diff --git a/.clang-tidy b/.clang-tidy index daacf4f00e..15d354a8c3 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -4,8 +4,8 @@ Checks: "-*, bugprone-assert-side-effect, bugprone-bad-signal-to-kill-thread, bugprone-bool-pointer-implicit-conversion, - bugprone-casting-through-void, bugprone-capturing-this-in-member-variable, + bugprone-casting-through-void, bugprone-chained-comparison, bugprone-compare-pointer-to-member-virtual-function, bugprone-copy-constructor-init, @@ -24,10 +24,10 @@ Checks: "-*, bugprone-lambda-function-name, bugprone-macro-parentheses, bugprone-macro-repeated-side-effects, + bugprone-misleading-setter-of-reference, bugprone-misplaced-operator-in-strlen-in-alloc, bugprone-misplaced-pointer-arithmetic-in-alloc, bugprone-misplaced-widening-cast, - bugprone-misleading-setter-of-reference, bugprone-move-forwarding-reference, bugprone-multi-level-implicit-pointer-conversion, bugprone-multiple-new-in-one-expression, @@ -73,10 +73,10 @@ Checks: "-*, bugprone-unhandled-self-assignment, bugprone-unique-ptr-array-mismatch, bugprone-unsafe-functions, - bugprone-use-after-move, + bugprone-unused-local-non-trivial-variable, bugprone-unused-raii, bugprone-unused-return-value, - bugprone-unused-local-non-trivial-variable, + bugprone-use-after-move, bugprone-virtual-near-miss, cppcoreguidelines-init-variables, cppcoreguidelines-misleading-capture-default-by-value, @@ -88,6 +88,7 @@ Checks: "-*, cppcoreguidelines-use-enum-class, cppcoreguidelines-virtual-class-destructor, hicpp-ignored-remove-result, + llvm-namespace-comment, misc-const-correctness, misc-definitions-in-headers, misc-header-include-cycle, @@ -99,6 +100,7 @@ Checks: "-*, misc-unused-alias-decls, misc-unused-using-decls, modernize-concat-nested-namespaces, + modernize-deprecated-headers, modernize-make-shared, modernize-make-unique, modernize-pass-by-value, @@ -114,8 +116,6 @@ Checks: "-*, modernize-use-starts-ends-with, modernize-use-std-numbers, modernize-use-using, - modernize-deprecated-headers, - llvm-namespace-comment, performance-faster-string-find, performance-for-range-copy, performance-implicit-conversion-in-loop, @@ -156,7 +156,13 @@ Checks: "-*, # readability-inconsistent-declaration-parameter-name, # in this codebase this check will break a lot of arg names # readability-static-accessed-through-instance, # this check is probably unnecessary. it makes the code less readable # --- + CheckOptions: + bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true + bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc + + misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h" + readability-braces-around-statements.ShortStatementLines: 2 readability-identifier-naming.MacroDefinitionCase: UPPER_CASE readability-identifier-naming.ClassCase: CamelCase @@ -191,9 +197,7 @@ CheckOptions: readability-identifier-naming.ProtectedMemberSuffix: _ readability-identifier-naming.PublicMemberSuffix: "" readability-identifier-naming.GlobalFunctionIgnoredRegexp: "^(to_string|hash_append|tuple_hash)$" - bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true - bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc - misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h" + HeaderFilterRegex: '^.*/(test|xrpl|xrpld)/.*\.(h|hpp|ipp)$' ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$' WarningsAsErrors: "*" diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs index 0cf704b051..d61cab7e03 100644 --- a/.git-blame-ignore-revs +++ b/.git-blame-ignore-revs @@ -5,6 +5,8 @@ # This file is sorted in reverse chronological order, with the most recent commits at the top. # The commits listed here are ignored by git blame, which is useful for formatting-only commits that would otherwise obscure the history of changes to a file. +# refactor: Enable clang-tidy `readability-identifier-naming` check (#6571) +8995564ed6b9e453e144bb663303072a3c1ba305 # refactor: Enable remaining clang-tidy `cppcoreguidelines` checks (#6538) 72f4cb097f626b08b02fc3efcb4aa11cb2e7adb8 # refactor: Rename system name from 'ripple' to 'xrpld' (#6347) diff --git a/.github/scripts/strategy-matrix/generate.py b/.github/scripts/strategy-matrix/generate.py index dec41a2610..6f00c69416 100755 --- a/.github/scripts/strategy-matrix/generate.py +++ b/.github/scripts/strategy-matrix/generate.py @@ -72,7 +72,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: skip = False if ( f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15" - and build_type == "Debug" + and build_type == "Release" and architecture["platform"] == "linux/amd64" ): skip = False @@ -90,8 +90,9 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: ): cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=1000 {cmake_args}" skip = False + elif os["distro_version"] == "trixie": if ( - f"{os['compiler_name']}-{os['compiler_version']}" == "clang-20" + f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22" and build_type == "Debug" and architecture["platform"] == "linux/amd64" ): @@ -188,8 +189,9 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: # We skip all clang 20+ on arm64 due to Boost build error. if ( - f"{os['compiler_name']}-{os['compiler_version']}" - in ["clang-20", "clang-21"] + os["compiler_name"] == "clang" + and os["compiler_version"].isdigit() + and int(os["compiler_version"]) >= 20 and architecture["platform"] == "linux/arm64" ): continue @@ -238,13 +240,14 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: # Add Address and UB sanitizers as separate configurations for specific # bookworm distros. Thread sanitizer is currently disabled (see below). # GCC-Asan xrpld-embedded tests are failing because of https://github.com/google/sanitizers/issues/856 - if os[ - "distro_version" - ] == "bookworm" and f"{os['compiler_name']}-{os['compiler_version']}" in [ - "gcc-15", - "clang-20", - ]: - # Add ASAN configuration. + if ( + os["distro_version"] == "bookworm" + and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15" + ) or ( + os["distro_version"] == "trixie" + and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22" + ): + # Add ASAN and UBSAN configurations for both gcc-15 and clang-22 configurations.append( { "config_name": config_name + "-asan", @@ -257,7 +260,6 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: "sanitizers": "address", } ) - # Add UBSAN configuration. configurations.append( { "config_name": config_name + "-ubsan", diff --git a/.github/scripts/strategy-matrix/linux.json b/.github/scripts/strategy-matrix/linux.json index 4943579be8..1b9af523cb 100644 --- a/.github/scripts/strategy-matrix/linux.json +++ b/.github/scripts/strategy-matrix/linux.json @@ -15,196 +15,203 @@ "distro_version": "bookworm", "compiler_name": "gcc", "compiler_version": "12", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "gcc", "compiler_version": "13", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "gcc", "compiler_version": "14", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "gcc", "compiler_version": "15", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "clang", "compiler_version": "16", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "clang", "compiler_version": "17", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "clang", "compiler_version": "18", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "clang", "compiler_version": "19", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "bookworm", "compiler_name": "clang", "compiler_version": "20", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "trixie", "compiler_name": "gcc", "compiler_version": "14", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "trixie", "compiler_name": "gcc", "compiler_version": "15", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "trixie", "compiler_name": "clang", "compiler_version": "20", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "debian", "distro_version": "trixie", "compiler_name": "clang", "compiler_version": "21", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" + }, + { + "distro_name": "debian", + "distro_version": "trixie", + "compiler_name": "clang", + "compiler_version": "22", + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "8", "compiler_name": "gcc", "compiler_version": "14", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "8", "compiler_name": "clang", "compiler_version": "any", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "9", "compiler_name": "gcc", "compiler_version": "12", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "9", "compiler_name": "gcc", "compiler_version": "13", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "9", "compiler_name": "gcc", "compiler_version": "14", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "9", "compiler_name": "clang", "compiler_version": "any", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "10", "compiler_name": "gcc", "compiler_version": "14", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "rhel", "distro_version": "10", "compiler_name": "clang", "compiler_version": "any", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "ubuntu", "distro_version": "jammy", "compiler_name": "gcc", "compiler_version": "12", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "ubuntu", "distro_version": "noble", "compiler_name": "gcc", "compiler_version": "13", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "ubuntu", "distro_version": "noble", "compiler_name": "gcc", "compiler_version": "14", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "ubuntu", "distro_version": "noble", "compiler_name": "clang", "compiler_version": "16", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "ubuntu", "distro_version": "noble", "compiler_name": "clang", "compiler_version": "17", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "ubuntu", "distro_version": "noble", "compiler_name": "clang", "compiler_version": "18", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" }, { "distro_name": "ubuntu", "distro_version": "noble", "compiler_name": "clang", "compiler_version": "19", - "image_sha": "ab4d1f0" + "image_sha": "4c086b9" } ], "build_type": ["Debug", "Release"], diff --git a/.github/workflows/build-nix-image.yml b/.github/workflows/build-nix-image.yml new file mode 100644 index 0000000000..6554cf6c08 --- /dev/null +++ b/.github/workflows/build-nix-image.yml @@ -0,0 +1,101 @@ +name: Build Nix Docker image + +on: + push: + branches: + - develop + paths: + - ".github/workflows/build-nix-image.yml" + - "docker/nix.Dockerfile" + - "flake.nix" + - "flake.lock" + - "nix/**" + pull_request: + paths: + - ".github/workflows/build-nix-image.yml" + - "docker/nix.Dockerfile" + - "flake.nix" + - "flake.lock" + - "nix/**" + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +defaults: + run: + shell: bash + +env: + UBUNTU_VERSION: "20.04" + RHEL_VERSION: "9" + DEBIAN_VERSION: "bookworm" + +jobs: + build: + name: Build and push Nix image (${{ matrix.distro }}) + runs-on: ubuntu-latest + permissions: + contents: read + packages: write + strategy: + matrix: + include: + - distro: nixos + - distro: ubuntu + - distro: rhel + - distro: debian + + steps: + - name: Checkout repository + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - name: Determine base image + id: vars + run: | + case "${{ matrix.distro }}" in + nixos) + echo "base_image=nixos/nix:latest" >> $GITHUB_OUTPUT + ;; + ubuntu) + echo "base_image=ubuntu:${UBUNTU_VERSION}" >> $GITHUB_OUTPUT + ;; + rhel) + echo "base_image=registry.access.redhat.com/ubi${RHEL_VERSION}/ubi:latest" >> $GITHUB_OUTPUT + ;; + debian) + echo "base_image=debian:${DEBIAN_VERSION}" >> $GITHUB_OUTPUT + ;; + esac + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0 + + - name: Login to GitHub Container Registry + if: github.event_name == 'push' + uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0 + with: + registry: ghcr.io + username: ${{ github.repository_owner }} + password: ${{ secrets.GITHUB_TOKEN }} + + - name: Docker metadata + id: meta + uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0 + with: + images: ghcr.io/xrplf/ci/nix-${{ matrix.distro }} + tags: | + type=sha,prefix=sha-,format=short + type=raw,value=latest + + - name: Build and push + uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0 + with: + context: . + file: docker/nix.Dockerfile + platforms: linux/amd64 + push: ${{ github.event_name == 'push' }} + tags: ${{ steps.meta.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }} + build-args: BASE_IMAGE=${{ steps.vars.outputs.base_image }} diff --git a/.github/workflows/check-pr-title.yml b/.github/workflows/check-pr-title.yml index 6d7bdefa08..5631950df6 100644 --- a/.github/workflows/check-pr-title.yml +++ b/.github/workflows/check-pr-title.yml @@ -11,4 +11,4 @@ on: jobs: check_title: if: ${{ github.event.pull_request.draft != true }} - uses: XRPLF/actions/.github/workflows/check-pr-title.yml@a5d8dd35be543365e90a11358447130c8763871d + uses: XRPLF/actions/.github/workflows/check-pr-title.yml@291206777251b4d493641b5afbdf7c23009d2988 diff --git a/.github/workflows/on-pr.yml b/.github/workflows/on-pr.yml index 28299a1264..d95f3a6c00 100644 --- a/.github/workflows/on-pr.yml +++ b/.github/workflows/on-pr.yml @@ -58,15 +58,12 @@ jobs: # Keep the paths below in sync with those in `on-trigger.yml`. .github/actions/build-deps/** - .github/actions/build-test/** .github/actions/generate-version/** .github/actions/setup-conan/** .github/scripts/strategy-matrix/** - .github/workflows/reusable-build.yml .github/workflows/reusable-build-test-config.yml .github/workflows/reusable-build-test.yml .github/workflows/reusable-clang-tidy.yml - .github/workflows/reusable-clang-tidy-files.yml .github/workflows/reusable-strategy-matrix.yml .github/workflows/reusable-test.yml .github/workflows/reusable-upload-recipe.yml @@ -176,4 +173,4 @@ jobs: runs-on: ubuntu-latest steps: - name: Fail - run: false + run: exit 1 diff --git a/.github/workflows/on-trigger.yml b/.github/workflows/on-trigger.yml index 5856c67bd3..11d98bffb7 100644 --- a/.github/workflows/on-trigger.yml +++ b/.github/workflows/on-trigger.yml @@ -15,15 +15,12 @@ on: # Keep the paths below in sync with those in `on-pr.yml`. - ".github/actions/build-deps/**" - - ".github/actions/build-test/**" - ".github/actions/generate-version/**" - ".github/actions/setup-conan/**" - ".github/scripts/strategy-matrix/**" - - ".github/workflows/reusable-build.yml" - ".github/workflows/reusable-build-test-config.yml" - ".github/workflows/reusable-build-test.yml" - ".github/workflows/reusable-clang-tidy.yml" - - ".github/workflows/reusable-clang-tidy-files.yml" - ".github/workflows/reusable-strategy-matrix.yml" - ".github/workflows/reusable-test.yml" - ".github/workflows/reusable-upload-recipe.yml" diff --git a/.github/workflows/reusable-build-test-config.yml b/.github/workflows/reusable-build-test-config.yml index ae998faebd..4c7c41fd0c 100644 --- a/.github/workflows/reusable-build-test-config.yml +++ b/.github/workflows/reusable-build-test-config.yml @@ -143,7 +143,6 @@ jobs: working-directory: ${{ env.BUILD_DIR }} env: BUILD_TYPE: ${{ inputs.build_type }} - SANITIZERS: ${{ inputs.sanitizers }} CMAKE_ARGS: ${{ inputs.cmake_args }} run: | cmake \ @@ -182,7 +181,7 @@ jobs: - name: Build the binary working-directory: ${{ env.BUILD_DIR }} env: - BUILD_NPROC: ${{ steps.nproc.outputs.nproc }} + BUILD_NPROC: ${{ runner.os == 'Linux' && '16' || steps.nproc.outputs.nproc }} BUILD_TYPE: ${{ inputs.build_type }} CMAKE_TARGET: ${{ inputs.cmake_target }} run: | @@ -284,8 +283,16 @@ jobs: - name: Show test failure summary if: ${{ failure() && !inputs.build_only }} - working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }} + env: + WORKING_DIR: ${{ runner.os == 'Windows' && format('{0}\{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }} run: | + if [ ! -d "${WORKING_DIR}" ]; then + echo "Working directory '${WORKING_DIR}' does not exist." + exit 0 + fi + + cd "${WORKING_DIR}" + if [ ! -f unittest.log ]; then echo "unittest.log not found; embedded tests may not have run." exit 0 diff --git a/.github/workflows/reusable-clang-tidy-files.yml b/.github/workflows/reusable-clang-tidy-files.yml deleted file mode 100644 index 7b35b2d968..0000000000 --- a/.github/workflows/reusable-clang-tidy-files.yml +++ /dev/null @@ -1,175 +0,0 @@ -name: Run clang-tidy on files - -on: - workflow_call: - inputs: - files: - description: "List of files to check (empty means check all files)" - type: string - default: "" - create_issue_on_failure: - description: "Whether to create an issue if the check failed" - type: boolean - default: false - -defaults: - run: - shell: bash - -env: - # Conan installs the generators in the build/generators directory, see the - # layout() method in conanfile.py. We then run CMake from the build directory. - BUILD_DIR: build - BUILD_TYPE: Debug # Debug so that ASSERTS and such participate in clang-tidy check - -jobs: - run-clang-tidy: - name: Run clang tidy - runs-on: ["self-hosted", "Linux", "X64", "heavy"] - container: "ghcr.io/xrplf/ci/debian-trixie:clang-21-sha-53033a2" - permissions: - issues: write - contents: read - steps: - - name: Checkout repository - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - - - name: Prepare runner - uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab - with: - enable_ccache: false - - - name: Print build environment - uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574 - - - name: Get number of processors - uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf - id: nproc - - - name: Setup Conan - uses: ./.github/actions/setup-conan - - - name: Build dependencies - uses: ./.github/actions/build-deps - with: - build_nproc: ${{ steps.nproc.outputs.nproc }} - build_type: ${{ env.BUILD_TYPE }} - log_verbosity: verbose - - - name: Configure CMake - working-directory: ${{ env.BUILD_DIR }} - run: | - cmake \ - -G 'Ninja' \ - -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \ - -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \ - -Dtests=ON \ - -Dwerr=ON \ - -Dxrpld=ON \ - .. - - # clang-tidy needs headers generated from proto files - - name: Build libxrpl.libpb - working-directory: ${{ env.BUILD_DIR }} - run: | - ninja -j ${{ steps.nproc.outputs.nproc }} xrpl.libpb - - - name: Run clang tidy - id: run_clang_tidy - continue-on-error: true - env: - TARGETS: ${{ inputs.files != '' && inputs.files || 'src tests' }} - run: | - run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -fix -allow-no-checks ${TARGETS} 2>&1 | tee clang-tidy-output.txt - - - name: Upload clang-tidy output - if: ${{ github.event.repository.visibility == 'public' && steps.run_clang_tidy.outcome != 'success' }} - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 - with: - name: clang-tidy-results - path: clang-tidy-output.txt - retention-days: 30 - - - name: Generate git diff - if: ${{ steps.run_clang_tidy.outcome != 'success' }} - run: | - git diff | tee clang-tidy-git-diff.txt - - - name: Upload clang-tidy diff output - if: ${{ github.event.repository.visibility == 'public' && steps.run_clang_tidy.outcome != 'success' }} - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 - with: - name: clang-tidy-git-diff - path: clang-tidy-git-diff.txt - retention-days: 30 - - - name: Create an issue - if: ${{ steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure }} - id: create_issue - shell: bash - env: - GH_TOKEN: ${{ github.token }} - run: | - # Prepare issue body with clang-tidy output - cat > issue.md < filtered-output.txt || true - - # If filtered output is empty, use original (might be a different error format) - if [ ! -s filtered-output.txt ]; then - cp clang-tidy-output.txt filtered-output.txt - fi - - # Truncate if too large - head -c 60000 filtered-output.txt >> issue.md - if [ "$(wc -c < filtered-output.txt)" -gt 60000 ]; then - echo "" >> issue.md - echo "... (output truncated, see artifacts for full output)" >> issue.md - fi - - rm filtered-output.txt - else - echo "No output file found" >> issue.md - fi - - cat >> issue.md < create_issue.log - - created_issue="$(sed 's|.*/||' create_issue.log)" - echo "created_issue=$created_issue" >> $GITHUB_OUTPUT - echo "Created issue #$created_issue" - - rm -f create_issue.log issue.md clang-tidy-output.txt - - - name: Fail the workflow if clang-tidy failed - if: ${{ steps.run_clang_tidy.outcome != 'success' }} - run: | - echo "Clang-tidy check failed!" - exit 1 diff --git a/.github/workflows/reusable-clang-tidy.yml b/.github/workflows/reusable-clang-tidy.yml index 7a8bf6de57..e01a50cf6d 100644 --- a/.github/workflows/reusable-clang-tidy.yml +++ b/.github/workflows/reusable-clang-tidy.yml @@ -1,4 +1,4 @@ -name: Clang-tidy check +name: Run clang-tidy on files on: workflow_call: @@ -16,40 +16,175 @@ defaults: run: shell: bash +env: + BUILD_DIR: build + BUILD_TYPE: Debug # Debug so that ASSERTS and such participate in clang-tidy check + + OUTPUT_FILE: clang-tidy-output.txt + DIFF_FILE: clang-tidy-git-diff.txt + ISSUE_FILE: clang-tidy-issue.md + jobs: determine-files: - name: Determine files to check if: ${{ inputs.check_only_changed }} - runs-on: ubuntu-latest - outputs: - clang_tidy_config_changed: ${{ steps.changed_clang_tidy.outputs.any_changed }} - any_cpp_changed: ${{ steps.changed_files.outputs.any_changed }} - all_changed_files: ${{ steps.changed_files.outputs.all_changed_files }} + permissions: + contents: read + uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@224f3c48d3014d082a1129237b8291ff0b0a331f + + run-clang-tidy: + name: Run clang tidy + needs: [determine-files] + if: ${{ always() && !cancelled() && (!inputs.check_only_changed || needs.determine-files.outputs.cpp_changed_files != '' || needs.determine-files.outputs.clang_tidy_config_changed == 'true') }} + runs-on: ["self-hosted", "Linux", "X64", "heavy"] + container: "ghcr.io/xrplf/ci/debian-trixie:clang-21-sha-53033a2" + permissions: + contents: read + issues: write steps: - name: Checkout repository uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - - name: Get changed C++ files - id: changed_files - uses: tj-actions/changed-files@9426d40962ed5378910ee2e21d5f8c6fcbf2dd96 # v47.0.6 + - name: Prepare runner + uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab with: - files: | - **/*.cpp - **/*.h - **/*.ipp - separator: " " + enable_ccache: false - - name: Get changed clang-tidy configuration - id: changed_clang_tidy - uses: tj-actions/changed-files@9426d40962ed5378910ee2e21d5f8c6fcbf2dd96 # v47.0.6 + - name: Print build environment + uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574 + + - name: Get number of processors + uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf + id: nproc + + - name: Setup Conan + uses: ./.github/actions/setup-conan + + - name: Build dependencies + uses: ./.github/actions/build-deps with: - files: | - .clang-tidy + build_nproc: ${{ steps.nproc.outputs.nproc }} + build_type: ${{ env.BUILD_TYPE }} + log_verbosity: verbose - run-clang-tidy: - needs: [determine-files] - if: ${{ always() && !cancelled() && (!inputs.check_only_changed || needs.determine-files.outputs.any_cpp_changed == 'true' || needs.determine-files.outputs.clang_tidy_config_changed == 'true') }} - uses: ./.github/workflows/reusable-clang-tidy-files.yml - with: - files: ${{ (needs.determine-files.outputs.clang_tidy_config_changed != 'true' && inputs.check_only_changed) && needs.determine-files.outputs.all_changed_files || '' }} - create_issue_on_failure: ${{ inputs.create_issue_on_failure }} + - name: Configure CMake + working-directory: ${{ env.BUILD_DIR }} + run: | + cmake \ + -G 'Ninja' \ + -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \ + -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \ + -Dtests=ON \ + -Dwerr=ON \ + -Dxrpld=ON \ + .. + + # clang-tidy needs headers generated from proto files + - name: Build libxrpl.libpb + working-directory: ${{ env.BUILD_DIR }} + run: | + ninja -j ${{ steps.nproc.outputs.nproc }} xrpl.libpb + + - name: Run clang tidy + id: run_clang_tidy + continue-on-error: true + env: + TARGETS: ${{ (needs.determine-files.outputs.clang_tidy_config_changed != 'true' && inputs.check_only_changed) && needs.determine-files.outputs.cpp_changed_files || 'src tests' }} + run: | + set -o pipefail + run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -fix -allow-no-checks ${TARGETS} 2>&1 | tee "${OUTPUT_FILE}" + + - name: Print errors + if: ${{ steps.run_clang_tidy.outcome != 'success' }} + run: | + sed '/error\||/!d' "${OUTPUT_FILE}" + + - name: Upload clang-tidy output + if: ${{ github.event.repository.visibility == 'public' && steps.run_clang_tidy.outcome != 'success' }} + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + path: ${{ env.OUTPUT_FILE }} + archive: false + retention-days: 30 + + - name: Check for changes + id: files_changed + continue-on-error: true + run: | + git diff --exit-code + + - name: Fix style + if: ${{ steps.files_changed.outcome != 'success' }} + run: | + pre-commit run --all-files || true + + - name: Generate git diff + if: ${{ steps.files_changed.outcome != 'success' }} + run: | + git diff | tee "${DIFF_FILE}" + + - name: Upload clang-tidy diff output + if: ${{ github.event.repository.visibility == 'public' && steps.files_changed.outcome != 'success' }} + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + path: ${{ env.DIFF_FILE }} + archive: false + retention-days: 30 + + - name: Write issue header + if: ${{ steps.run_clang_tidy.outcome != 'success' }} + run: | + cat > "${ISSUE_FILE}" < filtered-output.txt || true + + # If filtered output is empty, use original (might be a different error format) + if [ ! -s filtered-output.txt ]; then + cp "${OUTPUT_FILE}" filtered-output.txt + fi + + # Truncate if too large + head -c 60000 filtered-output.txt >> "${ISSUE_FILE}" + if [ "$(wc -c < filtered-output.txt)" -gt 60000 ]; then + echo "" >> "${ISSUE_FILE}" + echo "... (output truncated, see artifacts for full output)" >> "${ISSUE_FILE}" + fi + + rm filtered-output.txt + else + echo "No output file found" >> "${ISSUE_FILE}" + fi + + - name: Append issue footer + if: ${{ steps.run_clang_tidy.outcome != 'success' }} + run: | + cat >> "${ISSUE_FILE}" < +# +# If set to 0, the server will skip validation of endpoint +# addresses received in TMEndpoints peer protocol messages, +# allowing addresses that are not publicly routable or have a +# port of 0. The default is 1 (verification enabled). +# +# WARNING: Disabling this option is a security risk and should +# only be used for local testing and debugging. Do not disable +# on mainnet. +# # # [transaction_queue] EXPERIMENTAL # @@ -1258,7 +1269,7 @@ # default. Don't change this without understanding the consequences. # # Example: -# account_reserve = 10000000 # 10 XRP +# account_reserve = 1000000 # 1 XRP # # owner_reserve = # @@ -1270,7 +1281,7 @@ # default. Don't change this without understanding the consequences. # # Example: -# owner_reserve = 2000000 # 2 XRP +# owner_reserve = 200000 # 0.2 XRP # #------------------------------------------------------------------------------- # diff --git a/cmake/XrplSanitizers.cmake b/cmake/XrplSanitizers.cmake index 2228381286..64f1841bfb 100644 --- a/cmake/XrplSanitizers.cmake +++ b/cmake/XrplSanitizers.cmake @@ -1,140 +1,33 @@ #[===================================================================[ - Configure sanitizers based on environment variables. + Apply sanitizer flags built by the Conan profile. - This module reads the following environment variables: - - SANITIZERS: The sanitizers to enable. Possible values: - - "address" - - "address,undefinedbehavior" - - "thread" - - "thread,undefinedbehavior" - - "undefinedbehavior" + Parsing, validation, and flag construction are performed in conan/profiles/sanitizers. + This module reads the following CMake variables injected by the Conan toolchain via extra_variables: - The compiler type and platform are detected in CompilationEnv.cmake. - The sanitizer compile options are applied to the 'common' interface library - which is linked to all targets in the project. + - SANITIZERS: The active sanitizers (e.g. "address,undefinedbehavior"). + - SANITIZERS_COMPILER_FLAGS: Space-separated compiler flags. + - SANITIZERS_LINKER_FLAGS: Space-separated linker flags. - Internal flag variables set by this module: - - - SANITIZER_TYPES: List of sanitizer types to enable (e.g., "address", - "thread", "undefined"). And two more flags for undefined behavior sanitizer (e.g., "float-divide-by-zero", "unsigned-integer-overflow"). - This list is joined with commas and passed to -fsanitize=. - - - SANITIZERS_COMPILE_FLAGS: Compiler flags for sanitizer instrumentation. - Includes: - * -fno-omit-frame-pointer: Preserves frame pointers for stack traces - * -O1: Minimum optimization for reasonable performance - * -fsanitize=: Enables sanitizer instrumentation - * -fsanitize-ignorelist=: (Clang only) Compile-time ignorelist - * -mcmodel=large/medium: (GCC only) Code model for large binaries - * -Wno-stringop-overflow: (GCC only) Suppresses false positive warnings - * -Wno-tsan: (For GCC TSAN combination only) Suppresses atomic_thread_fence warnings - - - SANITIZERS_LINK_FLAGS: Linker flags for sanitizer runtime libraries. - Includes: - * -fsanitize=: Links sanitizer runtime libraries - * -mcmodel=large/medium: (GCC only) Matches compile-time code model - - - SANITIZERS_RELOCATION_FLAGS: (GCC only, x86_64 only) Code model flags for linking. - Used to handle large instrumented binaries on x86_64: - * -mcmodel=large: For AddressSanitizer (prevents relocation errors) - * -mcmodel=medium: For ThreadSanitizer (large model is incompatible) - On ARM64, these flags are omitted since GCC does not support - -mcmodel=large with -fPIC, and -mcmodel=medium does not exist. + The flags are applied to the 'common' interface library which is linked to all targets in the project. #]===================================================================] +include_guard(GLOBAL) include(CompilationEnv) -# Read environment variable -set(SANITIZERS "") -if(DEFINED ENV{SANITIZERS}) - set(SANITIZERS "$ENV{SANITIZERS}") -endif() - -# Set SANITIZERS_ENABLED flag for use in other modules -if(SANITIZERS MATCHES "address|thread|undefinedbehavior") - set(SANITIZERS_ENABLED TRUE) -else() +if(NOT DEFINED SANITIZERS) set(SANITIZERS_ENABLED FALSE) return() endif() +set(SANITIZERS_ENABLED TRUE) -# Sanitizers are not supported on Windows/MSVC -if(is_msvc) - message( - FATAL_ERROR - "Sanitizers are not supported on Windows/MSVC. " - "Please unset the SANITIZERS environment variable." - ) -endif() +message(STATUS "=== Configuring Sanitizers ===") +message(STATUS " SANITIZERS: ${SANITIZERS}") +message(STATUS " Compile flags: ${SANITIZERS_COMPILER_FLAGS}") +message(STATUS " Link flags: ${SANITIZERS_LINKER_FLAGS}") -message(STATUS "Configuring sanitizers: ${SANITIZERS}") - -# Parse SANITIZERS value to determine which sanitizers to enable -set(enable_asan FALSE) -set(enable_tsan FALSE) -set(enable_ubsan FALSE) - -# Normalize SANITIZERS into a list -set(san_list "${SANITIZERS}") -string(REPLACE "," ";" san_list "${san_list}") -separate_arguments(san_list) - -foreach(san IN LISTS san_list) - if(san STREQUAL "address") - set(enable_asan TRUE) - elseif(san STREQUAL "thread") - set(enable_tsan TRUE) - elseif(san STREQUAL "undefinedbehavior") - set(enable_ubsan TRUE) - else() - message( - FATAL_ERROR - "Unsupported sanitizer type: ${san}" - "Supported: address, thread, undefinedbehavior and their combinations." - ) - endif() -endforeach() - -# Validate sanitizer compatibility -if(enable_asan AND enable_tsan) - message( - FATAL_ERROR - "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. " - "Use 'address' or 'thread', optionally with 'undefinedbehavior'." - ) -endif() - -# Frame pointer is required for meaningful stack traces. Sanitizers recommend minimum of -O1 for reasonable performance -set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1") - -# Build the sanitizer flags list -set(SANITIZER_TYPES) - -if(enable_asan) - list(APPEND SANITIZER_TYPES "address") -elseif(enable_tsan) - list(APPEND SANITIZER_TYPES "thread") -endif() - -if(enable_ubsan) - # UB sanitizer flags - list(APPEND SANITIZER_TYPES "undefined" "float-divide-by-zero") - if(is_clang) - # Clang supports additional UB checks. More info here - # https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html - list(APPEND SANITIZER_TYPES "unsigned-integer-overflow") - endif() -endif() - -# Configure code model for GCC on amd64 Use large code model for ASAN to avoid relocation errors Use medium code model -# for TSAN (large is not compatible with TSAN) -set(SANITIZERS_RELOCATION_FLAGS) - -# Compiler-specific configuration +# GCC with sanitizers is incompatible with mold, gold, and lld linkers. +# Namely, the instrumented binary exceeds size limits imposed by these linkers. if(is_gcc) - # Disable mold, gold and lld linkers for GCC with sanitizers Use default linker (bfd/ld) which is more lenient with - # mixed code models This is needed since the size of instrumented binary exceeds the limits set by mold, lld and - # gold linkers set(use_mold OFF CACHE BOOL "Use mold linker" FORCE) set(use_gold OFF CACHE BOOL "Use gold linker" FORCE) set(use_lld OFF CACHE BOOL "Use lld linker" FORCE) @@ -142,82 +35,62 @@ if(is_gcc) STATUS " Disabled mold, gold, and lld linkers for GCC with sanitizers" ) - - # Suppress false positive warnings in GCC with stringop-overflow - list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-stringop-overflow") - - if(is_amd64 AND enable_asan) - message(STATUS " Using large code model (-mcmodel=large)") - list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=large") - list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=large") - elseif(enable_tsan) - # GCC doesn't support atomic_thread_fence with tsan. Suppress warnings. - list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-tsan") - if(is_amd64) - message(STATUS " Using medium code model (-mcmodel=medium)") - list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=medium") - list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=medium") - endif() - endif() - - # Join sanitizer flags with commas for -fsanitize option - list(JOIN SANITIZER_TYPES "," SANITIZER_TYPES_STR) - - # Add sanitizer to compile and link flags - list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}") - set(SANITIZERS_LINK_FLAGS - "${SANITIZERS_RELOCATION_FLAGS}" - "-fsanitize=${SANITIZER_TYPES_STR}" - ) -elseif(is_clang) - # Add ignorelist for Clang (GCC doesn't support this) Use CMAKE_SOURCE_DIR to get the path to the ignorelist - set(IGNORELIST_PATH - "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt" - ) - if(NOT EXISTS "${IGNORELIST_PATH}") - message( - FATAL_ERROR - "Sanitizer ignorelist not found: ${IGNORELIST_PATH}" - ) - endif() - - list( - APPEND SANITIZERS_COMPILE_FLAGS - "-fsanitize-ignorelist=${IGNORELIST_PATH}" - ) - message(STATUS " Using sanitizer ignorelist: ${IGNORELIST_PATH}") - - # Join sanitizer flags with commas for -fsanitize option - list(JOIN SANITIZER_TYPES "," SANITIZER_TYPES_STR) - - # Add sanitizer to compile and link flags - list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}") - set(SANITIZERS_LINK_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}") endif() -message(STATUS " Compile flags: ${SANITIZERS_COMPILE_FLAGS}") -message(STATUS " Link flags: ${SANITIZERS_LINK_FLAGS}") +# Flags arrive as space-separated strings; split into CMake lists before use +separate_arguments( + sanitizers_compiler_flags + UNIX_COMMAND + "${SANITIZERS_COMPILER_FLAGS}" +) +separate_arguments( + sanitizers_linker_flags + UNIX_COMMAND + "${SANITIZERS_LINKER_FLAGS}" +) -# Apply the sanitizer flags to the 'common' interface library This is the same library used by XrplCompiler.cmake target_compile_options( common INTERFACE - $<$:${SANITIZERS_COMPILE_FLAGS}> - $<$:${SANITIZERS_COMPILE_FLAGS}> + $<$:${sanitizers_compiler_flags}> + $<$:${sanitizers_compiler_flags}> ) +target_link_options(common INTERFACE ${sanitizers_linker_flags}) -# Apply linker flags -target_link_options(common INTERFACE ${SANITIZERS_LINK_FLAGS}) +# This module appends -fsanitize-ignorelist= for Clang builds. +# The ignorelist path contains CMAKE_SOURCE_DIR, so it must be set here, rather than in the Conan profile. +# GCC does not support -fsanitize-ignorelist. +if(is_clang) + set(ignorelist_path + "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt" + ) + if(NOT EXISTS "${ignorelist_path}") + message( + FATAL_ERROR + "Sanitizer ignorelist not found: ${ignorelist_path}" + ) + endif() + target_compile_options( + common + INTERFACE + $<$:-fsanitize-ignorelist=${ignorelist_path}> + $<$:-fsanitize-ignorelist=${ignorelist_path}> + ) + message(STATUS " Ignorelist: ${ignorelist_path}") +endif() # Define SANITIZERS macro for BuildInfo.cpp set(sanitizers_list) -if(enable_asan) +if(SANITIZERS MATCHES "address") + set(enable_asan ON) list(APPEND sanitizers_list "ASAN") endif() -if(enable_tsan) +if(SANITIZERS MATCHES "thread") + set(enable_tsan ON) list(APPEND sanitizers_list "TSAN") endif() -if(enable_ubsan) +if(SANITIZERS MATCHES "undefinedbehavior") + set(enable_ubsan ON) list(APPEND sanitizers_list "UBSAN") endif() diff --git a/cmake/scripts/codegen/requirements.txt b/cmake/scripts/codegen/requirements.txt index 40b472078d..d799fd60fd 100644 --- a/cmake/scripts/codegen/requirements.txt +++ b/cmake/scripts/codegen/requirements.txt @@ -10,4 +10,4 @@ pcpp>=1.30 pyparsing>=3.0.0 # Template engine - used to generate C++ code from templates -Mako>=1.2.0 +Mako>=1.2.2 diff --git a/conan.lock b/conan.lock index f1d6ed3fa5..e2eb8d871a 100644 --- a/conan.lock +++ b/conan.lock @@ -1,38 +1,38 @@ { "version": "0.5", "requires": [ - "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809", + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503", "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987", - "sqlite3/3.51.0#66aa11eabd0e34954c5c1c061ad44abe%1774467355.988", + "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1776096494.149", "soci/4.0.3#fe32b9ad5eb47e79ab9e45a68f363945%1774450067.231", "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1765850147.878", "secp256k1/0.7.1#481881709eb0bdd0185a12b912bbe8ad%1770910500.329", "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1765850186.86", "re2/20251105#8579cfd0bda4daf0683f9e3898f964b4%1774398111.888", "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12", - "openssl/3.6.1#e6399de266349245a4542fc5f6c71552%1774458290.139", - "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1774883011.384", + "openssl/3.6.2#4789bbf131b77d0515d15e094c8f697f%1778071755.506", + "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1775040983.408", "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914", "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492", "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03", - "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1765850144.736", - "jemalloc/5.3.0#e951da9cf599e956cebc117880d2d9f8%1729241615.244", + "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1776147552.838", + "jemalloc/5.3.1#1fc58d55316041f10fbc1e8a2eae632a%1776700028.228", "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1768312129.152", "grpc/1.78.1#b1a9e74b145cc471bed4dc64dc6eb2c1%1774467387.342", "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1765850143.772", "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772", "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1774439234.681", "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837", - "boost/1.90.0#d5e8defe7355494953be18524a7f135b%1769454080.269", + "boost/1.91.0#ea540ca2133d831b560036aa24dece3c%1778050991.9", "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196" ], "build_requires": [ - "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809", + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503", "strawberryperl/5.32.1.1#8d114504d172cfea8ea1662d09b6333e%1774447376.964", "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12", "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1765850144.707", "msys2/cci.latest#d22fe7b2808f5fd34d0a7923ace9c54f%1770657326.649", - "m4/1.4.19#5d7a4994e5875d76faf7acf3ed056036%1774365463.87", + "m4/1.4.19#4523e4347b55cd26ae918bd5770cab9a%1778062762.471", "cmake/4.3.0#b939a42e98f593fb34d3a8c5cc860359%1774439249.183", "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1774439233.447", "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56", @@ -48,13 +48,13 @@ "lz4/1.10.0" ], "boost/[>=1.83.0 <1.91.0]": [ - "boost/1.90.0" + "boost/1.91.0" ], "sqlite3/[>=3.44 <4]": [ - "sqlite3/3.51.0" + "sqlite3/3.53.0" ], "boost/1.83.0": [ - "boost/1.90.0" + "boost/1.91.0" ], "lz4/[>=1.9.4 <2]": [ "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504" diff --git a/conan/global.conf b/conan/global.conf index 37b329a5c5..cc803dc801 100644 --- a/conan/global.conf +++ b/conan/global.conf @@ -3,3 +3,5 @@ core:non_interactive=True core.download:parallel={{ os.cpu_count() }} core.upload:parallel={{ os.cpu_count() }} +tools.files.download:retry=5 +tools.files.download:retry_wait=10 diff --git a/conan/profiles/ci b/conan/profiles/ci index c4c0898ad5..ae93187026 100644 --- a/conan/profiles/ci +++ b/conan/profiles/ci @@ -1 +1 @@ - include(sanitizers) +include(sanitizers) diff --git a/conan/profiles/sanitizers b/conan/profiles/sanitizers index 800e6eb48c..4a05fda734 100644 --- a/conan/profiles/sanitizers +++ b/conan/profiles/sanitizers @@ -3,96 +3,120 @@ include(default) {% set arch = detect_api.detect_arch() %} {% set sanitizers = os.getenv("SANITIZERS") %} -[conf] -{% if sanitizers %} - {% if compiler == "gcc" %} - {% if "address" in sanitizers or "thread" in sanitizers or "undefinedbehavior" in sanitizers %} - {% set sanitizer_list = [] %} - {% set defines = [] %} - {% set model_code = "" %} - {% set extra_cxxflags = ["-fno-omit-frame-pointer", "-O1", "-Wno-stringop-overflow"] %} +{% if not sanitizers %} +{# Sanitizers not configured; no additional settings needed #} +{% else %} - {% if "address" in sanitizers %} - {% set _ = sanitizer_list.append("address") %} - {% if arch == "x86_64" %} - {% set model_code = "-mcmodel=large" %} - {% endif %} - {% set _ = defines.append("BOOST_USE_ASAN")%} - {% set _ = defines.append("BOOST_USE_UCONTEXT")%} - {% elif "thread" in sanitizers %} - {% set _ = sanitizer_list.append("thread") %} - {% if arch == "x86_64" %} - {% set model_code = "-mcmodel=medium" %} - {% endif %} - {% set _ = extra_cxxflags.append("-Wno-tsan") %} - {% set _ = defines.append("BOOST_USE_TSAN")%} - {% set _ = defines.append("BOOST_USE_UCONTEXT")%} - {% endif %} +{% if compiler == "msvc" %} + {{ "Sanitizers are not supported on Windows/MSVC. Please unset the SANITIZERS environment variable." }} +{% endif %} - {% if "undefinedbehavior" in sanitizers %} - {% set _ = sanitizer_list.append("undefined") %} - {% set _ = sanitizer_list.append("float-divide-by-zero") %} - {% endif %} +{% set known_sanitizers = ["address", "thread", "undefinedbehavior"] %} +{% set provided_sanitizers = [] %} +{% for san in sanitizers.split(",") %} + {% set san = san.strip() %} + {% if san not in known_sanitizers %} + {{ "Unknown sanitizer in SANITIZERS: " ~ san }} + {% endif %} + {% set _ = provided_sanitizers.append(san) %} +{% endfor %} - {% set sanitizer_flags = "-fsanitize=" ~ ",".join(sanitizer_list) ~ " " ~ model_code %} +{% set enable_asan = "address" in provided_sanitizers %} +{% set enable_tsan = "thread" in provided_sanitizers %} +{% set enable_ubsan = "undefinedbehavior" in provided_sanitizers %} - tools.build:cxxflags+=['{{sanitizer_flags}} {{" ".join(extra_cxxflags)}}'] - tools.build:sharedlinkflags+=['{{sanitizer_flags}}'] - tools.build:exelinkflags+=['{{sanitizer_flags}}'] - tools.build:defines+={{defines}} - {% endif %} - {% elif compiler == "apple-clang" or compiler == "clang" %} - {% if "address" in sanitizers or "thread" in sanitizers or "undefinedbehavior" in sanitizers %} - {% set sanitizer_list = [] %} - {% set defines = [] %} - {% set extra_cxxflags = ["-fno-omit-frame-pointer", "-O1"] %} +{% if enable_asan and enable_tsan %} + {{ "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously." }} +{% endif %} - {% if "address" in sanitizers %} - {% set _ = sanitizer_list.append("address") %} - {% set _ = defines.append("BOOST_USE_ASAN")%} - {% set _ = defines.append("BOOST_USE_UCONTEXT")%} - {% elif "thread" in sanitizers %} - {% set _ = sanitizer_list.append("thread") %} - {% set _ = defines.append("BOOST_USE_TSAN")%} - {% set _ = defines.append("BOOST_USE_UCONTEXT")%} - {% endif %} +{% set sanitizer_types = [] %} +{% set defines = [] %} - {% if "undefinedbehavior" in sanitizers %} - {% set _ = sanitizer_list.append("undefined") %} - {% set _ = sanitizer_list.append("float-divide-by-zero") %} - {% set _ = sanitizer_list.append("unsigned-integer-overflow") %} - {% endif %} +{% if enable_asan %} + {% set _ = sanitizer_types.append("address") %} + {% set _ = defines.append("BOOST_USE_ASAN") %} + {% set _ = defines.append("BOOST_USE_UCONTEXT") %} +{% elif enable_tsan %} + {% set _ = sanitizer_types.append("thread") %} + {% set _ = defines.append("BOOST_USE_TSAN") %} + {% set _ = defines.append("BOOST_USE_UCONTEXT") %} +{% endif %} - {% set sanitizer_flags = "-fsanitize=" ~ ",".join(sanitizer_list) %} - - tools.build:cxxflags+=['{{sanitizer_flags}} {{" ".join(extra_cxxflags)}}'] - tools.build:sharedlinkflags+=['{{sanitizer_flags}}'] - tools.build:exelinkflags+=['{{sanitizer_flags}}'] - tools.build:defines+={{defines}} - {% endif %} +{% if enable_ubsan %} + {% set _ = sanitizer_types.append("undefined") %} + {% set _ = sanitizer_types.append("float-divide-by-zero") %} + {# Clang supports additional UB checks beyond the GCC baseline #} + {% if compiler == "clang" or compiler == "apple-clang" %} + {% set _ = sanitizer_types.append("unsigned-integer-overflow") %} {% endif %} {% endif %} +{# Frame pointer required for meaningful stack traces; -O1 for reasonable performance #} +{% set compile_flags = ["-fno-omit-frame-pointer", "-O1"] %} + +{% if compiler == "gcc" %} + {# Suppress false positive warnings with GCC #} + {% set _ = compile_flags.append("-Wno-stringop-overflow") %} + + {% set relocation_flags = [] %} + + {% if arch == "x86_64" and enable_asan %} + {# Large code model prevents relocation errors in instrumented ASAN binaries #} + {% set _ = compile_flags.append("-mcmodel=large") %} + {% set _ = relocation_flags.append("-mcmodel=large") %} + {% elif enable_tsan %} + {# GCC doesn't support atomic_thread_fence with TSAN; suppress warnings #} + {% set _ = compile_flags.append("-Wno-tsan") %} + {% if arch == "x86_64" %} + {# Medium code model for TSAN; large is incompatible #} + {% set _ = compile_flags.append("-mcmodel=medium") %} + {% set _ = relocation_flags.append("-mcmodel=medium") %} + {% endif %} + {% endif %} + + {% set fsanitize = "-fsanitize=" ~ ",".join(sanitizer_types) %} + {% set _ = compile_flags.append(fsanitize) %} + {% set _ = relocation_flags.append(fsanitize) %} + + {% set sanitizer_compiler_flags = " ".join(compile_flags) %} + {% set sanitizer_linker_flags = " ".join(relocation_flags) %} +{% elif compiler == "clang" or compiler == "apple-clang" %} + {% set fsanitize = "-fsanitize=" ~ ",".join(sanitizer_types) %} + {% set _ = compile_flags.append(fsanitize) %} + + {% set sanitizer_compiler_flags = " ".join(compile_flags) %} + {% set sanitizer_linker_flags = fsanitize %} +{% endif %} + +[conf] +tools.build:defines+={{defines}} +tools.build:cxxflags+=['{{sanitizer_compiler_flags}}'] +tools.build:sharedlinkflags+=['{{sanitizer_linker_flags}}'] +tools.build:exelinkflags+=['{{sanitizer_linker_flags}}'] + tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags", "tools.build:defines"] +# &: means "apply only to the consumer/root package" +&:tools.cmake.cmaketoolchain:extra_variables={"SANITIZERS": "{{sanitizers}}", "SANITIZERS_COMPILER_FLAGS": "{{sanitizer_compiler_flags}}", "SANITIZERS_LINKER_FLAGS": "{{sanitizer_linker_flags}}"} + [options] -{% if sanitizers %} - {% if "address" in sanitizers %} - # Build Boost.Context with ucontext backend (not fcontext) so that - # ASAN fiber-switching annotations (__sanitizer_start/finish_switch_fiber) - # are compiled into the library. fcontext (assembly) has no ASAN support. - # define=BOOST_USE_ASAN=1 is critical: it must be defined when building - # Boost.Context itself so the ucontext backend compiles in the ASAN annotations. - boost/*:extra_b2_flags=context-impl=ucontext address-sanitizer=on define=BOOST_USE_ASAN=1 - boost/*:without_context=False - # Boost stacktrace fails to build with some sanitizers - boost/*:without_stacktrace=True - {% elif "thread" in sanitizers %} - # Build Boost.Context with ucontext backend for TSAN. fcontext (assembly) - # has no TSAN annotations, so without this the BOOST_USE_TSAN/BOOST_USE_UCONTEXT - # defines in [conf] would be ineffective. - boost/*:extra_b2_flags=context-impl=ucontext thread-sanitizer=on define=BOOST_USE_TSAN=1 - boost/*:without_context=False - boost/*:without_stacktrace=True - {% endif %} +{% if enable_asan %} + # Build Boost.Context with ucontext backend (not fcontext) so that + # ASAN fiber-switching annotations (__sanitizer_start/finish_switch_fiber) + # are compiled into the library. fcontext (assembly) has no ASAN support. + # define=BOOST_USE_ASAN=1 is critical: it must be defined when building + # Boost.Context itself so the ucontext backend compiles in the ASAN annotations. + boost/*:extra_b2_flags=context-impl=ucontext address-sanitizer=on define=BOOST_USE_ASAN=1 + boost/*:without_context=False + # Boost stacktrace fails to build with some sanitizers + boost/*:without_stacktrace=True +{% elif enable_tsan %} + # Build Boost.Context with ucontext backend for TSAN. fcontext (assembly) + # has no TSAN annotations, so without this the BOOST_USE_TSAN/BOOST_USE_UCONTEXT + # defines in [conf] would be ineffective. + boost/*:extra_b2_flags=context-impl=ucontext thread-sanitizer=on define=BOOST_USE_TSAN=1 + boost/*:without_context=False + boost/*:without_stacktrace=True +{% endif %} + {% endif %} diff --git a/conanfile.py b/conanfile.py index 66de2e2d57..2cf5aefbc2 100644 --- a/conanfile.py +++ b/conanfile.py @@ -1,4 +1,3 @@ -import os import re from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout @@ -30,12 +29,12 @@ class Xrpl(ConanFile): requires = [ "ed25519/2015.03", "grpc/1.78.1", - "libarchive/3.8.1", + "libarchive/3.8.7", "nudb/2.0.9", - "openssl/3.6.1", + "openssl/3.6.2", "secp256k1/0.7.1", "soci/4.0.3", - "zlib/1.3.1", + "zlib/1.3.2", ] test_requires = [ @@ -57,6 +56,7 @@ class Xrpl(ConanFile): "tests": False, "unity": False, "xrpld": False, + "boost/*:without_cobalt": True, "boost/*:without_context": False, "boost/*:without_coroutine": True, "boost/*:without_coroutine2": False, @@ -130,13 +130,13 @@ class Xrpl(ConanFile): self.options["boost"].without_cobalt = True def requirements(self): - self.requires("boost/1.90.0", force=True, transitive_headers=True) + self.requires("boost/1.91.0", force=True, transitive_headers=True) self.requires("date/3.0.4", transitive_headers=True) self.requires("lz4/1.10.0", force=True) self.requires("protobuf/6.33.5", force=True) - self.requires("sqlite3/3.51.0", force=True) + self.requires("sqlite3/3.53.0", force=True) if self.options.jemalloc: - self.requires("jemalloc/5.3.0") + self.requires("jemalloc/5.3.1") if self.options.rocksdb: self.requires("rocksdb/10.5.1") self.requires("xxhash/0.8.3", transitive_headers=True) diff --git a/cspell.config.yaml b/cspell.config.yaml index 028f02191e..bc56ef5d79 100644 --- a/cspell.config.yaml +++ b/cspell.config.yaml @@ -63,6 +63,7 @@ words: - Bougalis - Britto - Btrfs + - Buildx - canonicality - changespq - checkme @@ -71,6 +72,7 @@ words: - citardauq - clawback - clawbacks + - cmaketoolchain - coeffs - coldwallet - compr @@ -114,6 +116,7 @@ words: - gcovr - ghead - Gnutella + - godexsoft - gpgcheck - gpgkey - hotwallet @@ -151,6 +154,7 @@ words: - lseq - lsmf - ltype + - mathbunnyru - mcmodel - MEMORYSTATUSEX - MPTAMM @@ -322,3 +326,4 @@ words: - xrplf - xxhash - xxhasher + - CGNAT diff --git a/docker/nix.Dockerfile b/docker/nix.Dockerfile new file mode 100644 index 0000000000..52faa8b8dc --- /dev/null +++ b/docker/nix.Dockerfile @@ -0,0 +1,66 @@ +ARG BASE_IMAGE=nixos/nix:latest + +# Nix builder +FROM nixos/nix:latest AS builder-source + +RUN mkdir -p ~/.config/nix && \ + echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf + +# Copy our source and setup our working dir. +COPY nix/ci-env.nix /tmp/build/nix/ci-env.nix +COPY nix/packages.nix /tmp/build/nix/packages.nix +COPY nix/utils.nix /tmp/build/nix/utils.nix +COPY flake.nix /tmp/build/ +COPY flake.lock /tmp/build/ +WORKDIR /tmp/build + +FROM builder-source AS builder + +# Build our Nix CI environment (all build tools in a single store path) +RUN nix \ + --option filter-syscalls false \ + build + +# Copy the Nix store closure into a directory. The Nix store closure is the +# entire set of Nix store values that we need for our build. +RUN mkdir /tmp/nix-store-closure && \ + cp -R $(nix-store -qR result/) /tmp/nix-store-closure + +# Final image +FROM ${BASE_IMAGE} + +# bash is not located at /bin/bash in nixos/nix, so we need to create a symlink to it. +RUN if [ -d /nix ]; then \ + ln -s /root/.nix-profile/bin/bash /bin/bash; \ + fi + +# Use Bash as the default shell for RUN commands, using the options +# `set -o errexit -o pipefail`, and as the entrypoint. +SHELL ["/bin/bash", "-e", "-o", "pipefail", "-c"] +ENTRYPOINT ["/bin/bash"] + +# Copy /nix/store and the env symlink tree +COPY --from=builder /tmp/nix-store-closure /nix/store +COPY --from=builder /tmp/build/result /nix/ci-env + +ENV PATH="/nix/ci-env/bin:$PATH" + +RUN < [!CAUTION] +> Do not mix Address and Thread sanitizers - they are incompatible. +> Also, we don't yet support MSVC sanitizers, so this is only for Clang/GCC builds. + - [Sanitizer Configuration for Xrpld](#sanitizer-configuration-for-xrpld) - [Building with Sanitizers](#building-with-sanitizers) - [Summary](#summary) - [Build steps:](#build-steps) - [Install dependencies](#install-dependencies) - - [Call CMake](#call-cmake) - - [Build](#build) - [Running Tests with Sanitizers](#running-tests-with-sanitizers) - [AddressSanitizer (ASAN)](#addresssanitizer-asan) - [ThreadSanitizer (TSan)](#threadsanitizer-tsan) @@ -33,9 +35,13 @@ Corresponding suppression files are located in the `sanitizers/suppressions` dir Follow the same instructions as mentioned in [BUILD.md](../../BUILD.md) but with the following changes: 1. Make sure you have a clean build directory. -2. Set the `SANITIZERS` environment variable before calling conan install and cmake. Only set it once. Make sure both conan and cmake read the same values. +2. Set the `SANITIZERS` environment variable before calling `conan install`. Only set it once. Example: `export SANITIZERS=address,undefinedbehavior` -3. Optionally use `--profile:all sanitizers` with Conan to build dependencies with sanitizer instrumentation. [!NOTE]Building with sanitizer-instrumented dependencies is slower but produces fewer false positives. +3. Use `--profile:all sanitizers` with Conan to build dependencies with sanitizer instrumentation. + + > [!NOTE] + > Building with sanitizer-instrumented dependencies is slower but produces fewer false positives. + 4. Set `ASAN_OPTIONS`, `LSAN_OPTIONS`, `UBSAN_OPTIONS` and `TSAN_OPTIONS` environment variables to configure sanitizer behavior when running executables. [More details below](#running-tests-with-sanitizers). --- @@ -51,36 +57,13 @@ cd .build #### Install dependencies -The `SANITIZERS` environment variable is used by both Conan and CMake. +The `SANITIZERS` environment variable is used during `conan install` command. ```bash -export SANITIZERS=address,undefinedbehavior -# Standard build (without instrumenting dependencies) -conan install .. --output-folder . --build missing --settings build_type=Debug - -# Or with sanitizer-instrumented dependencies (takes longer but fewer false positives) -conan install .. --output-folder . --profile:all sanitizers --build missing --settings build_type=Debug +SANITIZERS=address,undefinedbehavior conan install .. --output-folder . --build missing --settings build_type=Debug --profile:all sanitizers ``` -[!CAUTION] -Do not mix Address and Thread sanitizers - they are incompatible. - -Since you already set the `SANITIZERS` environment variable when running Conan, same values will be read for the next part. - -#### Call CMake - -```bash -cmake .. -G Ninja \ - -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \ - -DCMAKE_BUILD_TYPE=Debug \ - -Dtests=ON -Dxrpld=ON -``` - -#### Build - -```bash -cmake --build . --parallel 4 -``` +Proceed with the rest of the build instructions as mentioned in [BUILD.md](../../BUILD.md). ## Running Tests with Sanitizers diff --git a/flake.lock b/flake.lock index fd43f5b683..5ec053975d 100644 --- a/flake.lock +++ b/flake.lock @@ -2,11 +2,11 @@ "nodes": { "nixpkgs": { "locked": { - "lastModified": 1769461804, - "narHash": "sha256-6h5sROT/3CTHvzPy9koKBmoCa2eJKh4fzQK8eYFEgl8=", + "lastModified": 1777954456, + "narHash": "sha256-hGdgeU2Nk87RAuZyYjyDjFL6LK7dAZN5RE9+hrDTkDU=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "b579d443b37c9c5373044201ea77604e37e748c8", + "rev": "549bd84d6279f9852cae6225e372cc67fb91a4c1", "type": "github" }, "original": { @@ -15,9 +15,27 @@ "type": "indirect" } }, + "nixpkgs-glibc231": { + "flake": false, + "locked": { + "lastModified": 1593520194, + "narHash": "sha256-+TZW+2I7kLL9JglPNOagm1ywjf9ua0JYGoptq/dzVn0=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "9cd98386a38891d1074fc18036b842dc4416f562", + "type": "github" + }, + "original": { + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "9cd98386a38891d1074fc18036b842dc4416f562", + "type": "github" + } + }, "root": { "inputs": { - "nixpkgs": "nixpkgs" + "nixpkgs": "nixpkgs", + "nixpkgs-glibc231": "nixpkgs-glibc231" } } }, diff --git a/flake.nix b/flake.nix index 4c500f1933..18671bdf31 100644 --- a/flake.nix +++ b/flake.nix @@ -2,15 +2,24 @@ description = "Nix related things for xrpld"; inputs = { nixpkgs.url = "nixpkgs/nixos-unstable"; + # nixpkgs snapshot (2020-06-30) that shipped glibc 2.31 as the primary + # version — matches the system libc on Ubuntu 20.04 LTS. Imported + # manually (flake = false) because this revision predates nixpkgs' + # own flake.nix. + nixpkgs-glibc231 = { + url = "github:NixOS/nixpkgs/9cd98386a38891d1074fc18036b842dc4416f562"; + flake = false; + }; }; outputs = - { nixpkgs, ... }: + { nixpkgs, nixpkgs-glibc231, ... }: let - forEachSystem = (import ./nix/utils.nix { inherit nixpkgs; }).forEachSystem; + forEachSystem = import ./nix/utils.nix { inherit nixpkgs nixpkgs-glibc231; }; in { devShells = forEachSystem (import ./nix/devshell.nix); + packages = forEachSystem (import ./nix/ci-env.nix); formatter = forEachSystem ({ pkgs, ... }: pkgs.nixfmt); }; } diff --git a/include/xrpl/basics/Expected.h b/include/xrpl/basics/Expected.h index 74a0e76eef..3796151777 100644 --- a/include/xrpl/basics/Expected.h +++ b/include/xrpl/basics/Expected.h @@ -148,17 +148,23 @@ public: } [[nodiscard]] constexpr E const& - error() const + error() const& { return Base::error(); } - constexpr E& - error() + [[nodiscard]] constexpr E& + error() & { return Base::error(); } + [[nodiscard]] constexpr E&& + error() && + { + return std::move(Base::error()); + } + constexpr explicit operator bool() const { @@ -215,17 +221,23 @@ public: } [[nodiscard]] constexpr E const& - error() const + error() const& { return Base::error(); } - constexpr E& - error() + [[nodiscard]] constexpr E& + error() & { return Base::error(); } + [[nodiscard]] constexpr E&& + error() && + { + return std::move(Base::error()); + } + constexpr explicit operator bool() const { diff --git a/include/xrpl/basics/Log.h b/include/xrpl/basics/Log.h index 8e6532f7c0..82782ba314 100644 --- a/include/xrpl/basics/Log.h +++ b/include/xrpl/basics/Log.h @@ -10,24 +10,11 @@ #include #include #include +#include #include namespace xrpl { -// DEPRECATED use beast::severities::Severity instead -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum LogSeverity { - LSInvalid = -1, // used to indicate an invalid severity - LSTrace = 0, // Very low-level progress information, details inside - // an operation - LSDebug = 1, // Function-level progress information, operations - LSInfo = 2, // Server-level progress information, major operations - LSWarning = 3, // Conditions that warrant human attention, may indicate - // a problem - LSError = 4, // A condition that indicates a problem - LSFatal = 5 // A severe condition that indicates a server problem -}; - /** Manages partitions for logging. */ class Logs { @@ -39,17 +26,17 @@ private: std::string partition_; public: - Sink(std::string partition, beast::severities::Severity thresh, Logs& logs); + Sink(std::string partition, beast::Severity thresh, Logs& logs); Sink(Sink const&) = delete; Sink& operator=(Sink const&) = delete; void - write(beast::severities::Severity level, std::string const& text) override; + write(beast::Severity level, std::string const& text) override; void - writeAlways(beast::severities::Severity level, std::string const& text) override; + writeAlways(beast::Severity level, std::string const& text) override; }; /** Manages a system file containing logged output. @@ -136,12 +123,12 @@ private: std::mutex mutable mutex_; std::map, boost::beast::iless> sinks_; - beast::severities::Severity thresh_; + beast::Severity thresh_; File file_; bool silent_ = false; public: - Logs(beast::severities::Severity level); + Logs(beast::Severity level); Logs(Logs const&) = delete; Logs& @@ -161,18 +148,18 @@ public: beast::Journal journal(std::string const& name); - beast::severities::Severity + beast::Severity threshold() const; void - threshold(beast::severities::Severity thresh); + threshold(beast::Severity thresh); std::vector> partitionSeverities() const; void write( - beast::severities::Severity level, + beast::Severity level, std::string const& partition, std::string const& text, bool console); @@ -192,36 +179,25 @@ public: } virtual std::unique_ptr - makeSink(std::string const& partition, beast::severities::Severity startingLevel); + makeSink(std::string const& partition, beast::Severity startingLevel); public: - static LogSeverity - fromSeverity(beast::severities::Severity level); - - static beast::severities::Severity - toSeverity(LogSeverity level); - static std::string - toString(LogSeverity s); + toString(beast::Severity s); - static LogSeverity + static std::optional fromString(std::string const& s); private: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { - // Maximum line length for log messages. - // If the message exceeds this length it will be truncated with - // ellipses. - MaximumMessageCharacters = 12 * 1024 - }; + // Maximum line length for log messages. + // If the message exceeds this length it will be truncated with ellipses. + static constexpr auto kMAXIMUM_MESSAGE_CHARACTERS = 12 * 1024; static void format( std::string& output, std::string const& message, - beast::severities::Severity severity, + beast::Severity severity, std::string const& partition); }; diff --git a/include/xrpl/basics/SHAMapHash.h b/include/xrpl/basics/SHAMapHash.h index 3b93d1f151..76d9d4fa3d 100644 --- a/include/xrpl/basics/SHAMapHash.h +++ b/include/xrpl/basics/SHAMapHash.h @@ -21,12 +21,12 @@ public: } [[nodiscard]] uint256 const& - asUint256() const + asUInt256() const { return hash_; } uint256& - asUint256() + asUInt256() { return hash_; } @@ -93,7 +93,7 @@ template <> inline std::size_t extract(SHAMapHash const& key) { - return *reinterpret_cast(key.asUint256().data()); + return *reinterpret_cast(key.asUInt256().data()); } } // namespace xrpl diff --git a/include/xrpl/basics/StringUtilities.h b/include/xrpl/basics/StringUtilities.h index c9f26026be..f4bdd61f6a 100644 --- a/include/xrpl/basics/StringUtilities.h +++ b/include/xrpl/basics/StringUtilities.h @@ -7,9 +7,11 @@ #include #include +#include #include #include #include +#include namespace xrpl { @@ -26,28 +28,39 @@ namespace xrpl { std::string sqlBlobLiteral(Blob const& blob); +namespace detail { + +template +concept SomeChar = std::same_as, int8_t> || + std::same_as, char> || std::same_as, uint8_t>; + +inline constexpr std::array, 256> const kDIGIT_LOOKUP_TABLE = []() { + std::array, 256> t{}; + + for (int i = 0; i < 10; ++i) + t['0' + i] = i; + + for (int i = 0; i < 6; ++i) + { + t['A' + i] = 10 + i; + t['a' + i] = 10 + i; + } + + return t; +}(); + +inline std::optional +hexCharToInt(SomeChar auto hexChar) +{ + return kDIGIT_LOOKUP_TABLE[static_cast(hexChar)]; +} + +} // namespace detail + template std::optional strUnHex(std::size_t strSize, Iterator begin, Iterator end) { - static constexpr std::array const kDIGIT_LOOKUP_TABLE = []() { - std::array t{}; - - for (auto& x : t) - x = -1; - - for (int i = 0; i < 10; ++i) - t['0' + i] = i; - - for (int i = 0; i < 6; ++i) - { - t['A' + i] = 10 + i; - t['a' + i] = 10 + i; - } - - return t; - }(); - Blob out; out.reserve((strSize + 1) / 2); @@ -56,27 +69,26 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end) if (strSize & 1) { - int c = kDIGIT_LOOKUP_TABLE[*iter++]; - - if (c < 0) + auto const c = detail::hexCharToInt(*iter++); + if (!c.has_value()) return {}; - out.push_back(c); + out.push_back(static_cast(*c)); } while (iter != end) { - int const cHigh = kDIGIT_LOOKUP_TABLE[*iter++]; + auto const cHigh = detail::hexCharToInt(*iter++); - if (cHigh < 0) + if (!cHigh.has_value()) return {}; - int const cLow = kDIGIT_LOOKUP_TABLE[*iter++]; + auto const cLow = detail::hexCharToInt(*iter++); - if (cLow < 0) + if (!cLow.has_value()) return {}; - out.push_back(static_cast((cHigh << 4) | cLow)); + out.push_back(static_cast((*cHigh << 4) | *cLow)); } return {std::move(out)}; @@ -120,7 +132,7 @@ std::string trimWhitespace(std::string str); std::optional -toUint64(std::string const& s); +toUInt64(std::string const& s); /** Determines if the given string looks like a TOML-file hosting domain. diff --git a/include/xrpl/basics/base_uint.h b/include/xrpl/basics/base_uint.h index 15fc4f6966..727768a69a 100644 --- a/include/xrpl/basics/base_uint.h +++ b/include/xrpl/basics/base_uint.h @@ -46,6 +46,11 @@ struct IsContiguousContainer : std::true_type { }; +template +struct AlwaysFalseT : std::bool_constant +{ +}; + } // namespace detail /** Integers of any length that is a multiple of 32-bits @@ -62,7 +67,7 @@ struct IsContiguousContainer : std::true_type number of bits. */ template -class BaseUint +class BaseUInt { static_assert((Bits % 32) == 0, "The length of a base_uint in bits must be a multiple of 32."); @@ -160,7 +165,7 @@ private: explicit VoidHelper() = default; }; - explicit BaseUint(void const* data, VoidHelper) + explicit BaseUInt(void const* data, VoidHelper) { memcpy(data_.data(), data, kBYTES); } @@ -244,15 +249,15 @@ private: } public: - constexpr BaseUint() : data_{} + constexpr BaseUInt() : data_{} { } - constexpr BaseUint(beast::Zero) : data_{} + constexpr BaseUInt(beast::Zero) : data_{} { } - explicit BaseUint(std::uint64_t b) + explicit BaseUInt(std::uint64_t b) { *this = b; } @@ -260,7 +265,7 @@ public: // This constructor is intended to be used at compile time since it might // throw at runtime. Consider declaring this constructor consteval once // we get to C++23. - explicit constexpr BaseUint(std::string_view sv) noexcept(false) + explicit constexpr BaseUInt(std::string_view sv) noexcept(false) : data_(parseFromStringViewThrows(sv)) { } @@ -270,24 +275,42 @@ public: class = std::enable_if_t< detail::IsContiguousContainer::value && std::is_trivially_copyable_v>> - explicit BaseUint(Container const& c) + explicit BaseUInt(Container const& c) { + // Use AlwaysFalseT so the static_assert condition is dependent + // and only triggers when this constructor template is instantiated. + static_assert( + detail::AlwaysFalseT::value, + "This constructor is not intended to be used and will be soon removed. " + "Use base_uint::fromRaw instead."); + } + + template < + class Container, + class = std::enable_if_t< + detail::IsContiguousContainer::value && + std::is_trivially_copyable_v>> + static BaseUInt + fromRaw(Container const& c) + { + BaseUInt result; XRPL_ASSERT( c.size() * sizeof(typename Container::value_type) == size(), - "xrpl::base_uint::base_uint(Container auto) : input size match"); - std::memcpy(data_.data(), c.data(), size()); + "xrpl::BaseUInt::fromRaw(Container auto) : input size match"); + std::memcpy(result.data_.data(), c.data(), size()); + return result; } template std::enable_if_t< detail::IsContiguousContainer::value && std::is_trivially_copyable_v, - BaseUint&> + BaseUInt&> operator=(Container const& c) { XRPL_ASSERT( c.size() * sizeof(typename Container::value_type) == size(), - "xrpl::base_uint::operator=(Container auto) : input size match"); + "xrpl::BaseUInt::operator=(Container auto) : input size match"); std::memcpy(data_.data(), c.data(), size()); return *this; } @@ -295,14 +318,14 @@ public: /* Construct from a raw pointer. The buffer pointed to by `data` must be at least Bits/8 bytes. */ - static BaseUint + static BaseUInt fromVoid(void const* data) { - return BaseUint(data, VoidHelper()); + return BaseUInt(data, VoidHelper()); } template - static std::optional + static std::optional fromVoidChecked(T const& from) { if (from.size() != size()) @@ -328,10 +351,10 @@ public: return *this == beast::kZERO; } - constexpr BaseUint + constexpr BaseUInt operator~() const { - BaseUint ret; + BaseUInt ret; for (int i = 0; i < kWIDTH; i++) ret.data_[i] = ~data_[i]; @@ -339,7 +362,7 @@ public: return ret; } - BaseUint& + BaseUInt& operator=(std::uint64_t uHost) { *this = beast::kZERO; @@ -357,8 +380,8 @@ public: return *this; } - BaseUint& - operator^=(BaseUint const& b) + BaseUInt& + operator^=(BaseUInt const& b) { for (int i = 0; i < kWIDTH; i++) data_[i] ^= b.data_[i]; @@ -366,8 +389,8 @@ public: return *this; } - BaseUint& - operator&=(BaseUint const& b) + BaseUInt& + operator&=(BaseUInt const& b) { for (int i = 0; i < kWIDTH; i++) data_[i] &= b.data_[i]; @@ -375,8 +398,8 @@ public: return *this; } - BaseUint& - operator|=(BaseUint const& b) + BaseUInt& + operator|=(BaseUInt const& b) { for (int i = 0; i < kWIDTH; i++) data_[i] |= b.data_[i]; @@ -384,7 +407,7 @@ public: return *this; } - BaseUint& + BaseUInt& operator++() { // prefix operator @@ -398,17 +421,17 @@ public: return *this; } - BaseUint + BaseUInt operator++(int) { // postfix operator - BaseUint const ret = *this; + BaseUInt const ret = *this; ++(*this); return ret; } - BaseUint& + BaseUInt& operator--() { for (int i = kWIDTH - 1; i >= 0; --i) @@ -423,32 +446,32 @@ public: return *this; } - BaseUint + BaseUInt operator--(int) { // postfix operator - BaseUint const ret = *this; + BaseUInt const ret = *this; --(*this); return ret; } - [[nodiscard]] BaseUint + [[nodiscard]] BaseUInt next() const { auto ret = *this; return ++ret; } - [[nodiscard]] BaseUint + [[nodiscard]] BaseUInt prev() const { auto ret = *this; return --ret; } - BaseUint& - operator+=(BaseUint const& b) + BaseUInt& + operator+=(BaseUInt const& b) { std::uint64_t carry = 0; @@ -466,7 +489,7 @@ public: template friend void - hash_append(Hasher& h, BaseUint const& a) noexcept + hash_append(Hasher& h, BaseUInt const& a) noexcept { // Do not allow any endian transformations on this memory h(a.data_.data(), sizeof(a.data_)); @@ -509,7 +532,7 @@ public: return kBYTES; } - BaseUint& + BaseUInt& operator=(beast::Zero) { data_.fill(0); @@ -534,14 +557,14 @@ public: } }; -using uint128 = BaseUint<128>; -using uint160 = BaseUint<160>; -using uint256 = BaseUint<256>; -using uint192 = BaseUint<192>; +using uint128 = BaseUInt<128>; +using uint160 = BaseUInt<160>; +using uint256 = BaseUInt<256>; +using uint192 = BaseUInt<192>; template [[nodiscard]] constexpr std::strong_ordering -operator<=>(BaseUint const& lhs, BaseUint const& rhs) +operator<=>(BaseUInt const& lhs, BaseUInt const& rhs) { // This comparison might seem wrong on a casual inspection because it // compares data internally stored as std::uint32_t byte-by-byte. But @@ -562,7 +585,7 @@ operator<=>(BaseUint const& lhs, BaseUint const& rhs) template [[nodiscard]] constexpr bool -operator==(BaseUint const& lhs, BaseUint const& rhs) +operator==(BaseUInt const& lhs, BaseUInt const& rhs) { return (lhs <=> rhs) == 0; } @@ -570,59 +593,59 @@ operator==(BaseUint const& lhs, BaseUint const& rhs) //------------------------------------------------------------------------------ template constexpr bool -operator==(BaseUint const& a, std::uint64_t b) +operator==(BaseUInt const& a, std::uint64_t b) { - return a == BaseUint(b); + return a == BaseUInt(b); } //------------------------------------------------------------------------------ template -constexpr BaseUint -operator^(BaseUint const& a, BaseUint const& b) +constexpr BaseUInt +operator^(BaseUInt const& a, BaseUInt const& b) { - return BaseUint(a) ^= b; + return BaseUInt(a) ^= b; } template -constexpr BaseUint -operator&(BaseUint const& a, BaseUint const& b) +constexpr BaseUInt +operator&(BaseUInt const& a, BaseUInt const& b) { - return BaseUint(a) &= b; + return BaseUInt(a) &= b; } template -constexpr BaseUint -operator|(BaseUint const& a, BaseUint const& b) +constexpr BaseUInt +operator|(BaseUInt const& a, BaseUInt const& b) { - return BaseUint(a) |= b; + return BaseUInt(a) |= b; } template -constexpr BaseUint -operator+(BaseUint const& a, BaseUint const& b) +constexpr BaseUInt +operator+(BaseUInt const& a, BaseUInt const& b) { - return BaseUint(a) += b; + return BaseUInt(a) += b; } //------------------------------------------------------------------------------ template inline std::string -to_string(BaseUint const& a) +to_string(BaseUInt const& a) { return strHex(a.cbegin(), a.cend()); } template inline std::string -toShortString(BaseUint const& a) +toShortString(BaseUInt const& a) { - static_assert(BaseUint::kBYTES > 4, "For 4 bytes or less, use a native type"); + static_assert(BaseUInt::kBYTES > 4, "For 4 bytes or less, use a native type"); return strHex(a.cbegin(), a.cbegin() + 4) + "..."; } template inline std::ostream& -operator<<(std::ostream& out, BaseUint const& u) +operator<<(std::ostream& out, BaseUInt const& u) { return out << to_string(u); } @@ -650,7 +673,7 @@ static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes"); namespace beast { template -struct IsUniquelyRepresented> : public std::true_type +struct IsUniquelyRepresented> : public std::true_type { explicit IsUniquelyRepresented() = default; }; diff --git a/include/xrpl/basics/partitioned_unordered_map.h b/include/xrpl/basics/partitioned_unordered_map.h index 5f32cca8af..3bf64985e5 100644 --- a/include/xrpl/basics/partitioned_unordered_map.h +++ b/include/xrpl/basics/partitioned_unordered_map.h @@ -236,7 +236,7 @@ public: map_.resize(partitions_); XRPL_ASSERT( partitions_, - "xrpl::partitioned_unordered_map::partitioned_unordered_map : " + "xrpl::PartitionedUnorderedMap::PartitionedUnorderedMap : " "nonzero partitions"); } diff --git a/include/xrpl/basics/random.h b/include/xrpl/basics/random.h index ca51ef9364..7dfade5bda 100644 --- a/include/xrpl/basics/random.h +++ b/include/xrpl/basics/random.h @@ -94,7 +94,7 @@ template std::enable_if_t && detail::is_engine::value, Integral> randInt(Engine& engine, Integral min, Integral max) { - XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs"); + XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs"); // This should have no state and constructing it should // be very cheap. If that turns out not to be the case diff --git a/include/xrpl/basics/safe_cast.h b/include/xrpl/basics/safe_cast.h index b9a7aa1fa0..e35495bcf7 100644 --- a/include/xrpl/basics/safe_cast.h +++ b/include/xrpl/basics/safe_cast.h @@ -81,7 +81,7 @@ safeDowncast(Src* s) noexcept return static_cast(s); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast) #else auto* result = dynamic_cast(s); - XRPL_ASSERT(result != nullptr, "xrpl::safe_downcast : pointer downcast is valid"); + XRPL_ASSERT(result != nullptr, "xrpl::safeDowncast : pointer downcast is valid"); return result; #endif } @@ -94,7 +94,7 @@ safeDowncast(Src& s) noexcept #ifndef NDEBUG XRPL_ASSERT( dynamic_cast>>(&s) != nullptr, - "xrpl::safe_downcast : reference downcast is valid"); + "xrpl::safeDowncast : reference downcast is valid"); #endif return static_cast(s); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast) } diff --git a/include/xrpl/basics/scope.h b/include/xrpl/basics/scope.h index 64f91727fa..cd2a5299b2 100644 --- a/include/xrpl/basics/scope.h +++ b/include/xrpl/basics/scope.h @@ -205,7 +205,7 @@ class ScopeUnlock public: explicit ScopeUnlock(std::unique_lock& lock) noexcept(true) : plock_(&lock) { - XRPL_ASSERT(plock_->owns_lock(), "xrpl::scope_unlock::scope_unlock : mutex must be locked"); + XRPL_ASSERT(plock_->owns_lock(), "xrpl::ScopeUnlock::ScopeUnlock : mutex must be locked"); plock_->unlock(); } diff --git a/include/xrpl/basics/spinlock.h b/include/xrpl/basics/spinlock.h index 3518b94680..2cc00efdef 100644 --- a/include/xrpl/basics/spinlock.h +++ b/include/xrpl/basics/spinlock.h @@ -103,7 +103,7 @@ public: { XRPL_ASSERT( index >= 0 && (mask_ != 0), - "xrpl::packed_spinlock::packed_spinlock : valid index and mask"); + "xrpl::PackedSpinlock::PackedSpinlock : valid index and mask"); } [[nodiscard]] bool diff --git a/include/xrpl/beast/asio/io_latency_probe.h b/include/xrpl/beast/asio/io_latency_probe.h index 4ba985e579..ce3929a394 100644 --- a/include/xrpl/beast/asio/io_latency_probe.h +++ b/include/xrpl/beast/asio/io_latency_probe.h @@ -15,7 +15,7 @@ namespace beast { /** Measures handler latency on an io_context queue. */ template -class IoLatencyProbe +class IOLatencyProbe { private: using duration = typename Clock::duration; @@ -30,12 +30,12 @@ private: bool cancel_{false}; public: - IoLatencyProbe(duration const& period, boost::asio::io_context& ios) + IOLatencyProbe(duration const& period, boost::asio::io_context& ios) : period_(period), ios_(ios), timer_(ios_) { } - ~IoLatencyProbe() + ~IOLatencyProbe() { std::unique_lock lock(mutex_); cancel(lock, true); @@ -85,7 +85,7 @@ public: { std::scoped_lock const lock(mutex_); if (cancel_) - throw std::logic_error("io_latency_probe is canceled"); + throw std::logic_error("IOLatencyProbe is canceled"); boost::asio::post( ios_, SampleOp(std::forward(handler), Clock::now(), false, this)); } @@ -100,7 +100,7 @@ public: { std::scoped_lock const lock(mutex_); if (cancel_) - throw std::logic_error("io_latency_probe is canceled"); + throw std::logic_error("IOLatencyProbe is canceled"); boost::asio::post( ios_, SampleOp(std::forward(handler), Clock::now(), true, this)); } @@ -140,18 +140,18 @@ private: Handler handler; time_point start; bool repeat; - IoLatencyProbe* probe; + IOLatencyProbe* probe; SampleOp( Handler const& handler, time_point const& start, bool repeat, - IoLatencyProbe* probe) + IOLatencyProbe* probe) : handler(handler), start(start), repeat(repeat), probe(probe) { XRPL_ASSERT( probe, - "beast::io_latency_probe::sample_op::sample_op : non-null " + "beast::IOLatencyProbe::SampleOp::SampleOp : non-null " "probe input"); probe->addref(); } @@ -164,7 +164,7 @@ private: { XRPL_ASSERT( probe, - "beast::io_latency_probe::sample_op::sample_op(sample_op&&) : " + "beast::IOLatencyProbe::SampleOp::SampleOp(SampleOp&&) : " "non-null probe input"); from.probe = nullptr; } diff --git a/include/xrpl/beast/container/detail/aged_unordered_container.h b/include/xrpl/beast/container/detail/aged_unordered_container.h index 78a2a5a32d..7162c237d6 100644 --- a/include/xrpl/beast/container/detail/aged_unordered_container.h +++ b/include/xrpl/beast/container/detail/aged_unordered_container.h @@ -1370,7 +1370,7 @@ private: buck_.resize(size() + additional, cont_); XRPL_ASSERT( loadFactor() <= maxLoadFactor(), - "beast::detail::AgedUnorderedContainer::maybe_rehash : maximum " + "beast::detail::AgedUnorderedContainer::maybeRehash : maximum " "load factor"); } diff --git a/include/xrpl/beast/unit_test/reporter.h b/include/xrpl/beast/unit_test/reporter.h index d2ba624f4a..d9bfcaa477 100644 --- a/include/xrpl/beast/unit_test/reporter.h +++ b/include/xrpl/beast/unit_test/reporter.h @@ -62,9 +62,7 @@ private: { using run_time = std::pair; - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { MaxTop = 10 }; + static constexpr auto kMAX_TOP = 10; std::size_t suites = 0; std::size_t cases = 0; @@ -148,11 +146,11 @@ Reporter::Results::add(SuiteResults const& r) }); if (iter != top.end()) { - if (top.size() == MaxTop) + if (top.size() == kMAX_TOP) top.resize(top.size() - 1); top.emplace(iter, r.name, elapsed); } - else if (top.size() < MaxTop) + else if (top.size() < kMAX_TOP) { top.emplace_back(r.name, elapsed); } diff --git a/include/xrpl/beast/utility/Journal.h b/include/xrpl/beast/utility/Journal.h index 0fd0019235..1a0c148d1f 100644 --- a/include/xrpl/beast/utility/Journal.h +++ b/include/xrpl/beast/utility/Journal.h @@ -2,29 +2,25 @@ #include +#include #include namespace beast { -/** A namespace for easy access to logging severity values. */ -namespace severities { /** Severity level / threshold of a Journal message. */ -// Hundreds of usages via logging macros -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum Severity { - KAll = 0, +enum class Severity : std::uint8_t { + All = 0, - KTrace = KAll, - KDebug = 1, - KInfo = 2, - KWarning = 3, - KError = 4, - KFatal = 5, + Trace = All, + Debug = 1, + Info = 2, + Warning = 3, + Error = 4, + Fatal = 5, - KDisabled = 6, - KNone = KDisabled + Disabled = 6, + None = Disabled }; -} // namespace severities /** A generic endpoint for log messages. @@ -44,9 +40,6 @@ public: class Sink; private: - // Severity level / threshold of a Journal message. - using Severity = severities::Severity; - // Invariant: sink_ always points to a valid Sink Sink* sink_; @@ -183,7 +176,7 @@ public: { public: /** Create a stream which produces no output. */ - explicit Stream() : sink_(getNullSink()), level_(severities::KDisabled) + explicit Stream() : sink_(getNullSink()), level_(Severity::Disabled) { } @@ -194,7 +187,7 @@ public: Stream(Sink& sink, Severity level) : sink_(sink), level_(level) { XRPL_ASSERT( - level_ < severities::KDisabled, "beast::Journal::Stream::Stream : maximum level"); + level_ < Severity::Disabled, "beast::Journal::Stream::Stream : maximum level"); } /** Construct or copy another Stream. */ @@ -297,37 +290,37 @@ public: [[nodiscard]] Stream trace() const { - return {*sink_, severities::KTrace}; + return {*sink_, Severity::Trace}; } [[nodiscard]] Stream debug() const { - return {*sink_, severities::KDebug}; + return {*sink_, Severity::Debug}; } [[nodiscard]] Stream info() const { - return {*sink_, severities::KInfo}; + return {*sink_, Severity::Info}; } [[nodiscard]] Stream warn() const { - return {*sink_, severities::KWarning}; + return {*sink_, Severity::Warning}; } [[nodiscard]] Stream error() const { - return {*sink_, severities::KError}; + return {*sink_, Severity::Error}; } [[nodiscard]] Stream fatal() const { - return {*sink_, severities::KFatal}; + return {*sink_, Severity::Fatal}; } /** @} */ }; diff --git a/include/xrpl/beast/utility/WrappedSink.h b/include/xrpl/beast/utility/WrappedSink.h index 57f0a02413..22d75927fe 100644 --- a/include/xrpl/beast/utility/WrappedSink.h +++ b/include/xrpl/beast/utility/WrappedSink.h @@ -36,7 +36,7 @@ public: } [[nodiscard]] bool - active(beast::severities::Severity level) const override + active(beast::Severity level) const override { return sink_.active(level); } @@ -53,27 +53,27 @@ public: sink_.console(output); } - [[nodiscard]] beast::severities::Severity + [[nodiscard]] beast::Severity threshold() const override { return sink_.threshold(); } void - threshold(beast::severities::Severity thresh) override + threshold(beast::Severity thresh) override { sink_.threshold(thresh); } void - write(beast::severities::Severity level, std::string const& text) override + write(beast::Severity level, std::string const& text) override { using beast::Journal; sink_.write(level, prefix_ + text); } void - writeAlways(severities::Severity level, std::string const& text) override + writeAlways(Severity level, std::string const& text) override { using beast::Journal; sink_.writeAlways(level, prefix_ + text); diff --git a/include/xrpl/json/JsonPropertyStream.h b/include/xrpl/json/JsonPropertyStream.h index 47d3c9fdfa..47317b9ddb 100644 --- a/include/xrpl/json/JsonPropertyStream.h +++ b/include/xrpl/json/JsonPropertyStream.h @@ -5,7 +5,7 @@ namespace xrpl { -/** A PropertyStream::Sink which produces a json::Value of type objectValue. */ +/** A PropertyStream::Sink which produces a json::Value of type ValueType::Object. */ class JsonPropertyStream : public beast::PropertyStream { public: diff --git a/include/xrpl/json/json_reader.h b/include/xrpl/json/json_reader.h index 8ce565dbbc..ecd9ea7985 100644 --- a/include/xrpl/json/json_reader.h +++ b/include/xrpl/json/json_reader.h @@ -70,24 +70,22 @@ public: static constexpr unsigned kNEST_LIMIT{25}; private: - // 53 files, protocol-wide - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum TokenType { - TokenEndOfStream = 0, - TokenObjectBegin, - TokenObjectEnd, - TokenArrayBegin, - TokenArrayEnd, - TokenString, - TokenInteger, - TokenDouble, - TokenTrue, - TokenFalse, - TokenNull, - TokenArraySeparator, - TokenMemberSeparator, - TokenComment, - TokenError + enum class TokenType { + EndOfStream = 0, + ObjectBegin, + ObjectEnd, + ArrayBegin, + ArrayEnd, + String, + Integer, + Double, + True, + False, + Null, + ArraySeparator, + MemberSeparator, + Comment, + Error }; class Token diff --git a/include/xrpl/json/json_value.h b/include/xrpl/json/json_value.h index 2344da3788..a11090d98b 100644 --- a/include/xrpl/json/json_value.h +++ b/include/xrpl/json/json_value.h @@ -15,22 +15,20 @@ namespace json { /** \brief Type of the value held by a Value object. */ -// Used throughout JSON layer -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum ValueType { - NullValue = 0, ///< 'null' value - IntValue, ///< signed integer value - UintValue, ///< unsigned integer value - RealValue, ///< double value - StringValue, ///< UTF-8 string value - BooleanValue, ///< bool value - ArrayValue, ///< array value (ordered list) - ObjectValue ///< object value (collection of name/value pairs). +enum class ValueType { + Null = 0, ///< 'null' value + Int, ///< signed integer value + UInt, ///< unsigned integer value + Real, ///< double value + String, ///< UTF-8 string value + Boolean, ///< bool value + Array, ///< array value (ordered list) + Object ///< object value (collection of name/value pairs). }; /** \brief Lightweight wrapper to tag static string. * - * Value constructor and objectValue member assignment takes advantage of the + * Value constructor and ValueType::Object member assignment takes advantage of the * StaticString and avoid the cost of string duplication when storing the * string or the member name. * @@ -104,8 +102,8 @@ operator!=(StaticString x, std::string const& y) /** \brief Represents a JSON value. * * This class is a discriminated union wrapper that can represent a: - * - signed integer [range: Value::minInt - Value::maxInt] - * - unsigned integer (range: 0 - Value::maxUInt) + * - signed integer [range: Value::kMIN_INT - Value::kMAX_INT] + * - unsigned integer (range: 0 - Value::kMAX_UINT) * - double * - UTF-8 string * - boolean @@ -116,16 +114,16 @@ operator!=(StaticString x, std::string const& y) * The type of the held value is represented by a #ValueType and * can be obtained using type(). * - * values of an #objectValue or #arrayValue can be accessed using operator[]() - * methods. Non const methods will automatically create the a #nullValue element + * values of an ValueType::Object or ValueType::Array can be accessed using operator[]() + * methods. Non const methods will automatically create the a ValueType::Null element * if it does not exist. - * The sequence of an #arrayValue will be automatically resize and initialized - * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue. + * The sequence of an ValueType::Array will be automatically resize and initialized + * with ValueType::Null. resize() can be used to enlarge or truncate an ValueType::Array. * * The get() methods can be used to obtain a default value in the case the * required element does not exist. * - * It is possible to iterate over the list of a #objectValue values using + * It is possible to iterate over the list of a ValueType::Object values using * the getMemberNames() method. */ class Value @@ -143,15 +141,13 @@ public: static Value const kNULL; static constexpr Int kMIN_INT = std::numeric_limits::min(); static constexpr Int kMAX_INT = std::numeric_limits::max(); - static constexpr UInt kMAX_U_INT = std::numeric_limits::max(); + static constexpr UInt kMAX_UINT = std::numeric_limits::max(); private: class CZString { public: - // Stored as int field, implicit conversion - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum DuplicationPolicy { NoDuplication = 0, Duplicate, DuplicateOnCopy }; + enum class DuplicationPolicy { NoDuplication = 0, Duplicate, DuplicateOnCopy }; CZString(int index); CZString(char const* cstr, DuplicationPolicy allocate); @@ -182,19 +178,19 @@ public: /** \brief Create a default Value of the given type. This is a very useful constructor. - To create an empty array, pass arrayValue. - To create an empty object, pass objectValue. + To create an empty array, pass ValueType::Array. + To create an empty object, pass ValueType::Object. Another Value can then be set to this one by assignment. This is useful since clear() and resize() will not alter types. Examples: \code json::Value null_value; // null - json::Value arr_value(json::arrayValue); // [] - json::Value obj_value(json::objectValue); // {} + json::Value arr_value(json::ValueType::Array); // [] + json::Value obj_value(json::ValueType::Object); // {} \endcode */ - Value(ValueType type = NullValue); + Value(ValueType type = ValueType::Null); Value(Int value); Value(UInt value); Value(double value); @@ -290,7 +286,7 @@ public: operator bool() const; /// Remove all object members and array elements. - /// \pre type() is arrayValue, objectValue, or nullValue + /// \pre type() is ValueType::Array, ValueType::Object, or ValueType::Null /// \post type() is unchanged void clear(); @@ -367,7 +363,7 @@ public: /// /// Do nothing if it did not exist. /// \return the removed Value, or null. - /// \pre type() is objectValue or nullValue + /// \pre type() is ValueType::Object or ValueType::Null /// \post type() is unchanged Value removeMember(char const* key); @@ -388,8 +384,8 @@ public: /// \brief Return a list of the member names. /// /// If null, return an empty list. - /// \pre type() is objectValue or nullValue - /// \post if type() was nullValue, it remains nullValue + /// \pre type() is ValueType::Object or ValueType::Null + /// \post if type() was ValueType::Null, it remains ValueType::Null [[nodiscard]] Members getMemberNames() const; @@ -469,16 +465,14 @@ operator>=(Value const& x, Value const& y) * string value memory management done by Value. * * - makeMemberName() and releaseMemberName() are called to respectively - * duplicate and free an json::objectValue member name. + * duplicate and free an json::ValueType::Object member name. * - duplicateStringValue() and releaseStringValue() are called similarly to - * duplicate and free a json::stringValue value. + * duplicate and free a json::ValueType::String value. */ class ValueAllocator { public: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { Unknown = (unsigned)-1 }; + static constexpr auto kUNKNOWN = (unsigned)-1; virtual ~ValueAllocator() = default; @@ -487,7 +481,7 @@ public: virtual void releaseMemberName(char* memberName) = 0; virtual char* - duplicateStringValue(char const* value, unsigned int length = Unknown) = 0; + duplicateStringValue(char const* value, unsigned int length = kUNKNOWN) = 0; virtual void releaseStringValue(char* value) = 0; }; @@ -523,12 +517,12 @@ public: [[nodiscard]] Value key() const; - /// Return the index of the referenced Value. -1 if it is not an arrayValue. + /// Return the index of the referenced Value. -1 if it is not an ValueType::Array. [[nodiscard]] UInt index() const; /// Return the member name of the referenced Value. "" if it is not an - /// objectValue. + /// ValueType::Object. [[nodiscard]] char const* memberName() const; diff --git a/include/xrpl/json/json_writer.h b/include/xrpl/json/json_writer.h index 8e5e819b10..afc99fe8c9 100644 --- a/include/xrpl/json/json_writer.h +++ b/include/xrpl/json/json_writer.h @@ -204,31 +204,31 @@ writeValue(Write const& write, Value const& value) { switch (value.type()) { - case NullValue: + case ValueType::Null: write("null", 4); break; - case IntValue: + case ValueType::Int: writeString(write, valueToString(value.asInt())); break; - case UintValue: + case ValueType::UInt: writeString(write, valueToString(value.asUInt())); break; - case RealValue: + case ValueType::Real: writeString(write, valueToString(value.asDouble())); break; - case StringValue: + case ValueType::String: writeString(write, valueToQuotedString(value.asCString())); break; - case BooleanValue: + case ValueType::Boolean: writeString(write, valueToString(value.asBool())); break; - case ArrayValue: { + case ValueType::Array: { write("[", 1); int const size = value.size(); for (int index = 0; index < size; ++index) @@ -241,7 +241,7 @@ writeValue(Write const& write, Value const& value) break; } - case ObjectValue: { + case ValueType::Object: { Value::Members const members = value.getMemberNames(); write("{", 1); for (auto it = members.begin(); it != members.end(); ++it) diff --git a/include/xrpl/ledger/AmendmentTable.h b/include/xrpl/ledger/AmendmentTable.h index a15433813d..8ed3cb81ff 100644 --- a/include/xrpl/ledger/AmendmentTable.h +++ b/include/xrpl/ledger/AmendmentTable.h @@ -67,7 +67,7 @@ public: [[nodiscard]] virtual json::Value getJson(bool isAdmin) const = 0; - /** Returns a json::objectValue. */ + /** Returns a json::ValueType::Object. */ [[nodiscard]] virtual json::Value getJson(uint256 const& amendment, bool isAdmin) const = 0; diff --git a/include/xrpl/ledger/helpers/CredentialHelpers.h b/include/xrpl/ledger/helpers/CredentialHelpers.h index c60bd6c7fa..e06d225934 100644 --- a/include/xrpl/ledger/helpers/CredentialHelpers.h +++ b/include/xrpl/ledger/helpers/CredentialHelpers.h @@ -19,14 +19,10 @@ namespace credentials { // Check if credential sfExpiration field has passed ledger's parentCloseTime bool -checkExpired(std::shared_ptr const& sleCredential, NetClock::time_point const& closed); - -// Return true if any expired credential was found in arr (and deleted) -bool -removeExpired(ApplyView& view, STVector256 const& arr, beast::Journal const j); +checkExpired(SLE const& sleCredential, NetClock::time_point const& closed); // Actually remove a credentials object from the ledger -TER +[[nodiscard]] TER deleteSLE(ApplyView& view, std::shared_ptr const& sleCredential, beast::Journal j); // Amendment and parameters checks for sfCredentialIDs field diff --git a/include/xrpl/ledger/helpers/EscrowHelpers.h b/include/xrpl/ledger/helpers/EscrowHelpers.h index 5aa5214b1f..305834a6bc 100644 --- a/include/xrpl/ledger/helpers/EscrowHelpers.h +++ b/include/xrpl/ledger/helpers/EscrowHelpers.h @@ -70,21 +70,21 @@ escrowUnlockApplyHelper( initialBalance.get().account = noAccount(); if (TER const ter = trustCreate( - view, // payment sandbox - recvLow, // is dest low? - issuer, // source - receiver, // destination - trustLineKey.key, // ledger index - sleDest, // Account to add to - false, // authorize account - (sleDest->getFlags() & lsfDefaultRipple) == 0, // - false, // freeze trust line - false, // deep freeze trust line - initialBalance, // zero initial balance - Issue(currency, receiver), // limit of zero - 0, // quality in - 0, // quality out - journal); // journal + view, // payment sandbox + recvLow, // is dest low? + issuer, // source + receiver, // destination + trustLineKey.key, // ledger index + sleDest, // Account to add to + false, // authorize account + !sleDest->isFlag(lsfDefaultRipple), // + false, // freeze trust line + false, // deep freeze trust line + initialBalance, // zero initial balance + Issue(currency, receiver), // limit of zero + 0, // quality in + 0, // quality out + journal); // journal !isTesSuccess(ter)) { return ter; // LCOV_EXCL_LINE diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h index 83ce8e5efa..b9711c4053 100644 --- a/include/xrpl/ledger/helpers/LendingHelpers.h +++ b/include/xrpl/ledger/helpers/LendingHelpers.h @@ -184,6 +184,7 @@ checkLoanGuards( LoanState computeTheoreticalLoanState( + Rules const& rules, Number const& periodicPayment, Number const& periodicRate, std::uint32_t const paymentRemaining, @@ -353,6 +354,7 @@ struct LoanStateDeltas Expected, TER> tryOverpayment( + Rules const& rules, Asset const& asset, std::int32_t loanScale, ExtendedPaymentComponents const& overpaymentComponents, @@ -363,11 +365,17 @@ tryOverpayment( TenthBips16 const managementFeeRate, beast::Journal j); -Number -computeRaisedRate(Number const& periodicRate, std::uint32_t paymentsRemaining); +[[nodiscard]] Number +computePowerMinusOne(Number const& periodicRate, std::uint32_t paymentsRemaining); -Number -computePaymentFactor(Number const& periodicRate, std::uint32_t paymentsRemaining); +[[nodiscard]] Number +computePowerMinusOneHybrid(Number const& periodicRate, std::uint32_t paymentsRemaining); + +[[nodiscard]] Number +computePaymentFactor( + Rules const& rules, + Number const& periodicRate, + std::uint32_t paymentsRemaining); std::pair computeInterestAndFeeParts( @@ -378,12 +386,14 @@ computeInterestAndFeeParts( Number loanPeriodicPayment( + Rules const& rules, Number const& principalOutstanding, Number const& periodicRate, std::uint32_t paymentsRemaining); Number loanPrincipalFromPeriodicPayment( + Rules const& rules, Number const& periodicPayment, Number const& periodicRate, std::uint32_t paymentsRemaining); @@ -415,6 +425,7 @@ computeOverpaymentComponents( PaymentComponents computePaymentComponents( + Rules const& rules, Asset const& asset, std::int32_t scale, Number const& totalValueOutstanding, @@ -438,6 +449,7 @@ operator+(LoanState const& lhs, detail::LoanStateDeltas const& rhs); LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, TenthBips32 interestRate, @@ -448,6 +460,7 @@ computeLoanProperties( LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, Number const& periodicRate, diff --git a/include/xrpl/nodestore/Types.h b/include/xrpl/nodestore/Types.h index 2b5d9ac770..cf1a9db42e 100644 --- a/include/xrpl/nodestore/Types.h +++ b/include/xrpl/nodestore/Types.h @@ -6,20 +6,16 @@ namespace xrpl::NodeStore { -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - // This is only used to pre-allocate the array for - // batch objects and does not affect the amount written. - // - BatchWritePreallocationSize = 256, +// This is only used to pre-allocate the array for +// batch objects and does not affect the amount written. +// +static constexpr auto kBATCH_WRITE_PREALLOCATION_SIZE = 256; - // This sets a limit on the maximum number of writes - // in a batch. Actual usage can be twice this since - // we have a new batch growing as we write the old. - // - BatchWriteLimitSize = 65536 -}; +// This sets a limit on the maximum number of writes +// in a batch. Actual usage can be twice this since +// we have a new batch growing as we write the old. +// +static constexpr auto kBATCH_WRITE_LIMIT_SIZE = 65536; /** Return codes from Backend operations. */ enum class Status { diff --git a/include/xrpl/protocol/AccountID.h b/include/xrpl/protocol/AccountID.h index e22c3b8edd..0b15f651bc 100644 --- a/include/xrpl/protocol/AccountID.h +++ b/include/xrpl/protocol/AccountID.h @@ -25,7 +25,7 @@ public: } // namespace detail /** A 160-bit unsigned that uniquely identifies an account. */ -using AccountID = BaseUint<160, detail::AccountIDTag>; +using AccountID = BaseUInt<160, detail::AccountIDTag>; /** Convert AccountID to base58 checked string */ std::string diff --git a/include/xrpl/protocol/ApiVersion.h b/include/xrpl/protocol/ApiVersion.h index 3399152363..4d68cdaa5a 100644 --- a/include/xrpl/protocol/ApiVersion.h +++ b/include/xrpl/protocol/ApiVersion.h @@ -61,7 +61,7 @@ setVersion(json::Value& parent, unsigned int apiVersion, bool betaEnabled) { XRPL_ASSERT(apiVersion != kAPI_INVALID_VERSION, "xrpl::RPC::setVersion : input is valid"); - auto& retObj = parent[jss::version] = json::ObjectValue; + auto& retObj = parent[jss::version] = json::ValueType::Object; if (apiVersion == kAPI_VERSION_IF_UNSPECIFIED) { diff --git a/include/xrpl/protocol/PublicKey.h b/include/xrpl/protocol/PublicKey.h index 75b898a71c..16d558d73c 100644 --- a/include/xrpl/protocol/PublicKey.h +++ b/include/xrpl/protocol/PublicKey.h @@ -267,10 +267,10 @@ getOrThrow(json::Value const& v, xrpl::SField const& field) { using namespace xrpl; std::string const b58 = getOrThrow(v, field); - if (auto pubKeyBlob = strUnHex(b58); pubKeyBlob && publicKeyType(makeSlice(*pubKeyBlob))) + if (auto pubKeyBlob = strUnHex(b58); + pubKeyBlob.has_value() && publicKeyType(makeSlice(*pubKeyBlob))) { - return PublicKey{makeSlice( - *pubKeyBlob)}; // NOLINT(bugprone-unchecked-optional-access) checked in condition above + return PublicKey{makeSlice(*pubKeyBlob)}; } for (auto const tokenType : {TokenType::NodePublic, TokenType::AccountPublic}) { diff --git a/include/xrpl/protocol/SField.h b/include/xrpl/protocol/SField.h index 45e4d8932e..26f52cd6a9 100644 --- a/include/xrpl/protocol/SField.h +++ b/include/xrpl/protocol/SField.h @@ -129,23 +129,20 @@ fieldCode(int id, int index) class SField { public: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { - SMdNever = 0x00, - SMdChangeOrig = 0x01, // original value when it changes - SMdChangeNew = 0x02, // new value when it changes - SMdDeleteFinal = 0x04, // final value when it is deleted - SMdCreate = 0x08, // value when it's created - SMdAlways = 0x10, // value when node containing it is affected at all - SMdBaseTen = 0x20, // value is treated as base 10, overriding behavior - SMdPseudoAccount = 0x40, // if this field is set in an ACCOUNT_ROOT - // _only_, then it is a pseudo-account - SMdNeedsAsset = 0x80, // This field needs to be associated with an - // asset before it is serialized as a ledger - // object. Intended for STNumber. - SMdDefault = SMdChangeOrig | SMdChangeNew | SMdDeleteFinal | SMdCreate - }; + static constexpr auto kSMD_NEVER = 0x00; + static constexpr auto kSMD_CHANGE_ORIG = 0x01; // original value when it changes + static constexpr auto kSMD_CHANGE_NEW = 0x02; // new value when it changes + static constexpr auto kSMD_DELETE_FINAL = 0x04; // final value when it is deleted + static constexpr auto kSMD_CREATE = 0x08; // value when it's created + static constexpr auto kSMD_ALWAYS = 0x10; // value when node containing it is affected at all + static constexpr auto kSMD_BASE_TEN = 0x20; // value is treated as base 10, overriding behavior + static constexpr auto kSMD_PSEUDO_ACCOUNT = 0x40; // if this field is set in an ACCOUNT_ROOT + // _only_, then it is a pseudo-account + static constexpr auto kSMD_NEEDS_ASSET = 0x80; // This field needs to be associated with an + // asset before it is serialized as a ledger + // object. Intended for STNumber. + static constexpr auto kSMD_DEFAULT = + kSMD_CHANGE_ORIG | kSMD_CHANGE_NEW | kSMD_DELETE_FINAL | kSMD_CREATE; enum class IsSigning : unsigned char { No, Yes }; static IsSigning const kNOT_SIGNING = IsSigning::No; @@ -175,7 +172,7 @@ public: SerializedTypeID tid, int fv, char const* fn, - int meta = SMdDefault, + int meta = kSMD_DEFAULT, IsSigning signing = IsSigning::Yes); explicit SField(PrivateAccessTagT, int fc, char const* fn); diff --git a/include/xrpl/protocol/STAmount.h b/include/xrpl/protocol/STAmount.h index 7fa6ef88ae..f05d44441d 100644 --- a/include/xrpl/protocol/STAmount.h +++ b/include/xrpl/protocol/STAmount.h @@ -241,7 +241,7 @@ public: [[nodiscard]] std::string getText() const override; - [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::KNone) const override; + [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::Values::None) const override; void add(Serializer& s) const override; diff --git a/include/xrpl/protocol/STBase.h b/include/xrpl/protocol/STBase.h index cba0bfbe74..bfcc50d1ff 100644 --- a/include/xrpl/protocol/STBase.h +++ b/include/xrpl/protocol/STBase.h @@ -18,23 +18,23 @@ struct JsonOptions using underlying_t = unsigned int; underlying_t value; - // Bitwise flags with operator~ - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum Values : underlying_t { - // clang-format off - KNone = 0b0000'0000, - KIncludeDate = 0b0000'0001, - KDisableApiPriorV2 = 0b0000'0010, + enum class Values : underlying_t { + None = 0b0000'0000, + IncludeDate = 0b0000'0001, + DisableApiPriorV2 = 0b0000'0010, - // IMPORTANT `kALL` must be union of all of the above; see also operator~ - KAll = 0b0000'0011 - // clang-format on + // IMPORTANT `All` must be union of all of the above; see also operator~ + All = IncludeDate | DisableApiPriorV2 // 0b0000'0011 }; constexpr JsonOptions(underlying_t v) noexcept : value(v) { } + constexpr JsonOptions(Values v) noexcept : value(static_cast(v)) + { + } + [[nodiscard]] constexpr explicit operator underlying_t() const noexcept { @@ -69,18 +69,18 @@ struct JsonOptions [[nodiscard]] constexpr JsonOptions friend operator~(JsonOptions v) noexcept { - return {~v.value & static_cast(KAll)}; + return {~v.value & static_cast(Values::All)}; } }; template requires requires(T const& t) { - { t.getJson(JsonOptions::KNone) } -> std::convertible_to; + { t.getJson(JsonOptions::Values::None) } -> std::convertible_to; } json::Value toJson(T const& t) { - return t.getJson(JsonOptions::KNone); + return t.getJson(JsonOptions::Values::None); } namespace detail { @@ -148,7 +148,7 @@ public: [[nodiscard]] virtual std::string getText() const; - [[nodiscard]] virtual json::Value getJson(JsonOptions = JsonOptions::KNone) const; + [[nodiscard]] virtual json::Value getJson(JsonOptions = JsonOptions::Values::None) const; virtual void add(Serializer& s) const; diff --git a/include/xrpl/protocol/STBitString.h b/include/xrpl/protocol/STBitString.h index efb98cfe27..8a7e5a6030 100644 --- a/include/xrpl/protocol/STBitString.h +++ b/include/xrpl/protocol/STBitString.h @@ -16,7 +16,7 @@ class STBitString final : public STBase, public CountedObject> static_assert(Bits > 0, "Number of bits must be positive"); public: - using value_type = BaseUint; + using value_type = BaseUInt; private: value_type value_{}; @@ -46,7 +46,7 @@ public: template void - setValue(BaseUint const& v); + setValue(BaseUInt const& v); [[nodiscard]] value_type const& value() const; @@ -157,7 +157,7 @@ STBitString::add(Serializer& s) const template template void -STBitString::setValue(BaseUint const& v) +STBitString::setValue(BaseUInt const& v) { value_ = v; } diff --git a/include/xrpl/protocol/STLedgerEntry.h b/include/xrpl/protocol/STLedgerEntry.h index e37b132806..aa87411ae6 100644 --- a/include/xrpl/protocol/STLedgerEntry.h +++ b/include/xrpl/protocol/STLedgerEntry.h @@ -38,7 +38,7 @@ public: getText() const override; [[nodiscard]] json::Value - getJson(JsonOptions options = JsonOptions::KNone) const override; + getJson(JsonOptions options = JsonOptions::Values::None) const override; /** Returns the 'key' (or 'index') of this item. The key identifies this entry's position in diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h index a9e46e8717..c635e8ce22 100644 --- a/include/xrpl/protocol/STObject.h +++ b/include/xrpl/protocol/STObject.h @@ -132,7 +132,7 @@ public: getText() const override; // TODO(tom): options should be an enum. - [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::KNone) const override; + [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::Values::None) const override; void addWithoutSigningFields(Serializer& s) const; @@ -381,7 +381,7 @@ public: template void - setFieldH160(SField const& field, BaseUint<160, Tag> const& v); + setFieldH160(SField const& field, BaseUInt<160, Tag> const& v); STObject& peekFieldObject(SField const& field); @@ -1143,7 +1143,7 @@ STObject::at(OptionaledField const& of) -> OptionalProxy template void -STObject::setFieldH160(SField const& field, BaseUint<160, Tag> const& v) +STObject::setFieldH160(SField const& field, BaseUInt<160, Tag> const& v) { STBase* rf = getPField(field, true); diff --git a/include/xrpl/protocol/STParsedJSON.h b/include/xrpl/protocol/STParsedJSON.h index d5b4f33be7..04ffc624fb 100644 --- a/include/xrpl/protocol/STParsedJSON.h +++ b/include/xrpl/protocol/STParsedJSON.h @@ -6,6 +6,13 @@ namespace xrpl { +/** Maximum JSON object nesting depth permitted during parsing. */ +inline constexpr std::size_t kMAX_PARSED_JSON_DEPTH = 64; + +/** Maximum number of elements permitted in any JSON array field during parsing. + Requests exceeding this limit are rejected with an invalidParams error. */ +inline constexpr std::size_t kMAX_PARSED_JSON_ARRAY_SIZE = 512; + /** Holds the serialized result of parsing an input JSON object. This does validation and checking on the provided JSON. */ diff --git a/include/xrpl/protocol/STValidation.h b/include/xrpl/protocol/STValidation.h index 27d5ef1051..0b7f53eb55 100644 --- a/include/xrpl/protocol/STValidation.h +++ b/include/xrpl/protocol/STValidation.h @@ -161,7 +161,7 @@ STValidation::STValidation(SerialIter& sit, LookupNodeID&& lookupNodeID, bool ch if (checkSignature && !isValid()) { JLOG(debugLog().error()) << "Invalid signature in validation: " - << getJson(JsonOptions::KNone); + << getJson(JsonOptions::Values::None); Throw("Invalid signature in validation"); } diff --git a/include/xrpl/protocol/Serializer.h b/include/xrpl/protocol/Serializer.h index 385c09009a..81706e152a 100644 --- a/include/xrpl/protocol/Serializer.h +++ b/include/xrpl/protocol/Serializer.h @@ -102,7 +102,7 @@ public: template int - addBitString(BaseUint const& v) + addBitString(BaseUInt const& v) { return addRaw(v.data(), v.size()); } @@ -151,7 +151,7 @@ public: template bool - getBitString(BaseUint& data, int offset) const + getBitString(BaseUInt& data, int offset) const { auto success = (offset + (Bits / 8)) <= data_.size(); if (success) @@ -369,7 +369,7 @@ public: geti64(); template - BaseUint + BaseUInt getBitString(); uint128 @@ -428,7 +428,7 @@ public: }; template -BaseUint +BaseUInt SerialIter::getBitString() { auto const n = Bits / 8; @@ -442,7 +442,7 @@ SerialIter::getBitString() used_ += n; remain_ -= n; - return BaseUint::fromVoid(x); + return BaseUInt::fromVoid(x); } } // namespace xrpl diff --git a/include/xrpl/protocol/UintTypes.h b/include/xrpl/protocol/UintTypes.h index 6fb0648b5f..322c58ea1f 100644 --- a/include/xrpl/protocol/UintTypes.h +++ b/include/xrpl/protocol/UintTypes.h @@ -30,21 +30,21 @@ public: /** Directory is an index into the directory of offer books. The last 64 bits of this are the quality. */ -using Directory = BaseUint<256, detail::DirectoryTag>; +using Directory = BaseUInt<256, detail::DirectoryTag>; /** Currency is a hash representing a specific currency. */ -using Currency = BaseUint<160, detail::CurrencyTag>; +using Currency = BaseUInt<160, detail::CurrencyTag>; /** NodeID is a 160-bit hash representing one node. */ -using NodeID = BaseUint<160, detail::NodeIDTag>; +using NodeID = BaseUInt<160, detail::NodeIDTag>; /** MPTID is a 192-bit value representing MPT Issuance ID, * which is a concatenation of a 32-bit sequence (big endian) * and a 160-bit account */ -using MPTID = BaseUint<192>; +using MPTID = BaseUInt<192>; /** Domain is a 256-bit hash representing a specific domain. */ -using Domain = BaseUint<256>; +using Domain = BaseUInt<256>; /** XRP currency. */ Currency const& diff --git a/include/xrpl/protocol/detail/features.macro b/include/xrpl/protocol/detail/features.macro index 78b78e132e..fd62b74d59 100644 --- a/include/xrpl/protocol/detail/features.macro +++ b/include/xrpl/protocol/detail/features.macro @@ -15,11 +15,10 @@ // Add new amendments to the top of this list. // Keep it sorted in reverse chronological order. -XRPL_FIX (Cleanup3_2_0, Supported::No, VoteBehavior::DefaultNo) -XRPL_FEATURE(MPTokensV2, Supported::No, VoteBehavior::DefaultNo) -XRPL_FIX (Security3_1_3, Supported::No, VoteBehavior::DefaultNo) -XRPL_FIX (PermissionedDomainInvariant, Supported::Yes, VoteBehavior::DefaultNo) -XRPL_FIX (BatchInnerSigs, Supported::No, VoteBehavior::DefaultNo) +XRPL_FIX (Cleanup3_2_0, Supported::No, VoteBehavior::DefaultNo) +XRPL_FEATURE(MPTokensV2, Supported::No, VoteBehavior::DefaultNo) +XRPL_FIX (Cleanup3_1_3, Supported::Yes, VoteBehavior::DefaultYes) +XRPL_FIX (BatchInnerSigs, Supported::No, VoteBehavior::DefaultNo) XRPL_FEATURE(LendingProtocol, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FEATURE(PermissionDelegationV1_1, Supported::No, VoteBehavior::DefaultNo) XRPL_FIX (DirectoryLimit, Supported::Yes, VoteBehavior::DefaultNo) @@ -34,7 +33,7 @@ XRPL_FIX (EnforceNFTokenTrustlineV2, Supported::Yes, VoteBehavior::DefaultN XRPL_FIX (AMMv1_3, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FEATURE(PermissionedDEX, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FEATURE(Batch, Supported::No, VoteBehavior::DefaultNo) -XRPL_FEATURE(SingleAssetVault, Supported::Yes, VoteBehavior::DefaultNo) +XRPL_FEATURE(SingleAssetVault, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FIX (PayChanCancelAfter, Supported::Yes, VoteBehavior::DefaultNo) // Check flags in Credential transactions XRPL_FIX (InvalidTxFlags, Supported::Yes, VoteBehavior::DefaultNo) @@ -46,9 +45,6 @@ XRPL_FEATURE(Credentials, Supported::Yes, VoteBehavior::DefaultNo XRPL_FEATURE(AMMClawback, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FIX (AMMv1_2, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FEATURE(MPTokensV1, Supported::Yes, VoteBehavior::DefaultNo) -// InvariantsV1_1 will be changes to Supported::yes when all the -// invariants expected to be included under it are complete. -XRPL_FEATURE(InvariantsV1_1, Supported::No, VoteBehavior::DefaultNo) XRPL_FIX (NFTokenPageLinks, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FIX (InnerObjTemplate2, Supported::Yes, VoteBehavior::DefaultNo) XRPL_FIX (EnforceNFTokenTrustline, Supported::Yes, VoteBehavior::DefaultNo) diff --git a/include/xrpl/protocol/detail/sfields.macro b/include/xrpl/protocol/detail/sfields.macro index 3637acc1c4..882f85a919 100644 --- a/include/xrpl/protocol/detail/sfields.macro +++ b/include/xrpl/protocol/detail/sfields.macro @@ -27,7 +27,7 @@ TYPED_SFIELD(sfWasLockingChainSend, UINT8, 19) TYPED_SFIELD(sfWithdrawalPolicy, UINT8, 20) // 16-bit integers (common) -TYPED_SFIELD(sfLedgerEntryType, UINT16, 1, SField::SMdNever) +TYPED_SFIELD(sfLedgerEntryType, UINT16, 1, SField::kSMD_NEVER) TYPED_SFIELD(sfTransactionType, UINT16, 2) TYPED_SFIELD(sfSignerWeight, UINT16, 3) TYPED_SFIELD(sfTransferFee, UINT16, 4) @@ -48,7 +48,7 @@ TYPED_SFIELD(sfNetworkID, UINT32, 1) TYPED_SFIELD(sfFlags, UINT32, 2) TYPED_SFIELD(sfSourceTag, UINT32, 3) TYPED_SFIELD(sfSequence, UINT32, 4) -TYPED_SFIELD(sfPreviousTxnLgrSeq, UINT32, 5, SField::SMdDeleteFinal) +TYPED_SFIELD(sfPreviousTxnLgrSeq, UINT32, 5, SField::kSMD_DELETE_FINAL) TYPED_SFIELD(sfLedgerSequence, UINT32, 6) TYPED_SFIELD(sfCloseTime, UINT32, 7) TYPED_SFIELD(sfParentCloseTime, UINT32, 8) @@ -138,12 +138,12 @@ TYPED_SFIELD(sfXChainClaimID, UINT64, 20) TYPED_SFIELD(sfXChainAccountCreateCount, UINT64, 21) TYPED_SFIELD(sfXChainAccountClaimCount, UINT64, 22) TYPED_SFIELD(sfAssetPrice, UINT64, 23) -TYPED_SFIELD(sfMaximumAmount, UINT64, 24, SField::SMdBaseTen|SField::SMdDefault) -TYPED_SFIELD(sfOutstandingAmount, UINT64, 25, SField::SMdBaseTen|SField::SMdDefault) -TYPED_SFIELD(sfMPTAmount, UINT64, 26, SField::SMdBaseTen|SField::SMdDefault) +TYPED_SFIELD(sfMaximumAmount, UINT64, 24, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT) +TYPED_SFIELD(sfOutstandingAmount, UINT64, 25, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT) +TYPED_SFIELD(sfMPTAmount, UINT64, 26, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT) TYPED_SFIELD(sfIssuerNode, UINT64, 27) TYPED_SFIELD(sfSubjectNode, UINT64, 28) -TYPED_SFIELD(sfLockedAmount, UINT64, 29, SField::SMdBaseTen|SField::SMdDefault) +TYPED_SFIELD(sfLockedAmount, UINT64, 29, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT) TYPED_SFIELD(sfVaultNode, UINT64, 30) TYPED_SFIELD(sfLoanBrokerNode, UINT64, 31) @@ -167,17 +167,17 @@ TYPED_SFIELD(sfLedgerHash, UINT256, 1) TYPED_SFIELD(sfParentHash, UINT256, 2) TYPED_SFIELD(sfTransactionHash, UINT256, 3) TYPED_SFIELD(sfAccountHash, UINT256, 4) -TYPED_SFIELD(sfPreviousTxnID, UINT256, 5, SField::SMdDeleteFinal) +TYPED_SFIELD(sfPreviousTxnID, UINT256, 5, SField::kSMD_DELETE_FINAL) TYPED_SFIELD(sfLedgerIndex, UINT256, 6) TYPED_SFIELD(sfWalletLocator, UINT256, 7) -TYPED_SFIELD(sfRootIndex, UINT256, 8, SField::SMdAlways) +TYPED_SFIELD(sfRootIndex, UINT256, 8, SField::kSMD_ALWAYS) TYPED_SFIELD(sfAccountTxnID, UINT256, 9) 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, - SField::SMdPseudoAccount | SField::SMdDefault) + SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT) // 256-bit (uncommon) TYPED_SFIELD(sfBookDirectory, UINT256, 16) @@ -200,30 +200,30 @@ TYPED_SFIELD(sfHookNamespace, UINT256, 32) TYPED_SFIELD(sfHookSetTxnID, UINT256, 33) TYPED_SFIELD(sfDomainID, UINT256, 34) TYPED_SFIELD(sfVaultID, UINT256, 35, - SField::SMdPseudoAccount | SField::SMdDefault) + SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT) TYPED_SFIELD(sfParentBatchID, UINT256, 36) TYPED_SFIELD(sfLoanBrokerID, UINT256, 37, - SField::SMdPseudoAccount | SField::SMdDefault) + SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT) TYPED_SFIELD(sfLoanID, UINT256, 38) // number (common) TYPED_SFIELD(sfNumber, NUMBER, 1) -TYPED_SFIELD(sfAssetsAvailable, NUMBER, 2, SField::SMdNeedsAsset | SField::SMdDefault) -TYPED_SFIELD(sfAssetsMaximum, NUMBER, 3, SField::SMdNeedsAsset | SField::SMdDefault) -TYPED_SFIELD(sfAssetsTotal, NUMBER, 4, SField::SMdNeedsAsset | SField::SMdDefault) -TYPED_SFIELD(sfLossUnrealized, NUMBER, 5, SField::SMdNeedsAsset | SField::SMdDefault) -TYPED_SFIELD(sfDebtTotal, NUMBER, 6, SField::SMdNeedsAsset | SField::SMdDefault) -TYPED_SFIELD(sfDebtMaximum, NUMBER, 7, SField::SMdNeedsAsset | SField::SMdDefault) -TYPED_SFIELD(sfCoverAvailable, NUMBER, 8, SField::SMdNeedsAsset | SField::SMdDefault) +TYPED_SFIELD(sfAssetsAvailable, NUMBER, 2, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) +TYPED_SFIELD(sfAssetsMaximum, NUMBER, 3, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) +TYPED_SFIELD(sfAssetsTotal, NUMBER, 4, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) +TYPED_SFIELD(sfLossUnrealized, NUMBER, 5, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) +TYPED_SFIELD(sfDebtTotal, NUMBER, 6, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) +TYPED_SFIELD(sfDebtMaximum, NUMBER, 7, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) +TYPED_SFIELD(sfCoverAvailable, NUMBER, 8, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) TYPED_SFIELD(sfLoanOriginationFee, NUMBER, 9) TYPED_SFIELD(sfLoanServiceFee, NUMBER, 10) TYPED_SFIELD(sfLatePaymentFee, NUMBER, 11) TYPED_SFIELD(sfClosePaymentFee, NUMBER, 12) -TYPED_SFIELD(sfPrincipalOutstanding, NUMBER, 13, SField::SMdNeedsAsset | SField::SMdDefault) +TYPED_SFIELD(sfPrincipalOutstanding, NUMBER, 13, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) TYPED_SFIELD(sfPrincipalRequested, NUMBER, 14) -TYPED_SFIELD(sfTotalValueOutstanding, NUMBER, 15, SField::SMdNeedsAsset | SField::SMdDefault) +TYPED_SFIELD(sfTotalValueOutstanding, NUMBER, 15, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) TYPED_SFIELD(sfPeriodicPayment, NUMBER, 16) -TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER, 17, SField::SMdNeedsAsset | SField::SMdDefault) +TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER, 17, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT) // int32 TYPED_SFIELD(sfLoanScale, INT32, 1) @@ -269,9 +269,9 @@ TYPED_SFIELD(sfLPTokenBalance, AMOUNT, 31) TYPED_SFIELD(sfPublicKey, VL, 1) TYPED_SFIELD(sfMessageKey, VL, 2) TYPED_SFIELD(sfSigningPubKey, VL, 3) -TYPED_SFIELD(sfTxnSignature, VL, 4, SField::SMdDefault, SField::kNOT_SIGNING) +TYPED_SFIELD(sfTxnSignature, VL, 4, SField::kSMD_DEFAULT, SField::kNOT_SIGNING) TYPED_SFIELD(sfURI, VL, 5) -TYPED_SFIELD(sfSignature, VL, 6, SField::SMdDefault, SField::kNOT_SIGNING) +TYPED_SFIELD(sfSignature, VL, 6, SField::kSMD_DEFAULT, SField::kNOT_SIGNING) TYPED_SFIELD(sfDomain, VL, 7) TYPED_SFIELD(sfFundCode, VL, 8) TYPED_SFIELD(sfRemoveCode, VL, 9) @@ -284,7 +284,7 @@ TYPED_SFIELD(sfMemoFormat, VL, 14) // variable length (uncommon) TYPED_SFIELD(sfFulfillment, VL, 16) TYPED_SFIELD(sfCondition, VL, 17) -TYPED_SFIELD(sfMasterSignature, VL, 18, SField::SMdDefault, SField::kNOT_SIGNING) +TYPED_SFIELD(sfMasterSignature, VL, 18, SField::kSMD_DEFAULT, SField::kNOT_SIGNING) TYPED_SFIELD(sfUNLModifyValidator, VL, 19) TYPED_SFIELD(sfValidatorToDisable, VL, 20) TYPED_SFIELD(sfValidatorToReEnable, VL, 21) @@ -326,7 +326,7 @@ TYPED_SFIELD(sfBorrower, ACCOUNT, 25) TYPED_SFIELD(sfCounterparty, ACCOUNT, 26) // vector of 256-bit -TYPED_SFIELD(sfIndexes, VECTOR256, 1, SField::SMdNever) +TYPED_SFIELD(sfIndexes, VECTOR256, 1, SField::kSMD_NEVER) TYPED_SFIELD(sfHashes, VECTOR256, 2) TYPED_SFIELD(sfAmendments, VECTOR256, 3) TYPED_SFIELD(sfNFTokenOffers, VECTOR256, 4) @@ -387,13 +387,13 @@ UNTYPED_SFIELD(sfCredential, OBJECT, 33) UNTYPED_SFIELD(sfRawTransaction, OBJECT, 34) UNTYPED_SFIELD(sfBatchSigner, OBJECT, 35) UNTYPED_SFIELD(sfBook, OBJECT, 36) -UNTYPED_SFIELD(sfCounterpartySignature, OBJECT, 37, SField::SMdDefault, SField::kNOT_SIGNING) +UNTYPED_SFIELD(sfCounterpartySignature, OBJECT, 37, SField::kSMD_DEFAULT, SField::kNOT_SIGNING) // array of objects (common) // ARRAY/1 is reserved for end of array // sfSigningAccounts has never been used. //UNTYPED_SFIELD(sfSigningAccounts, ARRAY, 2) -UNTYPED_SFIELD(sfSigners, ARRAY, 3, SField::SMdDefault, SField::kNOT_SIGNING) +UNTYPED_SFIELD(sfSigners, ARRAY, 3, SField::kSMD_DEFAULT, SField::kNOT_SIGNING) UNTYPED_SFIELD(sfSignerEntries, ARRAY, 4) UNTYPED_SFIELD(sfTemplate, ARRAY, 5) UNTYPED_SFIELD(sfNecessary, ARRAY, 6) @@ -421,4 +421,4 @@ UNTYPED_SFIELD(sfUnauthorizeCredentials, ARRAY, 27) UNTYPED_SFIELD(sfAcceptedCredentials, ARRAY, 28) UNTYPED_SFIELD(sfPermissions, ARRAY, 29) UNTYPED_SFIELD(sfRawTransactions, ARRAY, 30) -UNTYPED_SFIELD(sfBatchSigners, ARRAY, 31, SField::SMdDefault, SField::kNOT_SIGNING) +UNTYPED_SFIELD(sfBatchSigners, ARRAY, 31, SField::kSMD_DEFAULT, SField::kNOT_SIGNING) diff --git a/include/xrpl/resource/detail/Entry.h b/include/xrpl/resource/detail/Entry.h index a821461e2e..8d9eb89a60 100644 --- a/include/xrpl/resource/detail/Entry.h +++ b/include/xrpl/resource/detail/Entry.h @@ -67,7 +67,7 @@ struct Entry : public beast::List::Node int refcount; // Exponentially decaying balance of resource consumption - DecayingSample local_balance; + DecayingSample local_balance; // Normalized balance contribution from imports int remote_balance; diff --git a/include/xrpl/resource/detail/Logic.h b/include/xrpl/resource/detail/Logic.h index 3bbe08724d..a1b94433df 100644 --- a/include/xrpl/resource/detail/Logic.h +++ b/include/xrpl/resource/detail/Logic.h @@ -180,16 +180,16 @@ public: json::Value getJson() { - return getJson(WarningThreshold); + return getJson(kWARNING_THRESHOLD); } - /** Returns a json::objectValue. */ + /** Returns a json::ValueType::Object. */ json::Value getJson(int threshold) { clock_type::time_point const now(clock_.now()); - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); std::scoped_lock const _(lock_); for (auto& inboundEntry : inbound_) @@ -197,7 +197,7 @@ public: int const localBalance = inboundEntry.local_balance.value(now); if ((localBalance + inboundEntry.remote_balance) >= threshold) { - json::Value& entry = (ret[inboundEntry.toString()] = json::ObjectValue); + json::Value& entry = (ret[inboundEntry.toString()] = json::ValueType::Object); entry[jss::local] = localBalance; entry[jss::remote] = inboundEntry.remote_balance; entry[jss::type] = "inbound"; @@ -208,7 +208,7 @@ public: int const localBalance = outboundEntry.local_balance.value(now); if ((localBalance + outboundEntry.remote_balance) >= threshold) { - json::Value& entry = (ret[outboundEntry.toString()] = json::ObjectValue); + json::Value& entry = (ret[outboundEntry.toString()] = json::ValueType::Object); entry[jss::local] = localBalance; entry[jss::remote] = outboundEntry.remote_balance; entry[jss::type] = "outbound"; @@ -219,7 +219,7 @@ public: int const localBalance = adminEntry.local_balance.value(now); if ((localBalance + adminEntry.remote_balance) >= threshold) { - json::Value& entry = (ret[adminEntry.toString()] = json::ObjectValue); + json::Value& entry = (ret[adminEntry.toString()] = json::ValueType::Object); entry[jss::local] = localBalance; entry[jss::remote] = adminEntry.remote_balance; entry[jss::type] = "admin"; @@ -243,7 +243,7 @@ public: { Gossip::Item item; item.balance = inboundEntry.local_balance.value(now); - if (item.balance >= MinimumGossipBalance) + if (item.balance >= kMINIMUM_GOSSIP_BALANCE) { item.address = inboundEntry.key->address; gossip.items.push_back(item); @@ -363,10 +363,10 @@ public: static Disposition disposition(int balance) { - if (balance >= DropThreshold) + if (balance >= kDROP_THRESHOLD) return Disposition::Drop; - if (balance >= WarningThreshold) + if (balance >= kWARNING_THRESHOLD) return Disposition::Warn; return Disposition::Ok; @@ -461,7 +461,7 @@ public: std::scoped_lock const _(lock_); bool notify(false); auto const elapsed = clock_.now(); - if (entry.balance(clock_.now()) >= WarningThreshold && elapsed != entry.lastWarningTime) + if (entry.balance(clock_.now()) >= kWARNING_THRESHOLD && elapsed != entry.lastWarningTime) { charge(entry, kFEE_WARNING); notify = true; @@ -485,10 +485,10 @@ public: bool drop(false); clock_type::time_point const now(clock_.now()); int const balance(entry.balance(now)); - if (balance >= DropThreshold) + if (balance >= kDROP_THRESHOLD) { JLOG(journal_.warn()) << "Consumer entry " << entry << " dropped with balance " - << balance << " at or above drop threshold " << DropThreshold; + << balance << " at or above drop threshold " << kDROP_THRESHOLD; // Adding feeDrop at this point keeps the dropped connection // from re-connecting for at least a little while after it is diff --git a/include/xrpl/resource/detail/Tuning.h b/include/xrpl/resource/detail/Tuning.h index 3452005c35..2678b8a1ca 100644 --- a/include/xrpl/resource/detail/Tuning.h +++ b/include/xrpl/resource/detail/Tuning.h @@ -5,30 +5,23 @@ namespace xrpl::Resource { /** Tunable constants. */ -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - // Balance at which a warning is issued - WarningThreshold = 5000 - // Balance at which the consumer is disconnected - , - DropThreshold = 25000 +// balance at which a warning is issued +static constexpr auto kWARNING_THRESHOLD = 5000; - // The number of seconds in the exponential decay window - // (This should be a power of two) - , - DecayWindowSeconds = 32 +// balance at which the consumer is disconnected +static constexpr auto kDROP_THRESHOLD = 25000; - // The minimum balance required in order to include a load source in gossip - , - MinimumGossipBalance = 1000 -}; +// seconds in exponential decay window (power of two) +static constexpr auto kDECAY_WINDOW_SECONDS = 32; + +// minimum balance to include a load source in gossip +static constexpr auto kMINIMUM_GOSSIP_BALANCE = 1000; // The number of seconds until an inactive table item is removed -std::chrono::seconds constexpr kSECONDS_UNTIL_EXPIRATION{300}; +static constexpr std::chrono::seconds kSECONDS_UNTIL_EXPIRATION{300}; // Number of seconds until imported gossip expires -std::chrono::seconds constexpr kGOSSIP_EXPIRATION_SECONDS{30}; +static constexpr std::chrono::seconds kGOSSIP_EXPIRATION_SECONDS{30}; } // namespace xrpl::Resource diff --git a/include/xrpl/server/detail/BaseHTTPPeer.h b/include/xrpl/server/detail/BaseHTTPPeer.h index 0260cd6b84..2cb1156cbb 100644 --- a/include/xrpl/server/detail/BaseHTTPPeer.h +++ b/include/xrpl/server/detail/BaseHTTPPeer.h @@ -30,7 +30,7 @@ namespace xrpl { /** Represents an active connection. */ template -class BaseHTTPPeer : public IoList::Work, public Session +class BaseHTTPPeer : public IOList::Work, public Session { protected: using clock_type = std::chrono::system_clock; @@ -38,16 +38,9 @@ protected: using endpoint_type = boost::asio::ip::tcp::endpoint; using yield_context = boost::asio::yield_context; - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { - // Size of our read/write buffer - BufferSize = 4 * 1024, - - // Max seconds without completing a message - TimeoutSeconds = 30, - TimeoutSecondsLocal = 3 // used for localhost clients - }; + static constexpr auto kBUFFER_SIZE = 4 * 1024; // size of read/write buffer + static constexpr auto kTIMEOUT_SECONDS = 30; // max seconds without completing a message + static constexpr auto kTIMEOUT_SECONDS_LOCAL = 3; // used for localhost clients struct Buffer { @@ -252,7 +245,8 @@ BaseHTTPPeer::startTimer() boost::beast::get_lowest_layer(impl().stream_) .expires_after( std::chrono::seconds( - remote_address_.address().is_loopback() ? TimeoutSecondsLocal : TimeoutSeconds)); + remote_address_.address().is_loopback() ? kTIMEOUT_SECONDS_LOCAL + : kTIMEOUT_SECONDS)); } // Convenience for discarding the error code @@ -364,7 +358,7 @@ BaseHTTPPeer::doWriter( for (;;) { - if (!writer->prepare(BufferSize, resume)) + if (!writer->prepare(kBUFFER_SIZE, resume)) return; error_code ec; auto const bytesTransferred = boost::asio::async_write( diff --git a/include/xrpl/server/detail/BasePeer.h b/include/xrpl/server/detail/BasePeer.h index 4aec164fe2..3705ef448e 100644 --- a/include/xrpl/server/detail/BasePeer.h +++ b/include/xrpl/server/detail/BasePeer.h @@ -17,7 +17,7 @@ namespace xrpl { // Common part of all peers template -class BasePeer : public IoList::Work +class BasePeer : public IOList::Work { protected: using clock_type = std::chrono::system_clock; diff --git a/include/xrpl/server/detail/Door.h b/include/xrpl/server/detail/Door.h index 811bf68a74..f1a622b173 100644 --- a/include/xrpl/server/detail/Door.h +++ b/include/xrpl/server/detail/Door.h @@ -39,7 +39,7 @@ namespace xrpl { /** A listening socket. */ template -class Door : public IoList::Work, public std::enable_shared_from_this> +class Door : public IOList::Work, public std::enable_shared_from_this> { private: using clock_type = std::chrono::steady_clock; @@ -53,7 +53,7 @@ private: using stream_type = boost::beast::tcp_stream; // Detects SSL on a socket - class Detector : public IoList::Work, public std::enable_shared_from_this + class Detector : public IOList::Work, public std::enable_shared_from_this { private: Port const& port_; diff --git a/include/xrpl/server/detail/ServerImpl.h b/include/xrpl/server/detail/ServerImpl.h index ce3a1c19c7..6eca1de6f2 100644 --- a/include/xrpl/server/detail/ServerImpl.h +++ b/include/xrpl/server/detail/ServerImpl.h @@ -62,9 +62,7 @@ class ServerImpl : public Server private: using clock_type = std::chrono::system_clock; - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { HistorySize = 100 }; + static constexpr auto kHISTORY_SIZE = 100; Handler& handler_; beast::Journal const j_; @@ -78,7 +76,7 @@ private: int high_ = 0; std::array hist_{}; - IoList ios_; + IOList ios_; public: ServerImpl(Handler& handler, boost::asio::io_context& ioContext, beast::Journal journal); @@ -97,7 +95,7 @@ public: void close() override; - IoList& + IOList& ios() { return ios_; diff --git a/include/xrpl/server/detail/io_list.h b/include/xrpl/server/detail/io_list.h index a7037b683c..4daa23fb7e 100644 --- a/include/xrpl/server/detail/io_list.h +++ b/include/xrpl/server/detail/io_list.h @@ -12,7 +12,7 @@ namespace xrpl { /** Manages a set of objects performing asynchronous I/O. */ -class IoList final +class IOList final { public: class Work @@ -21,8 +21,8 @@ public: void destroy(); - friend class IoList; - IoList* ios_ = nullptr; + friend class IOList; + IOList* ios_ = nullptr; public: virtual ~Work() @@ -30,13 +30,13 @@ public: destroy(); } - /** Return the IoList associated with the work. + /** Return the IOList associated with the work. Requirements: - The call to IoList::emplace to + The call to IOList::emplace to create the work has already returned. */ - IoList& + IOList& ios() { return *ios_; @@ -59,17 +59,17 @@ private: std::function f_; public: - IoList() = default; + IOList() = default; /** Destroy the list. Effects: - Closes the IoList if it was not previously + Closes the IOList if it was not previously closed. No finisher is invoked in this case. Blocks until all work is destroyed. */ - ~IoList() + ~IOList() { destroy(); } @@ -159,7 +159,7 @@ public: template void -IoList::Work::destroy() +IOList::Work::destroy() { if (!ios_) return; @@ -179,7 +179,7 @@ IoList::Work::destroy() template void -IoList::destroy() +IOList::destroy() { close(); join(); @@ -187,9 +187,9 @@ IoList::destroy() template std::shared_ptr -IoList::emplace(Args&&... args) +IOList::emplace(Args&&... args) { - static_assert(std::is_base_of_v, "T must derive from IoList::Work"); + static_assert(std::is_base_of_v, "T must derive from IOList::Work"); if (closed_) return nullptr; auto sp = std::make_shared(std::forward(args)...); @@ -211,7 +211,7 @@ IoList::emplace(Args&&... args) template void -IoList::close(Finisher&& f) +IOList::close(Finisher&& f) { std::unique_lock lock(m_); if (closed_) @@ -237,7 +237,7 @@ IoList::close(Finisher&& f) template void -IoList::join() +IOList::join() { std::unique_lock lock(m_); cv_.wait(lock, [&] { return closed_ && n_ == 0; }); diff --git a/include/xrpl/shamap/FullBelowCache.h b/include/xrpl/shamap/FullBelowCache.h index 0812f97c7b..c52434ca05 100644 --- a/include/xrpl/shamap/FullBelowCache.h +++ b/include/xrpl/shamap/FullBelowCache.h @@ -22,9 +22,7 @@ private: using CacheType = KeyCache; public: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { DefaultCacheTargetSize = 0 }; + static constexpr auto kDEFAULT_CACHE_TARGET_SIZE = 0; using key_type = uint256; using clock_type = typename CacheType::clock_type; @@ -41,7 +39,7 @@ public: clock_type& clock, beast::Journal j, beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::make(), - std::size_t targetSize = DefaultCacheTargetSize, + std::size_t targetSize = kDEFAULT_CACHE_TARGET_SIZE, std::chrono::seconds expiration = std::chrono::minutes{2}) : cache_(name, targetSize, expiration, clock, j, collector), gen_(1) { diff --git a/include/xrpl/shamap/SHAMap.h b/include/xrpl/shamap/SHAMap.h index ba48e1927b..cca800fa40 100644 --- a/include/xrpl/shamap/SHAMap.h +++ b/include/xrpl/shamap/SHAMap.h @@ -624,7 +624,7 @@ private: inline SHAMap::ConstIterator::ConstIterator(SHAMap const* map) : map_(map) { - XRPL_ASSERT(map_, "xrpl::SHAMap::const_iterator::const_iterator : non-null input"); + XRPL_ASSERT(map_, "xrpl::SHAMap::ConstIterator::ConstIterator : non-null input"); if (auto temp = map_->peekFirstItem(stack_)) item_ = temp->peekItem().get(); diff --git a/include/xrpl/shamap/SHAMapItem.h b/include/xrpl/shamap/SHAMapItem.h index d781dbf894..41558197bf 100644 --- a/include/xrpl/shamap/SHAMapItem.h +++ b/include/xrpl/shamap/SHAMapItem.h @@ -139,7 +139,7 @@ inline boost::intrusive_ptr makeShamapitem(uint256 const& tag, Slice data) { XRPL_ASSERT( - data.size() <= megabytes(16), "xrpl::make_shamapitem : maximum input size"); + data.size() <= megabytes(16), "xrpl::makeShamapitem : maximum input size"); // NOLINTNEXTLINE(misc-const-correctness) std::uint8_t* raw = detail::gSlabber.allocate(data.size()); diff --git a/include/xrpl/shamap/SHAMapTreeNode.h b/include/xrpl/shamap/SHAMapTreeNode.h index d50fc65ccb..ac48df8d46 100644 --- a/include/xrpl/shamap/SHAMapTreeNode.h +++ b/include/xrpl/shamap/SHAMapTreeNode.h @@ -7,6 +7,7 @@ #include #include +#include #include #include @@ -20,6 +21,9 @@ static constexpr unsigned char const kWIRE_TYPE_INNER = 2; static constexpr unsigned char const kWIRE_TYPE_COMPRESSED_INNER = 3; static constexpr unsigned char const kWIRE_TYPE_TRANSACTION_WITH_META = 4; +// Lower bound on SHAMap leaf item payload size, in bytes. +inline constexpr std::size_t kMIN_SHA_MAP_ITEM_BYTES = 12; + enum class SHAMapNodeType { TnInner = 1, TnTransactionNm = 2, // transaction, no metadata diff --git a/include/xrpl/tx/Transactor.h b/include/xrpl/tx/Transactor.h index cf8030b275..bee2e2942c 100644 --- a/include/xrpl/tx/Transactor.h +++ b/include/xrpl/tx/Transactor.h @@ -123,9 +123,8 @@ public: Transactor(Transactor const&) = delete; Transactor& operator=(Transactor const&) = delete; - // 68 transactor subclass files - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum ConsequencesFactoryType { Normal, Blocker, Custom }; + + enum class ConsequencesFactoryType { Normal, Blocker, Custom }; /** Process the transaction. */ ApplyResult diff --git a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h index 5f76a43759..e55419dfc1 100644 --- a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h +++ b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h @@ -25,7 +25,7 @@ not have the relevant amendments enabled_. It's intentionally a pain in the neck so that bad code gets caught and fixed as early as possible. */ -// Bitwise flags, 86 files +// Bitwise flags, 86 files, used in macros files // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) enum Privilege { NoPriv = 0x0000, // The transaction can not do any of the enumerated operations diff --git a/include/xrpl/tx/invariants/PermissionedDEXInvariant.h b/include/xrpl/tx/invariants/PermissionedDEXInvariant.h index da187779b2..3784a32840 100644 --- a/include/xrpl/tx/invariants/PermissionedDEXInvariant.h +++ b/include/xrpl/tx/invariants/PermissionedDEXInvariant.h @@ -11,8 +11,8 @@ namespace xrpl { class ValidPermissionedDEX { bool regularOffers_ = false; - bool badHybridsOld_ = false; // pre-fixSecurity3_1_3: missing field/domain or size > 1 - bool badHybrids_ = false; // post-fixSecurity3_1_3: also catches size == 0 (size != 1) + bool badHybridsOld_ = false; // pre-fixCleanup3_1_3: missing field/domain or size > 1 + bool badHybrids_ = false; // post-fixCleanup3_1_3: also catches size == 0 (size != 1) hash_set domains_; public: diff --git a/include/xrpl/tx/paths/detail/StepChecks.h b/include/xrpl/tx/paths/detail/StepChecks.h index a1e6490781..fea9f90a31 100644 --- a/include/xrpl/tx/paths/detail/StepChecks.h +++ b/include/xrpl/tx/paths/detail/StepChecks.h @@ -77,8 +77,8 @@ checkNoRipple( if (!sleIn || !sleOut) return terNO_LINE; - if ((((*sleIn)[sfFlags] & ((cur > prev) ? lsfHighNoRipple : lsfLowNoRipple)) != 0u) && - (((*sleOut)[sfFlags] & ((cur > next) ? lsfHighNoRipple : lsfLowNoRipple)) != 0u)) + if (sleIn->isFlag((cur > prev) ? lsfHighNoRipple : lsfLowNoRipple) && + sleOut->isFlag((cur > next) ? lsfHighNoRipple : lsfLowNoRipple)) { JLOG(j.info()) << "Path violates noRipple constraint between " << prev << ", " << cur << " and " << next; diff --git a/include/xrpl/tx/transactors/account/AccountDelete.h b/include/xrpl/tx/transactors/account/AccountDelete.h index 1491ae09d9..0e0ad1c33a 100644 --- a/include/xrpl/tx/transactors/account/AccountDelete.h +++ b/include/xrpl/tx/transactors/account/AccountDelete.h @@ -7,7 +7,7 @@ namespace xrpl { class AccountDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker; explicit AccountDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/account/AccountSet.h b/include/xrpl/tx/transactors/account/AccountSet.h index 780ad846da..69eff6d005 100644 --- a/include/xrpl/tx/transactors/account/AccountSet.h +++ b/include/xrpl/tx/transactors/account/AccountSet.h @@ -8,7 +8,7 @@ namespace xrpl { class AccountSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; explicit AccountSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/account/SetRegularKey.h b/include/xrpl/tx/transactors/account/SetRegularKey.h index 22a40714db..6ea6375b1d 100644 --- a/include/xrpl/tx/transactors/account/SetRegularKey.h +++ b/include/xrpl/tx/transactors/account/SetRegularKey.h @@ -7,7 +7,7 @@ namespace xrpl { class SetRegularKey : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker; explicit SetRegularKey(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/account/SignerListSet.h b/include/xrpl/tx/transactors/account/SignerListSet.h index 16e7bf3a06..a2c75a27d8 100644 --- a/include/xrpl/tx/transactors/account/SignerListSet.h +++ b/include/xrpl/tx/transactors/account/SignerListSet.h @@ -24,7 +24,7 @@ private: std::vector signers_; public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker; explicit SignerListSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/bridge/XChainBridge.h b/include/xrpl/tx/transactors/bridge/XChainBridge.h index 79755c0c2f..a98ef58238 100644 --- a/include/xrpl/tx/transactors/bridge/XChainBridge.h +++ b/include/xrpl/tx/transactors/bridge/XChainBridge.h @@ -12,7 +12,7 @@ constexpr size_t kXBRIDGE_MAX_ACCOUNT_CREATE_CLAIMS = 128; class XChainCreateBridge : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit XChainCreateBridge(ApplyContext& ctx) : Transactor(ctx) { @@ -45,7 +45,7 @@ public: class BridgeModify : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit BridgeModify(ApplyContext& ctx) : Transactor(ctx) { @@ -95,7 +95,7 @@ class XChainClaim : public Transactor { public: // Blocker since we cannot accurately calculate the consequences - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker; explicit XChainClaim(ApplyContext& ctx) : Transactor(ctx) { @@ -133,7 +133,7 @@ public: class XChainCommit : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; static TxConsequences makeTxConsequences(PreflightContext const& ctx); @@ -179,7 +179,7 @@ public: class XChainCreateClaimID : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit XChainCreateClaimID(ApplyContext& ctx) : Transactor(ctx) { @@ -222,7 +222,7 @@ class XChainAddClaimAttestation : public Transactor { public: // Blocker since we cannot accurately calculate the consequences - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker; explicit XChainAddClaimAttestation(ApplyContext& ctx) : Transactor(ctx) { @@ -256,7 +256,7 @@ class XChainAddAccountCreateAttestation : public Transactor { public: // Blocker since we cannot accurately calculate the consequences - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker; explicit XChainAddAccountCreateAttestation(ApplyContext& ctx) : Transactor(ctx) { @@ -314,7 +314,7 @@ public: class XChainCreateAccountCommit : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit XChainCreateAccountCommit(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/check/CheckCancel.h b/include/xrpl/tx/transactors/check/CheckCancel.h index 4861a05a02..787ce516e3 100644 --- a/include/xrpl/tx/transactors/check/CheckCancel.h +++ b/include/xrpl/tx/transactors/check/CheckCancel.h @@ -7,7 +7,7 @@ namespace xrpl { class CheckCancel : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit CheckCancel(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/check/CheckCash.h b/include/xrpl/tx/transactors/check/CheckCash.h index c831cc279e..6141c93bc0 100644 --- a/include/xrpl/tx/transactors/check/CheckCash.h +++ b/include/xrpl/tx/transactors/check/CheckCash.h @@ -7,7 +7,7 @@ namespace xrpl { class CheckCash : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit CheckCash(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/check/CheckCreate.h b/include/xrpl/tx/transactors/check/CheckCreate.h index 494870cb1c..dc3ece3446 100644 --- a/include/xrpl/tx/transactors/check/CheckCreate.h +++ b/include/xrpl/tx/transactors/check/CheckCreate.h @@ -7,7 +7,7 @@ namespace xrpl { class CheckCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit CheckCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/credentials/CredentialAccept.h b/include/xrpl/tx/transactors/credentials/CredentialAccept.h index 0da5dd6131..ac76384142 100644 --- a/include/xrpl/tx/transactors/credentials/CredentialAccept.h +++ b/include/xrpl/tx/transactors/credentials/CredentialAccept.h @@ -7,7 +7,7 @@ namespace xrpl { class CredentialAccept : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit CredentialAccept(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/credentials/CredentialCreate.h b/include/xrpl/tx/transactors/credentials/CredentialCreate.h index d7a1a245df..b6476ec460 100644 --- a/include/xrpl/tx/transactors/credentials/CredentialCreate.h +++ b/include/xrpl/tx/transactors/credentials/CredentialCreate.h @@ -7,7 +7,7 @@ namespace xrpl { class CredentialCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit CredentialCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/credentials/CredentialDelete.h b/include/xrpl/tx/transactors/credentials/CredentialDelete.h index 60de0957ca..bcae90cefa 100644 --- a/include/xrpl/tx/transactors/credentials/CredentialDelete.h +++ b/include/xrpl/tx/transactors/credentials/CredentialDelete.h @@ -7,7 +7,7 @@ namespace xrpl { class CredentialDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit CredentialDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/delegate/DelegateSet.h b/include/xrpl/tx/transactors/delegate/DelegateSet.h index ee4bfeaaef..b0fcbfea22 100644 --- a/include/xrpl/tx/transactors/delegate/DelegateSet.h +++ b/include/xrpl/tx/transactors/delegate/DelegateSet.h @@ -7,7 +7,7 @@ namespace xrpl { class DelegateSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit DelegateSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMBid.h b/include/xrpl/tx/transactors/dex/AMMBid.h index 979ca0250d..38fb1a57fe 100644 --- a/include/xrpl/tx/transactors/dex/AMMBid.h +++ b/include/xrpl/tx/transactors/dex/AMMBid.h @@ -45,7 +45,7 @@ namespace xrpl { class AMMBid : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit AMMBid(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMClawback.h b/include/xrpl/tx/transactors/dex/AMMClawback.h index 3cf6288ccf..9a6dd36791 100644 --- a/include/xrpl/tx/transactors/dex/AMMClawback.h +++ b/include/xrpl/tx/transactors/dex/AMMClawback.h @@ -7,7 +7,7 @@ class Sandbox; class AMMClawback : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit AMMClawback(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMCreate.h b/include/xrpl/tx/transactors/dex/AMMCreate.h index 485273ca17..35e3a951b4 100644 --- a/include/xrpl/tx/transactors/dex/AMMCreate.h +++ b/include/xrpl/tx/transactors/dex/AMMCreate.h @@ -37,7 +37,7 @@ namespace xrpl { class AMMCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit AMMCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMDelete.h b/include/xrpl/tx/transactors/dex/AMMDelete.h index 1fbb4ec9e8..57fdfebf94 100644 --- a/include/xrpl/tx/transactors/dex/AMMDelete.h +++ b/include/xrpl/tx/transactors/dex/AMMDelete.h @@ -13,7 +13,7 @@ namespace xrpl { class AMMDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit AMMDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMDeposit.h b/include/xrpl/tx/transactors/dex/AMMDeposit.h index 3847a2a529..8afe957e60 100644 --- a/include/xrpl/tx/transactors/dex/AMMDeposit.h +++ b/include/xrpl/tx/transactors/dex/AMMDeposit.h @@ -42,7 +42,7 @@ class Sandbox; class AMMDeposit : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit AMMDeposit(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMVote.h b/include/xrpl/tx/transactors/dex/AMMVote.h index c1fa059bd6..70e75144c4 100644 --- a/include/xrpl/tx/transactors/dex/AMMVote.h +++ b/include/xrpl/tx/transactors/dex/AMMVote.h @@ -30,7 +30,7 @@ namespace xrpl { class AMMVote : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit AMMVote(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMWithdraw.h b/include/xrpl/tx/transactors/dex/AMMWithdraw.h index cbaae78433..17ebe4e2be 100644 --- a/include/xrpl/tx/transactors/dex/AMMWithdraw.h +++ b/include/xrpl/tx/transactors/dex/AMMWithdraw.h @@ -50,7 +50,7 @@ enum class WithdrawAll : bool { No = false, Yes }; class AMMWithdraw : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit AMMWithdraw(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/OfferCancel.h b/include/xrpl/tx/transactors/dex/OfferCancel.h index a8e408492e..c16550f87d 100644 --- a/include/xrpl/tx/transactors/dex/OfferCancel.h +++ b/include/xrpl/tx/transactors/dex/OfferCancel.h @@ -8,7 +8,7 @@ namespace xrpl { class OfferCancel : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit OfferCancel(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/OfferCreate.h b/include/xrpl/tx/transactors/dex/OfferCreate.h index 2c5e63705a..4ee69313e0 100644 --- a/include/xrpl/tx/transactors/dex/OfferCreate.h +++ b/include/xrpl/tx/transactors/dex/OfferCreate.h @@ -12,7 +12,7 @@ class Sandbox; class OfferCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; /** Construct a Transactor subclass that creates an offer in the ledger. */ explicit OfferCreate(ApplyContext& ctx) : Transactor(ctx) diff --git a/include/xrpl/tx/transactors/did/DIDDelete.h b/include/xrpl/tx/transactors/did/DIDDelete.h index 2699307b39..4e19a6664f 100644 --- a/include/xrpl/tx/transactors/did/DIDDelete.h +++ b/include/xrpl/tx/transactors/did/DIDDelete.h @@ -7,7 +7,7 @@ namespace xrpl { class DIDDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit DIDDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/did/DIDSet.h b/include/xrpl/tx/transactors/did/DIDSet.h index fa07cfc295..972f3a9579 100644 --- a/include/xrpl/tx/transactors/did/DIDSet.h +++ b/include/xrpl/tx/transactors/did/DIDSet.h @@ -7,7 +7,7 @@ namespace xrpl { class DIDSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit DIDSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/escrow/EscrowCancel.h b/include/xrpl/tx/transactors/escrow/EscrowCancel.h index 13270b6741..628fd2e61f 100644 --- a/include/xrpl/tx/transactors/escrow/EscrowCancel.h +++ b/include/xrpl/tx/transactors/escrow/EscrowCancel.h @@ -7,7 +7,7 @@ namespace xrpl { class EscrowCancel : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit EscrowCancel(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/escrow/EscrowCreate.h b/include/xrpl/tx/transactors/escrow/EscrowCreate.h index 4e809e3bf5..b3b04b71b6 100644 --- a/include/xrpl/tx/transactors/escrow/EscrowCreate.h +++ b/include/xrpl/tx/transactors/escrow/EscrowCreate.h @@ -7,7 +7,7 @@ namespace xrpl { class EscrowCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/escrow/EscrowFinish.h b/include/xrpl/tx/transactors/escrow/EscrowFinish.h index 0fc6b46311..420f5f7324 100644 --- a/include/xrpl/tx/transactors/escrow/EscrowFinish.h +++ b/include/xrpl/tx/transactors/escrow/EscrowFinish.h @@ -7,7 +7,7 @@ namespace xrpl { class EscrowFinish : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit EscrowFinish(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h b/include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h index a774e23717..73781fa4bd 100644 --- a/include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h +++ b/include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanBrokerCoverClawback : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanBrokerCoverClawback(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h b/include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h index f69c47afbc..4ced4747bb 100644 --- a/include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h +++ b/include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanBrokerCoverDeposit : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanBrokerCoverDeposit(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h b/include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h index b70b0a758a..8dc370283a 100644 --- a/include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h +++ b/include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanBrokerCoverWithdraw : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanBrokerCoverWithdraw(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanBrokerDelete.h b/include/xrpl/tx/transactors/lending/LoanBrokerDelete.h index ca58fc75bd..9f40986909 100644 --- a/include/xrpl/tx/transactors/lending/LoanBrokerDelete.h +++ b/include/xrpl/tx/transactors/lending/LoanBrokerDelete.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanBrokerDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanBrokerDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanBrokerSet.h b/include/xrpl/tx/transactors/lending/LoanBrokerSet.h index 6c07740f9a..adbb3217ba 100644 --- a/include/xrpl/tx/transactors/lending/LoanBrokerSet.h +++ b/include/xrpl/tx/transactors/lending/LoanBrokerSet.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanBrokerSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanBrokerSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanDelete.h b/include/xrpl/tx/transactors/lending/LoanDelete.h index 6f9d3ed5f0..6f14530101 100644 --- a/include/xrpl/tx/transactors/lending/LoanDelete.h +++ b/include/xrpl/tx/transactors/lending/LoanDelete.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanManage.h b/include/xrpl/tx/transactors/lending/LoanManage.h index c01d25e428..b21f618b19 100644 --- a/include/xrpl/tx/transactors/lending/LoanManage.h +++ b/include/xrpl/tx/transactors/lending/LoanManage.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanManage : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanManage(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanPay.h b/include/xrpl/tx/transactors/lending/LoanPay.h index 6c2aa0ec47..59f4f20149 100644 --- a/include/xrpl/tx/transactors/lending/LoanPay.h +++ b/include/xrpl/tx/transactors/lending/LoanPay.h @@ -7,7 +7,7 @@ namespace xrpl { class LoanPay : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanPay(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/lending/LoanSet.h b/include/xrpl/tx/transactors/lending/LoanSet.h index e926c927fb..6517212a18 100644 --- a/include/xrpl/tx/transactors/lending/LoanSet.h +++ b/include/xrpl/tx/transactors/lending/LoanSet.h @@ -8,7 +8,7 @@ namespace xrpl { class LoanSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LoanSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h b/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h index 7c77b02277..9cdb609ad8 100644 --- a/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h +++ b/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h @@ -20,7 +20,7 @@ private: transferNFToken(AccountID const& buyer, AccountID const& seller, uint256 const& nfTokenID); public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit NFTokenAcceptOffer(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/nft/NFTokenBurn.h b/include/xrpl/tx/transactors/nft/NFTokenBurn.h index 075bcc59ce..e8341cf26a 100644 --- a/include/xrpl/tx/transactors/nft/NFTokenBurn.h +++ b/include/xrpl/tx/transactors/nft/NFTokenBurn.h @@ -7,7 +7,7 @@ namespace xrpl { class NFTokenBurn : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit NFTokenBurn(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h b/include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h index f78c29dfe5..faa6c0c029 100644 --- a/include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h +++ b/include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h @@ -7,7 +7,7 @@ namespace xrpl { class NFTokenCancelOffer : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit NFTokenCancelOffer(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/nft/NFTokenCreateOffer.h b/include/xrpl/tx/transactors/nft/NFTokenCreateOffer.h index bdb76e1c44..cedb680bb1 100644 --- a/include/xrpl/tx/transactors/nft/NFTokenCreateOffer.h +++ b/include/xrpl/tx/transactors/nft/NFTokenCreateOffer.h @@ -7,7 +7,7 @@ namespace xrpl { class NFTokenCreateOffer : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit NFTokenCreateOffer(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/nft/NFTokenMint.h b/include/xrpl/tx/transactors/nft/NFTokenMint.h index 5274e1b4b8..43beb47179 100644 --- a/include/xrpl/tx/transactors/nft/NFTokenMint.h +++ b/include/xrpl/tx/transactors/nft/NFTokenMint.h @@ -9,7 +9,7 @@ namespace xrpl { class NFTokenMint : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit NFTokenMint(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/nft/NFTokenModify.h b/include/xrpl/tx/transactors/nft/NFTokenModify.h index 6d3bac49f5..d7f5f031b1 100644 --- a/include/xrpl/tx/transactors/nft/NFTokenModify.h +++ b/include/xrpl/tx/transactors/nft/NFTokenModify.h @@ -7,7 +7,7 @@ namespace xrpl { class NFTokenModify : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit NFTokenModify(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/oracle/OracleDelete.h b/include/xrpl/tx/transactors/oracle/OracleDelete.h index 85ca9a2a88..5acc365fa5 100644 --- a/include/xrpl/tx/transactors/oracle/OracleDelete.h +++ b/include/xrpl/tx/transactors/oracle/OracleDelete.h @@ -16,7 +16,7 @@ namespace xrpl { class OracleDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit OracleDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/oracle/OracleSet.h b/include/xrpl/tx/transactors/oracle/OracleSet.h index 7bedf9c837..3cad859dce 100644 --- a/include/xrpl/tx/transactors/oracle/OracleSet.h +++ b/include/xrpl/tx/transactors/oracle/OracleSet.h @@ -16,7 +16,7 @@ namespace xrpl { class OracleSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit OracleSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/payment/DepositPreauth.h b/include/xrpl/tx/transactors/payment/DepositPreauth.h index 365ba157a5..9eaf94989a 100644 --- a/include/xrpl/tx/transactors/payment/DepositPreauth.h +++ b/include/xrpl/tx/transactors/payment/DepositPreauth.h @@ -7,7 +7,7 @@ namespace xrpl { class DepositPreauth : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit DepositPreauth(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/payment/Payment.h b/include/xrpl/tx/transactors/payment/Payment.h index 4ad870ce3f..23a46f0766 100644 --- a/include/xrpl/tx/transactors/payment/Payment.h +++ b/include/xrpl/tx/transactors/payment/Payment.h @@ -13,7 +13,7 @@ class Payment : public Transactor static std::size_t const kMAX_PATH_LENGTH = 8; public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; explicit Payment(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h b/include/xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h index d5e8235d31..444832b1dc 100644 --- a/include/xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h +++ b/include/xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h @@ -7,7 +7,7 @@ namespace xrpl { class PaymentChannelClaim : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit PaymentChannelClaim(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h b/include/xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h index 94a43ea165..800cfcdb91 100644 --- a/include/xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h +++ b/include/xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h @@ -7,7 +7,7 @@ namespace xrpl { class PaymentChannelCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; explicit PaymentChannelCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/payment_channel/PaymentChannelFund.h b/include/xrpl/tx/transactors/payment_channel/PaymentChannelFund.h index 3f16cf1ec1..ee26d34dce 100644 --- a/include/xrpl/tx/transactors/payment_channel/PaymentChannelFund.h +++ b/include/xrpl/tx/transactors/payment_channel/PaymentChannelFund.h @@ -7,7 +7,7 @@ namespace xrpl { class PaymentChannelFund : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; explicit PaymentChannelFund(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h b/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h index 4aaff83a7a..1ac96be2eb 100644 --- a/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h +++ b/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h @@ -7,7 +7,7 @@ namespace xrpl { class PermissionedDomainDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit PermissionedDomainDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h b/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h index 820b36688c..f5725e7660 100644 --- a/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h +++ b/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h @@ -7,7 +7,7 @@ namespace xrpl { class PermissionedDomainSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit PermissionedDomainSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/system/Batch.h b/include/xrpl/tx/transactors/system/Batch.h index b1af9a2f86..82e5bf8f78 100644 --- a/include/xrpl/tx/transactors/system/Batch.h +++ b/include/xrpl/tx/transactors/system/Batch.h @@ -9,7 +9,7 @@ namespace xrpl { class Batch : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit Batch(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/system/Change.h b/include/xrpl/tx/transactors/system/Change.h index fc68fd55c2..c3a3ff81ff 100644 --- a/include/xrpl/tx/transactors/system/Change.h +++ b/include/xrpl/tx/transactors/system/Change.h @@ -7,7 +7,7 @@ namespace xrpl { class Change : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit Change(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/system/LedgerStateFix.h b/include/xrpl/tx/transactors/system/LedgerStateFix.h index 72ad8196c1..7e6a89ea0b 100644 --- a/include/xrpl/tx/transactors/system/LedgerStateFix.h +++ b/include/xrpl/tx/transactors/system/LedgerStateFix.h @@ -11,7 +11,7 @@ public: NfTokenPageLink = 1, }; - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit LedgerStateFix(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/system/TicketCreate.h b/include/xrpl/tx/transactors/system/TicketCreate.h index fc1743236f..9c9289e1b5 100644 --- a/include/xrpl/tx/transactors/system/TicketCreate.h +++ b/include/xrpl/tx/transactors/system/TicketCreate.h @@ -7,7 +7,7 @@ namespace xrpl { class TicketCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom; constexpr static std::uint32_t kMIN_VALID_COUNT = 1; diff --git a/include/xrpl/tx/transactors/token/Clawback.h b/include/xrpl/tx/transactors/token/Clawback.h index e21f98bd7a..6a5927fb02 100644 --- a/include/xrpl/tx/transactors/token/Clawback.h +++ b/include/xrpl/tx/transactors/token/Clawback.h @@ -7,7 +7,7 @@ namespace xrpl { class Clawback : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit Clawback(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/token/MPTokenAuthorize.h b/include/xrpl/tx/transactors/token/MPTokenAuthorize.h index 29cdda275a..29d80c5d9d 100644 --- a/include/xrpl/tx/transactors/token/MPTokenAuthorize.h +++ b/include/xrpl/tx/transactors/token/MPTokenAuthorize.h @@ -16,7 +16,7 @@ struct MPTAuthorizeArgs class MPTokenAuthorize : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit MPTokenAuthorize(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h b/include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h index 0107c11598..2cb871550a 100644 --- a/include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h +++ b/include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h @@ -27,7 +27,7 @@ struct MPTCreateArgs class MPTokenIssuanceCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit MPTokenIssuanceCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h b/include/xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h index 8e2a4c3dcd..2f18a501e9 100644 --- a/include/xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h +++ b/include/xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h @@ -7,7 +7,7 @@ namespace xrpl { class MPTokenIssuanceDestroy : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit MPTokenIssuanceDestroy(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/token/MPTokenIssuanceSet.h b/include/xrpl/tx/transactors/token/MPTokenIssuanceSet.h index e15027ab5e..2e8c8a7a41 100644 --- a/include/xrpl/tx/transactors/token/MPTokenIssuanceSet.h +++ b/include/xrpl/tx/transactors/token/MPTokenIssuanceSet.h @@ -7,7 +7,7 @@ namespace xrpl { class MPTokenIssuanceSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit MPTokenIssuanceSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/token/TrustSet.h b/include/xrpl/tx/transactors/token/TrustSet.h index e99d599fe4..5eee05889a 100644 --- a/include/xrpl/tx/transactors/token/TrustSet.h +++ b/include/xrpl/tx/transactors/token/TrustSet.h @@ -8,7 +8,7 @@ namespace xrpl { class TrustSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit TrustSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/vault/VaultClawback.h b/include/xrpl/tx/transactors/vault/VaultClawback.h index 4f0328aa4f..bd9fb2abec 100644 --- a/include/xrpl/tx/transactors/vault/VaultClawback.h +++ b/include/xrpl/tx/transactors/vault/VaultClawback.h @@ -7,7 +7,7 @@ namespace xrpl { class VaultClawback : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit VaultClawback(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/vault/VaultCreate.h b/include/xrpl/tx/transactors/vault/VaultCreate.h index 61b3e552cc..1b05f80c06 100644 --- a/include/xrpl/tx/transactors/vault/VaultCreate.h +++ b/include/xrpl/tx/transactors/vault/VaultCreate.h @@ -7,7 +7,7 @@ namespace xrpl { class VaultCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit VaultCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/vault/VaultDelete.h b/include/xrpl/tx/transactors/vault/VaultDelete.h index 9a75fcebac..dc610cc089 100644 --- a/include/xrpl/tx/transactors/vault/VaultDelete.h +++ b/include/xrpl/tx/transactors/vault/VaultDelete.h @@ -7,7 +7,7 @@ namespace xrpl { class VaultDelete : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit VaultDelete(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/vault/VaultDeposit.h b/include/xrpl/tx/transactors/vault/VaultDeposit.h index 21dc1749e2..fbaf987082 100644 --- a/include/xrpl/tx/transactors/vault/VaultDeposit.h +++ b/include/xrpl/tx/transactors/vault/VaultDeposit.h @@ -7,7 +7,7 @@ namespace xrpl { class VaultDeposit : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit VaultDeposit(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/vault/VaultSet.h b/include/xrpl/tx/transactors/vault/VaultSet.h index 59a9639126..719b828766 100644 --- a/include/xrpl/tx/transactors/vault/VaultSet.h +++ b/include/xrpl/tx/transactors/vault/VaultSet.h @@ -7,7 +7,7 @@ namespace xrpl { class VaultSet : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit VaultSet(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/vault/VaultWithdraw.h b/include/xrpl/tx/transactors/vault/VaultWithdraw.h index f9b7665fd6..fd3739bc2f 100644 --- a/include/xrpl/tx/transactors/vault/VaultWithdraw.h +++ b/include/xrpl/tx/transactors/vault/VaultWithdraw.h @@ -7,7 +7,7 @@ namespace xrpl { class VaultWithdraw : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal; explicit VaultWithdraw(ApplyContext& ctx) : Transactor(ctx) { diff --git a/nix/ci-env.nix b/nix/ci-env.nix new file mode 100644 index 0000000000..d8021fe0bd --- /dev/null +++ b/nix/ci-env.nix @@ -0,0 +1,54 @@ +{ + pkgs, + glibc231, + ... +}: +let + inherit (import ./packages.nix { inherit pkgs; }) commonPackages; + + # binutils wrapped to emit binaries that reference glibc 2.31 (dynamic + # linker path, library search path, RPATH). + binutils231 = pkgs.wrapBintoolsWith { + bintools = pkgs.binutils-unwrapped; + libc = glibc231; + }; + + # Rebuild gcc 15 (specifically libstdc++ / libgcc_s) against glibc 2.31. + # The override swaps gcc15.cc's bootstrap stdenv for one that uses the + # existing gcc 15 binary but links against glibc 2.31, so the resulting + # compiler ships runtime libraries that only reference symbols available + # in glibc 2.31. + gcc15CcWithGlibc231 = pkgs.gcc15.cc.override { + stdenv = pkgs.stdenvAdapters.overrideCC pkgs.stdenv ( + pkgs.wrapCCWith { + cc = pkgs.gcc15.cc; + libc = glibc231; + bintools = binutils231; + } + ); + }; + + # cc-wrapper around the rebuilt compiler, pointing at glibc 2.31 headers + # and libraries. This is what we actually expose to users. + gcc15WithGlibc231 = pkgs.wrapCCWith { + cc = gcc15CcWithGlibc231; + libc = glibc231; + bintools = binutils231; + }; + +in +{ + default = pkgs.buildEnv { + name = "xrpld-ci-env"; + paths = commonPackages ++ [ + gcc15WithGlibc231 + binutils231 + ]; + pathsToLink = [ + "/bin" + "/lib" + "/include" + "/share" + ]; + }; +} diff --git a/nix/devshell.nix b/nix/devshell.nix index 1d907f4d87..1bd7ea4c0c 100644 --- a/nix/devshell.nix +++ b/nix/devshell.nix @@ -1,19 +1,6 @@ { pkgs, ... }: let - commonPackages = with pkgs; [ - ccache - cmake - conan - gcovr - git - gnumake - llvmPackages_21.clang-tools - ninja - perl # needed for openssl - pkg-config - pre-commit - python314 - ]; + inherit (import ./packages.nix { inherit pkgs; }) commonPackages; # Supported compiler versions gccVersion = pkgs.lib.range 13 15; diff --git a/nix/packages.nix b/nix/packages.nix new file mode 100644 index 0000000000..edfe302ec9 --- /dev/null +++ b/nix/packages.nix @@ -0,0 +1,27 @@ +{ pkgs }: +let + # In LLVM 22, run-clang-tidy.py moved from share/clang/ to bin/, so nixpkgs + # clang-tools no longer links it. Wrap it manually. + runClangTidy = pkgs.writeShellScriptBin "run-clang-tidy" '' + exec ${pkgs.python3}/bin/python3 ${pkgs.llvmPackages_22.clang-unwrapped}/bin/run-clang-tidy "$@" + ''; +in +{ + commonPackages = with pkgs; [ + ccache + cmake + conan + gcovr + git + gnumake + llvmPackages_22.clang-tools + mold + ninja + perl # needed for openssl + pkg-config + pre-commit + python3 + runClangTidy + vim + ]; +} diff --git a/nix/utils.nix b/nix/utils.nix index 821d60a6f6..07ff169c44 100644 --- a/nix/utils.nix +++ b/nix/utils.nix @@ -1,19 +1,21 @@ -{ nixpkgs }: -{ - forEachSystem = - function: - nixpkgs.lib.genAttrs - [ - "x86_64-linux" - "aarch64-linux" - "x86_64-darwin" - "aarch64-darwin" - ] - ( - system: - function { - inherit system; - pkgs = import nixpkgs { inherit system; }; - } - ); -} +{ nixpkgs, nixpkgs-glibc231 }: +function: +nixpkgs.lib.genAttrs + [ + "x86_64-linux" + "aarch64-linux" + "x86_64-darwin" + "aarch64-darwin" + ] + ( + system: + function { + pkgs = import nixpkgs { inherit system; }; + # glibc 2.31 — matches the system libc on Ubuntu 20.04 LTS. Sourced + # from the nixpkgs snapshot pinned via the `nixpkgs-glibc231` flake + # input, so the build uses the compiler from that snapshot + # (gcc 9.3.0) along with the matching patches, configure flags, and + # hardening defaults. + glibc231 = (import nixpkgs-glibc231 { inherit system; }).glibc; + } + ) diff --git a/src/libxrpl/basics/Log.cpp b/src/libxrpl/basics/Log.cpp index a629d865b8..43f9ee4b67 100644 --- a/src/libxrpl/basics/Log.cpp +++ b/src/libxrpl/basics/Log.cpp @@ -14,19 +14,20 @@ #include #include #include +#include #include #include #include namespace xrpl { -Logs::Sink::Sink(std::string partition, beast::severities::Severity thresh, Logs& logs) +Logs::Sink::Sink(std::string partition, beast::Severity thresh, Logs& logs) : beast::Journal::Sink(thresh, false), logs_(logs), partition_(std::move(partition)) { } void -Logs::Sink::write(beast::severities::Severity level, std::string const& text) +Logs::Sink::write(beast::Severity level, std::string const& text) { if (level < threshold()) return; @@ -35,7 +36,7 @@ Logs::Sink::write(beast::severities::Severity level, std::string const& text) } void -Logs::Sink::writeAlways(beast::severities::Severity level, std::string const& text) +Logs::Sink::writeAlways(beast::Severity level, std::string const& text) { logs_.write(level, partition_, text, console()); } @@ -107,7 +108,7 @@ Logs::File::writeln(char const* text) //------------------------------------------------------------------------------ -Logs::Logs(beast::severities::Severity thresh) : thresh_(thresh) // default severity +Logs::Logs(beast::Severity thresh) : thresh_(thresh) // default severity { } @@ -137,14 +138,14 @@ Logs::journal(std::string const& name) return beast::Journal(get(name)); } -beast::severities::Severity +beast::Severity Logs::threshold() const { return thresh_; } void -Logs::threshold(beast::severities::Severity thresh) +Logs::threshold(beast::Severity thresh) { std::scoped_lock const lock(mutex_); thresh_ = thresh; @@ -159,13 +160,13 @@ Logs::partitionSeverities() const std::scoped_lock const lock(mutex_); list.reserve(sinks_.size()); for (auto const& [name, sink] : sinks_) - list.emplace_back(name, toString(fromSeverity(sink->threshold()))); + list.emplace_back(name, toString(sink->threshold())); return list; } void Logs::write( - beast::severities::Severity level, + beast::Severity level, std::string const& partition, std::string const& text, bool console) @@ -192,122 +193,65 @@ Logs::rotate() } std::unique_ptr -Logs::makeSink(std::string const& name, beast::severities::Severity threshold) +Logs::makeSink(std::string const& name, beast::Severity threshold) { return std::make_unique(name, threshold, *this); } -LogSeverity -Logs::fromSeverity(beast::severities::Severity level) -{ - using namespace beast::severities; - switch (level) - { - case KTrace: - return LSTrace; - case KDebug: - return LSDebug; - case KInfo: - return LSInfo; - case KWarning: - return LSWarning; - case KError: - return LSError; - - // LCOV_EXCL_START - default: - UNREACHABLE("xrpl::Logs::fromSeverity : invalid severity"); - [[fallthrough]]; - // LCOV_EXCL_STOP - case KFatal: - break; - } - - return LSFatal; -} - -beast::severities::Severity -Logs::toSeverity(LogSeverity level) -{ - using namespace beast::severities; - switch (level) - { - case LSTrace: - return KTrace; - case LSDebug: - return KDebug; - case LSInfo: - return KInfo; - case LSWarning: - return KWarning; - case LSError: - return KError; - // LCOV_EXCL_START - default: - UNREACHABLE("xrpl::Logs::toSeverity : invalid severity"); - [[fallthrough]]; - // LCOV_EXCL_STOP - case LSFatal: - break; - } - - return KFatal; -} - std::string -Logs::toString(LogSeverity s) +Logs::toString(beast::Severity s) { switch (s) { - case LSTrace: + case beast::Severity::Trace: return "Trace"; - case LSDebug: + case beast::Severity::Debug: return "Debug"; - case LSInfo: + case beast::Severity::Info: return "Info"; - case LSWarning: + case beast::Severity::Warning: return "Warning"; - case LSError: + case beast::Severity::Error: return "Error"; - case LSFatal: + case beast::Severity::Fatal: return "Fatal"; // LCOV_EXCL_START default: - UNREACHABLE("xrpl::Logs::to_string : invalid severity"); + UNREACHABLE("xrpl::Logs::toString : invalid severity"); return "Unknown"; // LCOV_EXCL_STOP } } -LogSeverity +std::optional Logs::fromString(std::string const& s) { if (boost::iequals(s, "trace")) - return LSTrace; + return beast::Severity::Trace; if (boost::iequals(s, "debug")) - return LSDebug; + return beast::Severity::Debug; if (boost::iequals(s, "info") || boost::iequals(s, "information")) - return LSInfo; + return beast::Severity::Info; if (boost::iequals(s, "warn") || boost::iequals(s, "warning") || boost::iequals(s, "warnings")) - return LSWarning; + return beast::Severity::Warning; if (boost::iequals(s, "error") || boost::iequals(s, "errors")) - return LSError; + return beast::Severity::Error; if (boost::iequals(s, "fatal") || boost::iequals(s, "fatals")) - return LSFatal; + return beast::Severity::Fatal; - return LSInvalid; + return std::nullopt; } void Logs::format( std::string& output, std::string const& message, - beast::severities::Severity severity, + beast::Severity severity, std::string const& partition) { output.reserve(message.size() + partition.size() + 100); @@ -318,22 +262,22 @@ Logs::format( if (!partition.empty()) output += partition + ":"; - using namespace beast::severities; + using beast::Severity; switch (severity) { - case KTrace: + case Severity::Trace: output += "TRC "; break; - case KDebug: + case Severity::Debug: output += "DBG "; break; - case KInfo: + case Severity::Info: output += "NFO "; break; - case KWarning: + case Severity::Warning: output += "WRN "; break; - case KError: + case Severity::Error: output += "ERR "; break; // LCOV_EXCL_START @@ -341,7 +285,7 @@ Logs::format( UNREACHABLE("xrpl::Logs::format : invalid severity"); [[fallthrough]]; // LCOV_EXCL_STOP - case KFatal: + case Severity::Fatal: output += "FTL "; break; } @@ -349,9 +293,9 @@ Logs::format( output += message; // Limit the maximum length of the output - if (output.size() > MaximumMessageCharacters) + if (output.size() > kMAXIMUM_MESSAGE_CHARACTERS) { - output.resize(MaximumMessageCharacters - 3); + output.resize(kMAXIMUM_MESSAGE_CHARACTERS - 3); output += "..."; } diff --git a/src/libxrpl/basics/ResolverAsio.cpp b/src/libxrpl/basics/ResolverAsio.cpp index 4e64c280c7..4a5ceb3d8d 100644 --- a/src/libxrpl/basics/ResolverAsio.cpp +++ b/src/libxrpl/basics/ResolverAsio.cpp @@ -231,7 +231,7 @@ public: void doStop(CompletionCounter) { - XRPL_ASSERT(stop_called == true, "xrpl::ResolverAsioImpl::do_stop : stopping"); + XRPL_ASSERT(stop_called == true, "xrpl::ResolverAsioImpl::doStop : stopping"); if (!stopped.exchange(true)) { @@ -369,7 +369,7 @@ public: void doResolve(std::vector const& names, HandlerType const& handler, CompletionCounter) { - XRPL_ASSERT(!names.empty(), "xrpl::ResolverAsioImpl::do_resolve : names non-empty"); + XRPL_ASSERT(!names.empty(), "xrpl::ResolverAsioImpl::doResolve : names non-empty"); if (!stop_called) { diff --git a/src/libxrpl/basics/StringUtilities.cpp b/src/libxrpl/basics/StringUtilities.cpp index f1f8515ae1..fa35f7f740 100644 --- a/src/libxrpl/basics/StringUtilities.cpp +++ b/src/libxrpl/basics/StringUtilities.cpp @@ -101,7 +101,7 @@ trimWhitespace(std::string str) } std::optional -toUint64(std::string const& s) +toUInt64(std::string const& s) { std::uint64_t result = 0; if (beast::lexicalCastChecked(result, s)) diff --git a/src/libxrpl/beast/clock/basic_seconds_clock.cpp b/src/libxrpl/beast/clock/basic_seconds_clock.cpp index 2c8ac34b6a..886887dd97 100644 --- a/src/libxrpl/beast/clock/basic_seconds_clock.cpp +++ b/src/libxrpl/beast/clock/basic_seconds_clock.cpp @@ -40,7 +40,7 @@ static_assert(std::atomic::is_always_lock_free); SecondsClockThread::~SecondsClockThread() { XRPL_ASSERT( - thread_.joinable(), "beast::seconds_clock_thread::~seconds_clock_thread : thread joinable"); + thread_.joinable(), "beast::SecondsClockThread::~SecondsClockThread : thread joinable"); { std::scoped_lock const lock(mut_); stop_ = true; diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp index 90d06ddf28..55042b1bf4 100644 --- a/src/libxrpl/beast/insight/StatsDCollector.cpp +++ b/src/libxrpl/beast/insight/StatsDCollector.cpp @@ -204,12 +204,7 @@ class StatsDCollectorImp : public StatsDCollector, public std::enable_shared_from_this { private: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { - // MaxPacketSize = 484 - MaxPacketSize = 1472 - }; + static constexpr auto kMAX_PACKET_SIZE = 1472; Journal journal_; IP::Endpoint address_; @@ -392,7 +387,7 @@ public: !s.empty(), "beast::insight::detail::StatsDCollectorImp::sendBuffers : " "non-empty payload"); - if (!buffers.empty() && (size + length) > MaxPacketSize) + if (!buffers.empty() && (size + length) > kMAX_PACKET_SIZE) { log(buffers); socket_.async_send( diff --git a/src/libxrpl/beast/net/IPAddressV4.cpp b/src/libxrpl/beast/net/IPAddressV4.cpp index 48554d0ec3..e087da92eb 100644 --- a/src/libxrpl/beast/net/IPAddressV4.cpp +++ b/src/libxrpl/beast/net/IPAddressV4.cpp @@ -14,7 +14,45 @@ isPrivate(AddressV4 const& addr) bool isPublic(AddressV4 const& addr) { - return !isPrivate(addr) && !addr.is_multicast(); + if (isPrivate(addr)) + return false; + if (addr.is_multicast()) + return false; + + auto const ip = addr.to_uint(); + + // 0.0.0.0/8 "This network" + if ((ip & 0xff000000) == 0x00000000) + return false; + // 100.64.0.0/10 Shared Address Space (CGNAT) - RFC 6598 + if ((ip & 0xffc00000) == 0x64400000) + return false; + // 169.254.0.0/16 Link-local + if ((ip & 0xffff0000) == 0xa9fe0000) + return false; + // 192.0.0.0/24 IETF Protocol Assignments - RFC 6890 + if ((ip & 0xffffff00) == 0xc0000000) + return false; + // 192.0.2.0/24 TEST-NET-1 (documentation) - RFC 5737 + if ((ip & 0xffffff00) == 0xc0000200) + return false; + // 192.88.99.0/24 6to4 Relay Anycast (deprecated) - RFC 7526 + if ((ip & 0xffffff00) == 0xc0586300) + return false; + // 198.18.0.0/15 Benchmarking - RFC 2544 + if ((ip & 0xfffe0000) == 0xc6120000) + return false; + // 198.51.100.0/24 TEST-NET-2 (documentation) - RFC 5737 + if ((ip & 0xffffff00) == 0xc6336400) + return false; + // 203.0.113.0/24 TEST-NET-3 (documentation) - RFC 5737 + if ((ip & 0xffffff00) == 0xcb007100) + return false; + // 240.0.0.0/4 Reserved for future use - RFC 1112 + if ((ip & 0xf0000000) == 0xf0000000) + return false; + + return true; } char diff --git a/src/libxrpl/beast/net/IPAddressV6.cpp b/src/libxrpl/beast/net/IPAddressV6.cpp index fad11dddc0..c75ccaf1cc 100644 --- a/src/libxrpl/beast/net/IPAddressV6.cpp +++ b/src/libxrpl/beast/net/IPAddressV6.cpp @@ -9,17 +9,53 @@ namespace beast::IP { bool isPrivate(AddressV6 const& addr) { - return ( - ((addr.to_bytes()[0] & 0xfd) != 0) || // TODO fc00::/8 too ? - (addr.is_v4_mapped() && - isPrivate(boost::asio::ip::make_address_v4(boost::asio::ip::v4_mapped, addr)))); + // fc00::/7 - Unique Local Address (ULA), covers fc00:: and fd00:: + if ((addr.to_bytes()[0] & 0xfe) == 0xfc) + return true; + if (addr.is_v4_mapped()) + return isPrivate(boost::asio::ip::make_address_v4(boost::asio::ip::v4_mapped, addr)); + return false; } bool isPublic(AddressV6 const& addr) { - // TODO is this correct? - return !isPrivate(addr) && !addr.is_multicast(); + if (addr.is_loopback()) + return false; + if (addr.is_v4_mapped()) + return isPublic(boost::asio::ip::make_address_v4(boost::asio::ip::v4_mapped, addr)); + if (isPrivate(addr)) + return false; + if (addr.is_multicast()) + return false; + if (addr.is_unspecified()) + return false; + + auto const b = addr.to_bytes(); + + // fe80::/10 - Link-local + if (b[0] == 0xfe && (b[1] & 0xc0) == 0x80) + return false; + // 100::/64 - Discard prefix (RFC 6666) + if (b[0] == 0x01 && b[1] == 0x00 && b[2] == 0 && b[3] == 0 && b[4] == 0 && b[5] == 0 && + b[6] == 0 && b[7] == 0) + return false; + // 2001:db8::/32 - Documentation (RFC 3849) + if (b[0] == 0x20 && b[1] == 0x01 && b[2] == 0x0d && b[3] == 0xb8) + return false; + // 2001::/32 - IETF Protocol Assignments / Teredo (RFC 4380) + if (b[0] == 0x20 && b[1] == 0x01 && b[2] == 0x00 && b[3] == 0x00) + return false; + // 2001:20::/28 - ORCHIDv2 (RFC 7343) + // 28-bit prefix: 0x2001002 => b[0]=0x20, b[1]=0x01, b[2]=0x00, + // top nibble of b[3]=0x2 + if (b[0] == 0x20 && b[1] == 0x01 && b[2] == 0x00 && (b[3] & 0xf0) == 0x20) + return false; + // 2002::/16 - 6to4 (RFC 3056, deprecated by RFC 7526) + if (b[0] == 0x20 && b[1] == 0x02) + return false; + + return true; } } // namespace beast::IP diff --git a/src/libxrpl/beast/utility/beast_Journal.cpp b/src/libxrpl/beast/utility/beast_Journal.cpp index abe5072461..2a8efe3b11 100644 --- a/src/libxrpl/beast/utility/beast_Journal.cpp +++ b/src/libxrpl/beast/utility/beast_Journal.cpp @@ -12,14 +12,14 @@ namespace beast { class NullJournalSink : public Journal::Sink { public: - NullJournalSink() : Sink(severities::KDisabled, false) + NullJournalSink() : Sink(Severity::Disabled, false) { } ~NullJournalSink() override = default; [[nodiscard]] bool - active(severities::Severity) const override + active(Severity) const override { return false; } @@ -35,24 +35,24 @@ public: { } - [[nodiscard]] severities::Severity + [[nodiscard]] Severity threshold() const override { - return severities::KDisabled; + return Severity::Disabled; } void - threshold(severities::Severity) override + threshold(Severity) override { } void - write(severities::Severity, std::string const&) override + write(Severity, std::string const&) override { } void - writeAlways(severities::Severity, std::string const&) override + writeAlways(Severity, std::string const&) override { } }; @@ -92,7 +92,7 @@ Journal::Sink::console(bool output) console_ = output; } -severities::Severity +Severity Journal::Sink::threshold() const { return thresh_; diff --git a/src/libxrpl/core/detail/JobQueue.cpp b/src/libxrpl/core/detail/JobQueue.cpp index 06a2d226e1..50f95dcdbf 100644 --- a/src/libxrpl/core/detail/JobQueue.cpp +++ b/src/libxrpl/core/detail/JobQueue.cpp @@ -186,11 +186,11 @@ json::Value JobQueue::getJson(int c) { using namespace std::chrono_literals; - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret["threads"] = workers_.getNumberOfThreads(); - json::Value priorities = json::ArrayValue; + json::Value priorities = json::ValueType::Array; std::scoped_lock const lock(mutex_); @@ -210,7 +210,7 @@ JobQueue::getJson(int c) if ((stats.count != 0) || (waiting != 0) || (stats.latencyPeak != 0ms) || (running != 0)) { - json::Value& pri = priorities.append(json::ObjectValue); + json::Value& pri = priorities.append(json::ValueType::Object); pri["job_type"] = data.name(); diff --git a/src/libxrpl/json/JsonPropertyStream.cpp b/src/libxrpl/json/JsonPropertyStream.cpp index b6a151d702..d4d343e186 100644 --- a/src/libxrpl/json/JsonPropertyStream.cpp +++ b/src/libxrpl/json/JsonPropertyStream.cpp @@ -6,7 +6,7 @@ namespace xrpl { -JsonPropertyStream::JsonPropertyStream() : topValue(json::ObjectValue) +JsonPropertyStream::JsonPropertyStream() : topValue(json::ValueType::Object) { stack.reserve(64); stack.push_back(&topValue); @@ -23,7 +23,7 @@ JsonPropertyStream::mapBegin() { // top is array json::Value& top(*stack.back()); - json::Value& map(top.append(json::ObjectValue)); + json::Value& map(top.append(json::ValueType::Object)); stack.push_back(&map); } @@ -32,7 +32,7 @@ JsonPropertyStream::mapBegin(std::string const& key) { // top is a map json::Value& top(*stack.back()); - json::Value& map(top[key] = json::ObjectValue); + json::Value& map(top[key] = json::ValueType::Object); stack.push_back(&map); } @@ -95,7 +95,7 @@ JsonPropertyStream::arrayBegin() { // top is array json::Value& top(*stack.back()); - json::Value& vec(top.append(json::ArrayValue)); + json::Value& vec(top.append(json::ValueType::Array)); stack.push_back(&vec); } @@ -104,7 +104,7 @@ JsonPropertyStream::arrayBegin(std::string const& key) { // top is a map json::Value& top(*stack.back()); - json::Value& vec(top[key] = json::ArrayValue); + json::Value& vec(top[key] = json::ValueType::Array); stack.push_back(&vec); } diff --git a/src/libxrpl/json/Output.cpp b/src/libxrpl/json/Output.cpp index 14b6617b2f..dc411f92b2 100644 --- a/src/libxrpl/json/Output.cpp +++ b/src/libxrpl/json/Output.cpp @@ -10,41 +10,41 @@ namespace json { namespace { void -outputJson(json::Value const& value, Writer& writer) +outputJson(Value const& value, Writer& writer) { switch (value.type()) { - case json::NullValue: { + case ValueType::Null: { writer.output(nullptr); break; } - case json::IntValue: { + case ValueType::Int: { writer.output(value.asInt()); break; } - case json::UintValue: { + case ValueType::UInt: { writer.output(value.asUInt()); break; } - case json::RealValue: { + case ValueType::Real: { writer.output(value.asDouble()); break; } - case json::StringValue: { + case ValueType::String: { writer.output(value.asString()); break; } - case json::BooleanValue: { + case ValueType::Boolean: { writer.output(value.asBool()); break; } - case json::ArrayValue: { + case ValueType::Array: { writer.startRoot(Writer::CollectionType::Array); for (auto const& i : value) { @@ -55,7 +55,7 @@ outputJson(json::Value const& value, Writer& writer) break; } - case json::ObjectValue: { + case ValueType::Object: { writer.startRoot(Writer::CollectionType::Object); auto members = value.getMemberNames(); for (auto const& tag : members) @@ -72,14 +72,14 @@ outputJson(json::Value const& value, Writer& writer) } // namespace void -outputJson(json::Value const& value, Output const& out) +outputJson(Value const& value, Output const& out) { Writer writer(out); outputJson(value, writer); } std::string -jsonAsString(json::Value const& value) +jsonAsString(Value const& value) { std::string s; Writer writer(stringOutput(s)); diff --git a/src/libxrpl/json/json_reader.cpp b/src/libxrpl/json/json_reader.cpp index 6574789e7b..3e8eb1e094 100644 --- a/src/libxrpl/json/json_reader.cpp +++ b/src/libxrpl/json/json_reader.cpp @@ -102,7 +102,7 @@ Reader::parse(char const* beginDoc, char const* endDoc, Value& root) { // Set error location to start of doc, ideally should be first token // found in doc - token.type = TokenError; + token.type = TokenType::Error; token.start = beginDoc; token.end = endDoc; addError("A valid JSON document must be either an array or an object value.", token); @@ -123,35 +123,35 @@ Reader::readValue(unsigned depth) switch (token.type) { - case TokenObjectBegin: + case TokenType::ObjectBegin: successful = readObject(token, depth); break; - case TokenArrayBegin: + case TokenType::ArrayBegin: successful = readArray(token, depth); break; - case TokenInteger: + case TokenType::Integer: successful = decodeNumber(token); break; - case TokenDouble: + case TokenType::Double: successful = decodeDouble(token); break; - case TokenString: + case TokenType::String: successful = decodeString(token); break; - case TokenTrue: + case TokenType::True: currentValue() = true; break; - case TokenFalse: + case TokenType::False: currentValue() = false; break; - case TokenNull: + case TokenType::Null: currentValue() = Value(); break; @@ -168,7 +168,7 @@ Reader::skipCommentTokens(Token& token) do { readToken(token); - } while (token.type == TokenComment); + } while (token.type == TokenType::Comment); } bool @@ -193,28 +193,28 @@ Reader::readToken(Token& token) switch (c) { case '{': - token.type = TokenObjectBegin; + token.type = TokenType::ObjectBegin; break; case '}': - token.type = TokenObjectEnd; + token.type = TokenType::ObjectEnd; break; case '[': - token.type = TokenArrayBegin; + token.type = TokenType::ArrayBegin; break; case ']': - token.type = TokenArrayEnd; + token.type = TokenType::ArrayEnd; break; case '"': - token.type = TokenString; + token.type = TokenType::String; ok = readString(); break; case '/': - token.type = TokenComment; + token.type = TokenType::Comment; ok = readComment(); break; @@ -233,30 +233,30 @@ Reader::readToken(Token& token) break; case 't': - token.type = TokenTrue; + token.type = TokenType::True; ok = match("rue", 3); break; case 'f': - token.type = TokenFalse; + token.type = TokenType::False; ok = match("alse", 4); // cspell:disable-line break; case 'n': - token.type = TokenNull; + token.type = TokenType::Null; ok = match("ull", 3); break; case ',': - token.type = TokenArraySeparator; + token.type = TokenType::ArraySeparator; break; case ':': - token.type = TokenMemberSeparator; + token.type = TokenType::MemberSeparator; break; case 0: - token.type = TokenEndOfStream; + token.type = TokenType::EndOfStream; break; default: @@ -265,7 +265,7 @@ Reader::readToken(Token& token) } if (!ok) - token.type = TokenError; + token.type = TokenType::Error; token.end = current_; return true; @@ -354,7 +354,7 @@ Reader::readNumber() { static char const kEXTENDED_TOKENS[] = {'.', 'e', 'E', '+', '-'}; - TokenType type = TokenInteger; + TokenType type = TokenType::Integer; if (current_ != end_) { @@ -370,7 +370,7 @@ Reader::readNumber() if (ret == std::end(kEXTENDED_TOKENS)) break; - type = TokenDouble; + type = TokenType::Double; } ++current_; @@ -407,35 +407,35 @@ Reader::readObject(Token& tokenStart, unsigned depth) { Token tokenName{}; std::string name; - currentValue() = Value(ObjectValue); + currentValue() = Value(ValueType::Object); while (readToken(tokenName)) { bool initialTokenOk = true; - while (tokenName.type == TokenComment && initialTokenOk) + while (tokenName.type == TokenType::Comment && initialTokenOk) initialTokenOk = readToken(tokenName); if (!initialTokenOk) break; - if (tokenName.type == TokenObjectEnd && name.empty()) // empty object + if (tokenName.type == TokenType::ObjectEnd && name.empty()) // empty object return true; - if (tokenName.type != TokenString) + if (tokenName.type != TokenType::String) break; name = ""; if (!decodeString(tokenName, name)) - return recoverFromError(TokenObjectEnd); + return recoverFromError(TokenType::ObjectEnd); Token colon{}; - if (!readToken(colon) || colon.type != TokenMemberSeparator) + if (!readToken(colon) || colon.type != TokenType::MemberSeparator) { return addErrorAndRecover( - "Missing ':' after object member name", colon, TokenObjectEnd); + "Missing ':' after object member name", colon, TokenType::ObjectEnd); } // Reject duplicate names @@ -448,34 +448,34 @@ Reader::readObject(Token& tokenStart, unsigned depth) nodes_.pop(); if (!ok) // error already set - return recoverFromError(TokenObjectEnd); + return recoverFromError(TokenType::ObjectEnd); Token comma{}; if (!readToken(comma) || - (comma.type != TokenObjectEnd && comma.type != TokenArraySeparator && - comma.type != TokenComment)) + (comma.type != TokenType::ObjectEnd && comma.type != TokenType::ArraySeparator && + comma.type != TokenType::Comment)) { return addErrorAndRecover( - "Missing ',' or '}' in object declaration", comma, TokenObjectEnd); + "Missing ',' or '}' in object declaration", comma, TokenType::ObjectEnd); } bool finalizeTokenOk = true; - while (comma.type == TokenComment && finalizeTokenOk) + while (comma.type == TokenType::Comment && finalizeTokenOk) finalizeTokenOk = readToken(comma); - if (comma.type == TokenObjectEnd) + if (comma.type == TokenType::ObjectEnd) return true; } - return addErrorAndRecover("Missing '}' or object member name", tokenName, TokenObjectEnd); + return addErrorAndRecover("Missing '}' or object member name", tokenName, TokenType::ObjectEnd); } bool Reader::readArray(Token& tokenStart, unsigned depth) { - currentValue() = Value(ArrayValue); + currentValue() = Value(ValueType::Array); skipSpaces(); if (*current_ == ']') // empty array @@ -495,27 +495,27 @@ Reader::readArray(Token& tokenStart, unsigned depth) nodes_.pop(); if (!ok) // error already set - return recoverFromError(TokenArrayEnd); + return recoverFromError(TokenType::ArrayEnd); Token token{}; // Accept Comment after last item in the array. ok = readToken(token); - while (token.type == TokenComment && ok) + while (token.type == TokenType::Comment && ok) { ok = readToken(token); } bool const badTokenType = - (token.type != TokenArraySeparator && token.type != TokenArrayEnd); + (token.type != TokenType::ArraySeparator && token.type != TokenType::ArrayEnd); if (!ok || badTokenType) { return addErrorAndRecover( - "Missing ',' or ']' in array declaration", token, TokenArrayEnd); + "Missing ',' or ']' in array declaration", token, TokenType::ArrayEnd); } - if (token.type == TokenArrayEnd) + if (token.type == TokenType::ArrayEnd) break; } @@ -542,10 +542,10 @@ Reader::decodeNumber(Token& token) std::int64_t value = 0; static_assert( - sizeof(value) > sizeof(Value::kMAX_U_INT), + sizeof(value) > sizeof(Value::kMAX_UINT), "The JSON integer overflow logic will need to be reworked."); - while (current < token.end && (value <= Value::kMAX_U_INT)) + while (current < token.end && (value <= Value::kMAX_UINT)) { Char const c = *current++; @@ -580,7 +580,7 @@ Reader::decodeNumber(Token& token) } else { - if (value > Value::kMAX_U_INT) + if (value > Value::kMAX_UINT) { return addError( "'" + std::string(token.start, token.end) + "' exceeds the allowable range.", @@ -834,7 +834,7 @@ Reader::recoverFromError(TokenType skipUntilToken) if (!readToken(skip)) errors_.resize(errorCount); // discard errors caused by recovery - if (skip.type == skipUntilToken || skip.type == TokenEndOfStream) + if (skip.type == skipUntilToken || skip.type == TokenType::EndOfStream) break; } diff --git a/src/libxrpl/json/json_value.cpp b/src/libxrpl/json/json_value.cpp index e7dc4b067b..b150ea0842 100644 --- a/src/libxrpl/json/json_value.cpp +++ b/src/libxrpl/json/json_value.cpp @@ -37,13 +37,13 @@ public: } char* - duplicateStringValue(char const* value, unsigned int length = Unknown) override + duplicateStringValue(char const* value, unsigned int length = kUNKNOWN) override { //@todo investigate this old optimization // if ( !value || value[0] == 0 ) // return 0; - if (length == Unknown) + if (length == kUNKNOWN) length = (value != nullptr) ? (unsigned int)strlen(value) : 0; char* newString = static_cast(malloc(length + 1)); @@ -93,26 +93,30 @@ Value::CZString::CZString(int index) : cstr_(0), index_(index) } Value::CZString::CZString(char const* cstr, DuplicationPolicy allocate) - : cstr_(allocate == Duplicate ? valueAllocator()->makeMemberName(cstr) : cstr), index_(allocate) + : cstr_( + allocate == DuplicationPolicy::Duplicate ? valueAllocator()->makeMemberName(cstr) : cstr) + , index_(static_cast(allocate)) { } Value::CZString::CZString(CZString const& other) : cstr_( - other.index_ != NoDuplication && other.cstr_ != 0 + other.index_ != static_cast(DuplicationPolicy::NoDuplication) && other.cstr_ != 0 ? valueAllocator()->makeMemberName(other.cstr_) : other.cstr_) , index_([&]() -> int { if (!other.cstr_) return other.index_; - return other.index_ == NoDuplication ? NoDuplication : Duplicate; + return other.index_ == static_cast(DuplicationPolicy::NoDuplication) + ? static_cast(DuplicationPolicy::NoDuplication) + : static_cast(DuplicationPolicy::Duplicate); }()) { } Value::CZString::~CZString() { - if ((cstr_ != nullptr) && index_ == Duplicate) + if ((cstr_ != nullptr) && index_ == static_cast(DuplicationPolicy::Duplicate)) valueAllocator()->releaseMemberName(const_cast(cstr_)); } @@ -149,7 +153,7 @@ Value::CZString::cStr() const bool Value::CZString::isStaticString() const { - return index_ == NoDuplication; + return index_ == static_cast(DuplicationPolicy::NoDuplication); } // ////////////////////////////////////////////////////////////////// @@ -168,28 +172,28 @@ Value::Value(ValueType type) : type_(type) { switch (type) { - case NullValue: + case ValueType::Null: break; - case IntValue: - case UintValue: + case ValueType::Int: + case ValueType::UInt: value_.intVal = 0; break; - case RealValue: + case ValueType::Real: value_.realVal = 0.0; break; - case StringValue: + case ValueType::String: value_.stringVal = 0; break; - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: value_.mapVal = new ObjectValues(); break; - case BooleanValue: + case ValueType::Boolean: value_.boolVal = false; break; @@ -200,44 +204,44 @@ Value::Value(ValueType type) : type_(type) } } -Value::Value(Int value) : type_(IntValue) +Value::Value(Int value) : type_(ValueType::Int) { value_.intVal = value; } -Value::Value(UInt value) : type_(UintValue) +Value::Value(UInt value) : type_(ValueType::UInt) { value_.uintVal = value; } -Value::Value(double value) : type_(RealValue) +Value::Value(double value) : type_(ValueType::Real) { value_.realVal = value; } -Value::Value(char const* value) : type_(StringValue), allocated_(true) +Value::Value(char const* value) : type_(ValueType::String), allocated_(true) { value_.stringVal = valueAllocator()->duplicateStringValue(value); } -Value::Value(xrpl::Number const& value) : type_(StringValue), allocated_(true) +Value::Value(xrpl::Number const& value) : type_(ValueType::String), allocated_(true) { auto const tmp = to_string(value); value_.stringVal = valueAllocator()->duplicateStringValue(tmp.c_str(), tmp.length()); } -Value::Value(std::string const& value) : type_(StringValue), allocated_(true) +Value::Value(std::string const& value) : type_(ValueType::String), allocated_(true) { value_.stringVal = valueAllocator()->duplicateStringValue(value.c_str(), (unsigned int)value.length()); } -Value::Value(StaticString const& value) : type_(StringValue) +Value::Value(StaticString const& value) : type_(ValueType::String) { value_.stringVal = const_cast(value.cStr()); } -Value::Value(bool value) : type_(BooleanValue) +Value::Value(bool value) : type_(ValueType::Boolean) { value_.boolVal = value; } @@ -246,15 +250,15 @@ Value::Value(Value const& other) : type_(other.type_) { switch (type_) { - case NullValue: - case IntValue: - case UintValue: - case RealValue: - case BooleanValue: + case ValueType::Null: + case ValueType::Int: + case ValueType::UInt: + case ValueType::Real: + case ValueType::Boolean: value_ = other.value_; break; - case StringValue: + case ValueType::String: if (other.value_.stringVal != nullptr) { value_.stringVal = valueAllocator()->duplicateStringValue(other.value_.stringVal); @@ -267,8 +271,8 @@ Value::Value(Value const& other) : type_(other.type_) break; - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: value_.mapVal = new ObjectValues(*other.value_.mapVal); break; @@ -283,21 +287,21 @@ Value::~Value() { switch (type_) { - case NullValue: - case IntValue: - case UintValue: - case RealValue: - case BooleanValue: + case ValueType::Null: + case ValueType::Int: + case ValueType::UInt: + case ValueType::Real: + case ValueType::Boolean: break; - case StringValue: + case ValueType::String: if (allocated_) valueAllocator()->releaseStringValue(value_.stringVal); break; - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: if (value_.mapVal != nullptr) delete value_.mapVal; break; @@ -320,7 +324,7 @@ Value::operator=(Value const& other) Value::Value(Value&& other) noexcept : value_(other.value_), type_(other.type_), allocated_(other.allocated_) { - other.type_ = NullValue; + other.type_ = ValueType::Null; other.allocated_ = 0; } @@ -368,13 +372,13 @@ integerCmp(Int i, UInt ui) bool operator<(Value const& x, Value const& y) { - if (auto signum = x.type_ - y.type_) + if (auto signum = static_cast(x.type_) - static_cast(y.type_)) { - if (x.type_ == IntValue && y.type_ == UintValue) + if (x.type_ == ValueType::Int && y.type_ == ValueType::UInt) { signum = integerCmp(x.value_.intVal, y.value_.uintVal); } - else if (x.type_ == UintValue && y.type_ == IntValue) + else if (x.type_ == ValueType::UInt && y.type_ == ValueType::Int) { signum = -integerCmp(y.value_.intVal, x.value_.uintVal); } @@ -383,28 +387,28 @@ operator<(Value const& x, Value const& y) switch (x.type_) { - case NullValue: + case ValueType::Null: return false; - case IntValue: + case ValueType::Int: return x.value_.intVal < y.value_.intVal; - case UintValue: + case ValueType::UInt: return x.value_.uintVal < y.value_.uintVal; - case RealValue: + case ValueType::Real: return x.value_.realVal < y.value_.realVal; - case BooleanValue: + case ValueType::Boolean: return static_cast(x.value_.boolVal) < static_cast(y.value_.boolVal); - case StringValue: + case ValueType::String: return (x.value_.stringVal == 0 && (y.value_.stringVal != nullptr)) || ((y.value_.stringVal != nullptr) && (x.value_.stringVal != nullptr) && strcmp(x.value_.stringVal, y.value_.stringVal) < 0); - case ArrayValue: - case ObjectValue: { + case ValueType::Array: + case ValueType::Object: { if (int const signum = int(x.value_.mapVal->size()) - y.value_.mapVal->size()) return signum < 0; @@ -425,37 +429,37 @@ operator==(Value const& x, Value const& y) { if (x.type_ != y.type_) { - if (x.type_ == IntValue && y.type_ == UintValue) + if (x.type_ == ValueType::Int && y.type_ == ValueType::UInt) return integerCmp(x.value_.intVal, y.value_.uintVal) == 0; - if (x.type_ == UintValue && y.type_ == IntValue) + if (x.type_ == ValueType::UInt && y.type_ == ValueType::Int) return integerCmp(y.value_.intVal, x.value_.uintVal) == 0; return false; } switch (x.type_) { - case NullValue: + case ValueType::Null: return true; - case IntValue: + case ValueType::Int: return x.value_.intVal == y.value_.intVal; - case UintValue: + case ValueType::UInt: return x.value_.uintVal == y.value_.uintVal; - case RealValue: + case ValueType::Real: return x.value_.realVal == y.value_.realVal; - case BooleanValue: + case ValueType::Boolean: return x.value_.boolVal == y.value_.boolVal; - case StringValue: + case ValueType::String: return x.value_.stringVal == y.value_.stringVal || ((y.value_.stringVal != nullptr) && (x.value_.stringVal != nullptr) && (strcmp(x.value_.stringVal, y.value_.stringVal) == 0)); - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: return x.value_.mapVal->size() == y.value_.mapVal->size() && *x.value_.mapVal == *y.value_.mapVal; @@ -471,7 +475,7 @@ operator==(Value const& x, Value const& y) char const* Value::asCString() const { - XRPL_ASSERT(type_ == StringValue, "json::Value::asCString : valid type"); + XRPL_ASSERT(type_ == ValueType::String, "json::Value::asCString : valid type"); return value_.stringVal; } @@ -480,26 +484,26 @@ Value::asString() const { switch (type_) { - case NullValue: + case ValueType::Null: return ""; - case StringValue: + case ValueType::String: return (value_.stringVal != nullptr) ? value_.stringVal : ""; - case BooleanValue: + case ValueType::Boolean: return value_.boolVal ? "true" : "false"; - case IntValue: + case ValueType::Int: return std::to_string(value_.intVal); - case UintValue: + case ValueType::UInt: return std::to_string(value_.uintVal); - case RealValue: + case ValueType::Real: return std::to_string(value_.realVal); - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: JSON_ASSERT_MESSAGE(false, "Type is not convertible to string"); // LCOV_EXCL_START @@ -516,33 +520,33 @@ Value::asInt() const { switch (type_) { - case NullValue: + case ValueType::Null: return 0; - case IntValue: + case ValueType::Int: return value_.intVal; - case UintValue: + case ValueType::UInt: JSON_ASSERT_MESSAGE( value_.uintVal < (unsigned)kMAX_INT, "integer out of signed integer range"); return value_.uintVal; - case RealValue: + case ValueType::Real: JSON_ASSERT_MESSAGE( (value_.realVal >= kMIN_INT && value_.realVal <= kMAX_INT), "Real out of signed integer range"); return Int(value_.realVal); - case BooleanValue: + case ValueType::Boolean: return value_.boolVal ? 1 : 0; - case StringValue: { + case ValueType::String: { char const* const str{(value_.stringVal != nullptr) ? value_.stringVal : ""}; return beast::lexicalCastThrow(str); } - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: JSON_ASSERT_MESSAGE(false, "Type is not convertible to int"); // LCOV_EXCL_START @@ -559,10 +563,10 @@ Value::asAbsUInt() const { switch (type_) { - case NullValue: + case ValueType::Null: return 0; - case IntValue: { + case ValueType::Int: { // Doing this conversion through int64 avoids overflow error for // value_.intVal = -1 * 2^31 i.e. numeric_limits::min(). if (value_.intVal < 0) @@ -570,38 +574,37 @@ Value::asAbsUInt() const return value_.intVal; } - case UintValue: + case ValueType::UInt: return value_.uintVal; - case RealValue: { + case ValueType::Real: { if (value_.realVal < 0) { JSON_ASSERT_MESSAGE( - -1 * value_.realVal <= kMAX_U_INT, "Real out of unsigned integer range"); + -1 * value_.realVal <= kMAX_UINT, "Real out of unsigned integer range"); return UInt(-1 * value_.realVal); } - JSON_ASSERT_MESSAGE(value_.realVal <= kMAX_U_INT, "Real out of unsigned integer range"); + JSON_ASSERT_MESSAGE(value_.realVal <= kMAX_UINT, "Real out of unsigned integer range"); return UInt(value_.realVal); } - case BooleanValue: + case ValueType::Boolean: return value_.boolVal ? 1 : 0; - case StringValue: { + case ValueType::String: { char const* const str{(value_.stringVal != nullptr) ? value_.stringVal : ""}; auto const temp = beast::lexicalCastThrow(str); if (temp < 0) { - JSON_ASSERT_MESSAGE( - -1 * temp <= kMAX_U_INT, "String out of unsigned integer range"); + JSON_ASSERT_MESSAGE(-1 * temp <= kMAX_UINT, "String out of unsigned integer range"); return -1 * temp; } - JSON_ASSERT_MESSAGE(temp <= kMAX_U_INT, "String out of unsigned integer range"); + JSON_ASSERT_MESSAGE(temp <= kMAX_UINT, "String out of unsigned integer range"); return temp; } - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: JSON_ASSERT_MESSAGE(false, "Type is not convertible to int"); // LCOV_EXCL_START @@ -618,33 +621,33 @@ Value::asUInt() const { switch (type_) { - case NullValue: + case ValueType::Null: return 0; - case IntValue: + case ValueType::Int: JSON_ASSERT_MESSAGE( value_.intVal >= 0, "Negative integer can not be converted to unsigned integer"); return value_.intVal; - case UintValue: + case ValueType::UInt: return value_.uintVal; - case RealValue: + case ValueType::Real: JSON_ASSERT_MESSAGE( - (value_.realVal >= 0 && value_.realVal <= kMAX_U_INT), + (value_.realVal >= 0 && value_.realVal <= kMAX_UINT), "Real out of unsigned integer range"); return UInt(value_.realVal); - case BooleanValue: + case ValueType::Boolean: return value_.boolVal ? 1 : 0; - case StringValue: { + case ValueType::String: { char const* const str{(value_.stringVal != nullptr) ? value_.stringVal : ""}; return beast::lexicalCastThrow(str); } - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: JSON_ASSERT_MESSAGE(false, "Type is not convertible to uint"); // LCOV_EXCL_START @@ -661,24 +664,24 @@ Value::asDouble() const { switch (type_) { - case NullValue: + case ValueType::Null: return 0.0; - case IntValue: + case ValueType::Int: return value_.intVal; - case UintValue: + case ValueType::UInt: return value_.uintVal; - case RealValue: + case ValueType::Real: return value_.realVal; - case BooleanValue: + case ValueType::Boolean: return value_.boolVal ? 1.0 : 0.0; - case StringValue: - case ArrayValue: - case ObjectValue: + case ValueType::String: + case ValueType::Array: + case ValueType::Object: JSON_ASSERT_MESSAGE(false, "Type is not convertible to double"); // LCOV_EXCL_START @@ -695,24 +698,24 @@ Value::asBool() const { switch (type_) { - case NullValue: + case ValueType::Null: return false; - case IntValue: - case UintValue: + case ValueType::Int: + case ValueType::UInt: return value_.intVal != 0; - case RealValue: + case ValueType::Real: return value_.realVal != 0.0; - case BooleanValue: + case ValueType::Boolean: return value_.boolVal; - case StringValue: + case ValueType::String: return (value_.stringVal != nullptr) && value_.stringVal[0] != 0; - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: return !value_.mapVal->empty(); // LCOV_EXCL_START @@ -729,41 +732,47 @@ Value::isConvertibleTo(ValueType other) const { switch (type_) { - case NullValue: + case ValueType::Null: return true; - case IntValue: - return (other == NullValue && value_.intVal == 0) || other == IntValue || - (other == UintValue && value_.intVal >= 0) || other == RealValue || - other == StringValue || other == BooleanValue; + case ValueType::Int: + return (other == ValueType::Null && value_.intVal == 0) || other == ValueType::Int || + (other == ValueType::UInt && value_.intVal >= 0) || other == ValueType::Real || + other == ValueType::String || other == ValueType::Boolean; - case UintValue: - return (other == NullValue && value_.uintVal == 0) || - (other == IntValue && value_.uintVal <= (unsigned)kMAX_INT) || other == UintValue || - other == RealValue || other == StringValue || other == BooleanValue; + case ValueType::UInt: + return (other == ValueType::Null && value_.uintVal == 0) || + (other == ValueType::Int && value_.uintVal <= (unsigned)kMAX_INT) || + other == ValueType::UInt || other == ValueType::Real || + other == ValueType::String || other == ValueType::Boolean; - case RealValue: - return (other == NullValue && value_.realVal == 0.0) || - (other == IntValue && value_.realVal >= kMIN_INT && value_.realVal <= kMAX_INT) || - (other == UintValue && value_.realVal >= 0 && value_.realVal <= kMAX_U_INT && + case ValueType::Real: + return (other == ValueType::Null && value_.realVal == 0.0) || + (other == ValueType::Int && value_.realVal >= kMIN_INT && + value_.realVal <= kMAX_INT) || + (other == ValueType::UInt && value_.realVal >= 0 && value_.realVal <= kMAX_UINT && std::fabs(round(value_.realVal) - value_.realVal) < std::numeric_limits::epsilon()) || - other == RealValue || other == StringValue || other == BooleanValue; + other == ValueType::Real || other == ValueType::String || + other == ValueType::Boolean; - case BooleanValue: - return (other == NullValue && !value_.boolVal) || other == IntValue || - other == UintValue || other == RealValue || other == StringValue || - other == BooleanValue; + case ValueType::Boolean: + return (other == ValueType::Null && !value_.boolVal) || other == ValueType::Int || + other == ValueType::UInt || other == ValueType::Real || + other == ValueType::String || other == ValueType::Boolean; - case StringValue: - return other == StringValue || - (other == NullValue && ((value_.stringVal == nullptr) || value_.stringVal[0] == 0)); + case ValueType::String: + return other == ValueType::String || + (other == ValueType::Null && + ((value_.stringVal == nullptr) || value_.stringVal[0] == 0)); - case ArrayValue: - return other == ArrayValue || (other == NullValue && value_.mapVal->empty()); + case ValueType::Array: + return other == ValueType::Array || + (other == ValueType::Null && value_.mapVal->empty()); - case ObjectValue: - return other == ObjectValue || (other == NullValue && value_.mapVal->empty()); + case ValueType::Object: + return other == ValueType::Object || + (other == ValueType::Null && value_.mapVal->empty()); // LCOV_EXCL_START default: @@ -780,15 +789,15 @@ Value::size() const { switch (type_) { - case NullValue: - case IntValue: - case UintValue: - case RealValue: - case BooleanValue: - case StringValue: + case ValueType::Null: + case ValueType::Int: + case ValueType::UInt: + case ValueType::Real: + case ValueType::Boolean: + case ValueType::String: return 0; - case ArrayValue: // size of the array is highest index + 1 + case ValueType::Array: // size of the array is highest index + 1 if (!value_.mapVal->empty()) { ObjectValues::const_iterator itLast = value_.mapVal->end(); @@ -798,7 +807,7 @@ Value::size() const return 0; - case ObjectValue: + case ValueType::Object: return Int(value_.mapVal->size()); // LCOV_EXCL_START @@ -829,13 +838,13 @@ void Value::clear() { XRPL_ASSERT( - type_ == NullValue || type_ == ArrayValue || type_ == ObjectValue, + type_ == ValueType::Null || type_ == ValueType::Array || type_ == ValueType::Object, "json::Value::clear : valid type"); switch (type_) { - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: value_.mapVal->clear(); break; @@ -848,10 +857,11 @@ Value& Value::operator[](UInt index) { XRPL_ASSERT( - type_ == NullValue || type_ == ArrayValue, "json::Value::operator[](UInt) : valid type"); + type_ == ValueType::Null || type_ == ValueType::Array, + "json::Value::operator[](UInt) : valid type"); - if (type_ == NullValue) - *this = Value(ArrayValue); + if (type_ == ValueType::Null) + *this = Value(ValueType::Array); CZString const key(index); ObjectValues::iterator it = value_.mapVal->lower_bound(key); @@ -868,10 +878,10 @@ Value const& Value::operator[](UInt index) const { XRPL_ASSERT( - type_ == NullValue || type_ == ArrayValue, + type_ == ValueType::Null || type_ == ValueType::Array, "json::Value::operator[](UInt) const : valid type"); - if (type_ == NullValue) + if (type_ == ValueType::Null) return kNULL; CZString const key(index); @@ -893,12 +903,16 @@ Value& Value::resolveReference(char const* key, bool isStatic) { XRPL_ASSERT( - type_ == NullValue || type_ == ObjectValue, "json::Value::resolveReference : valid type"); + type_ == ValueType::Null || type_ == ValueType::Object, + "json::Value::resolveReference : valid type"); - if (type_ == NullValue) - *this = Value(ObjectValue); + if (type_ == ValueType::Null) + *this = Value(ValueType::Object); - CZString const actualKey(key, isStatic ? CZString::NoDuplication : CZString::DuplicateOnCopy); + CZString const actualKey( + key, + isStatic ? CZString::DuplicationPolicy::NoDuplication + : CZString::DuplicationPolicy::DuplicateOnCopy); ObjectValues::iterator it = value_.mapVal->lower_bound(actualKey); if (it != value_.mapVal->end() && (*it).first == actualKey) @@ -927,13 +941,13 @@ Value const& Value::operator[](char const* key) const { XRPL_ASSERT( - type_ == NullValue || type_ == ObjectValue, + type_ == ValueType::Null || type_ == ValueType::Object, "json::Value::operator[](const char*) const : valid type"); - if (type_ == NullValue) + if (type_ == ValueType::Null) return kNULL; - CZString const actualKey(key, CZString::NoDuplication); + CZString const actualKey(key, CZString::DuplicationPolicy::NoDuplication); ObjectValues::const_iterator const it = value_.mapVal->find(actualKey); if (it == value_.mapVal->end()) @@ -995,12 +1009,13 @@ Value Value::removeMember(char const* key) { XRPL_ASSERT( - type_ == NullValue || type_ == ObjectValue, "json::Value::removeMember : valid type"); + type_ == ValueType::Null || type_ == ValueType::Object, + "json::Value::removeMember : valid type"); - if (type_ == NullValue) + if (type_ == ValueType::Null) return kNULL; - CZString const actualKey(key, CZString::NoDuplication); + CZString const actualKey(key, CZString::DuplicationPolicy::NoDuplication); ObjectValues::iterator const it = value_.mapVal->find(actualKey); if (it == value_.mapVal->end()) @@ -1020,7 +1035,7 @@ Value::removeMember(std::string const& key) bool Value::isMember(char const* key) const { - if (type_ != ObjectValue) + if (type_ != ValueType::Object) return false; Value const* value = &((*this)[key]); @@ -1043,9 +1058,10 @@ Value::Members Value::getMemberNames() const { XRPL_ASSERT( - type_ == NullValue || type_ == ObjectValue, "json::Value::getMemberNames : valid type"); + type_ == ValueType::Null || type_ == ValueType::Object, + "json::Value::getMemberNames : valid type"); - if (type_ == NullValue) + if (type_ == ValueType::Null) return Value::Members(); Members members; @@ -1062,37 +1078,37 @@ Value::getMemberNames() const bool Value::isNull() const { - return type_ == NullValue; + return type_ == ValueType::Null; } bool Value::isBool() const { - return type_ == BooleanValue; + return type_ == ValueType::Boolean; } bool Value::isInt() const { - return type_ == IntValue; + return type_ == ValueType::Int; } bool Value::isUInt() const { - return type_ == UintValue; + return type_ == ValueType::UInt; } bool Value::isIntegral() const { - return type_ == IntValue || type_ == UintValue || type_ == BooleanValue; + return type_ == ValueType::Int || type_ == ValueType::UInt || type_ == ValueType::Boolean; } bool Value::isDouble() const { - return type_ == RealValue; + return type_ == ValueType::Real; } bool @@ -1104,31 +1120,31 @@ Value::isNumeric() const bool Value::isString() const { - return type_ == StringValue; + return type_ == ValueType::String; } bool Value::isArray() const { - return type_ == ArrayValue; + return type_ == ValueType::Array; } bool Value::isArrayOrNull() const { - return type_ == NullValue || type_ == ArrayValue; + return type_ == ValueType::Null || type_ == ValueType::Array; } bool Value::isObject() const { - return type_ == ObjectValue; + return type_ == ValueType::Object; } bool Value::isObjectOrNull() const { - return type_ == NullValue || type_ == ObjectValue; + return type_ == ValueType::Null || type_ == ValueType::Object; } std::string @@ -1143,8 +1159,8 @@ Value::begin() const { switch (type_) { - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: if (value_.mapVal != nullptr) return const_iterator(value_.mapVal->begin()); @@ -1161,8 +1177,8 @@ Value::end() const { switch (type_) { - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: if (value_.mapVal != nullptr) return const_iterator(value_.mapVal->end()); @@ -1179,8 +1195,8 @@ Value::begin() { switch (type_) { - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: if (value_.mapVal != nullptr) return iterator(value_.mapVal->begin()); break; @@ -1196,8 +1212,8 @@ Value::end() { switch (type_) { - case ArrayValue: - case ObjectValue: + case ValueType::Array: + case ValueType::Object: if (value_.mapVal != nullptr) return iterator(value_.mapVal->end()); break; diff --git a/src/libxrpl/json/json_writer.cpp b/src/libxrpl/json/json_writer.cpp index 6c138e1fb1..4c38bdcf92 100644 --- a/src/libxrpl/json/json_writer.cpp +++ b/src/libxrpl/json/json_writer.cpp @@ -188,31 +188,31 @@ FastWriter::writeValue(Value const& value) { switch (value.type()) { - case NullValue: + case ValueType::Null: document_ += "null"; break; - case IntValue: + case ValueType::Int: document_ += valueToString(value.asInt()); break; - case UintValue: + case ValueType::UInt: document_ += valueToString(value.asUInt()); break; - case RealValue: + case ValueType::Real: document_ += valueToString(value.asDouble()); break; - case StringValue: + case ValueType::String: document_ += valueToQuotedString(value.asCString()); break; - case BooleanValue: + case ValueType::Boolean: document_ += valueToString(value.asBool()); break; - case ArrayValue: { + case ValueType::Array: { document_ += "["; int const size = value.size(); @@ -228,7 +228,7 @@ FastWriter::writeValue(Value const& value) } break; - case ObjectValue: { + case ValueType::Object: { Value::Members members(value.getMemberNames()); document_ += "{"; @@ -271,35 +271,35 @@ StyledWriter::writeValue(Value const& value) { switch (value.type()) { - case NullValue: + case ValueType::Null: pushValue("null"); break; - case IntValue: + case ValueType::Int: pushValue(valueToString(value.asInt())); break; - case UintValue: + case ValueType::UInt: pushValue(valueToString(value.asUInt())); break; - case RealValue: + case ValueType::Real: pushValue(valueToString(value.asDouble())); break; - case StringValue: + case ValueType::String: pushValue(valueToQuotedString(value.asCString())); break; - case BooleanValue: + case ValueType::Boolean: pushValue(valueToString(value.asBool())); break; - case ArrayValue: + case ValueType::Array: writeArrayValue(value); break; - case ObjectValue: { + case ValueType::Object: { Value::Members members(value.getMemberNames()); if (members.empty()) @@ -506,35 +506,35 @@ StyledStreamWriter::writeValue(Value const& value) { switch (value.type()) { - case NullValue: + case ValueType::Null: pushValue("null"); break; - case IntValue: + case ValueType::Int: pushValue(valueToString(value.asInt())); break; - case UintValue: + case ValueType::UInt: pushValue(valueToString(value.asUInt())); break; - case RealValue: + case ValueType::Real: pushValue(valueToString(value.asDouble())); break; - case StringValue: + case ValueType::String: pushValue(valueToQuotedString(value.asCString())); break; - case BooleanValue: + case ValueType::Boolean: pushValue(valueToString(value.asBool())); break; - case ArrayValue: + case ValueType::Array: writeArrayValue(value); break; - case ObjectValue: { + case ValueType::Object: { Value::Members members(value.getMemberNames()); if (members.empty()) diff --git a/src/libxrpl/ledger/AcceptedLedgerTx.cpp b/src/libxrpl/ledger/AcceptedLedgerTx.cpp index 304c99ffcb..2275c3552f 100644 --- a/src/libxrpl/ledger/AcceptedLedgerTx.cpp +++ b/src/libxrpl/ledger/AcceptedLedgerTx.cpp @@ -35,17 +35,17 @@ AcceptedLedgerTx::AcceptedLedgerTx( met->add(s); rawMeta_ = std::move(s.modData()); - json_ = json::ObjectValue; - json_[jss::transaction] = txn_->getJson(JsonOptions::KNone); + json_ = json::ValueType::Object; + json_[jss::transaction] = txn_->getJson(JsonOptions::Values::None); - json_[jss::meta] = meta_.getJson(JsonOptions::KNone); + json_[jss::meta] = meta_.getJson(JsonOptions::Values::None); json_[jss::raw_meta] = strHex(rawMeta_); json_[jss::result] = transHuman(meta_.getResultTER()); if (!affected_.empty()) { - json::Value& affected = (json_[jss::affected] = json::ArrayValue); + json::Value& affected = (json_[jss::affected] = json::ValueType::Array); for (auto const& account : affected_) affected.append(toBase58(account)); } diff --git a/src/libxrpl/ledger/ApplyStateTable.cpp b/src/libxrpl/ledger/ApplyStateTable.cpp index f49b1d0122..608648de12 100644 --- a/src/libxrpl/ledger/ApplyStateTable.cpp +++ b/src/libxrpl/ledger/ApplyStateTable.cpp @@ -169,7 +169,7 @@ ApplyStateTable::apply( { // go through the original node for // modified fields saved on modification - if (obj.getFName().shouldMeta(SField::SMdChangeOrig) && + if (obj.getFName().shouldMeta(SField::kSMD_CHANGE_ORIG) && !curNode->hasMatchingEntry(obj)) prevs.emplaceBack(obj); } @@ -181,7 +181,7 @@ ApplyStateTable::apply( for (auto const& obj : *curNode) { // go through the final node for final fields - if (obj.getFName().shouldMeta(SField::SMdAlways | SField::SMdDeleteFinal)) + if (obj.getFName().shouldMeta(SField::kSMD_ALWAYS | SField::kSMD_DELETE_FINAL)) finals.emplaceBack(obj); } @@ -205,7 +205,7 @@ ApplyStateTable::apply( for (auto const& obj : *origNode) { // search the original node for values saved on modify - if (obj.getFName().shouldMeta(SField::SMdChangeOrig) && + if (obj.getFName().shouldMeta(SField::kSMD_CHANGE_ORIG) && !curNode->hasMatchingEntry(obj)) prevs.emplaceBack(obj); } @@ -217,7 +217,7 @@ ApplyStateTable::apply( for (auto const& obj : *curNode) { // search the final node for values saved always - if (obj.getFName().shouldMeta(SField::SMdAlways | SField::SMdChangeNew)) + if (obj.getFName().shouldMeta(SField::kSMD_ALWAYS | SField::kSMD_CHANGE_NEW)) finals.emplaceBack(obj); } @@ -240,7 +240,7 @@ ApplyStateTable::apply( { // save non-default values if (!obj.isDefault() && - obj.getFName().shouldMeta(SField::SMdCreate | SField::SMdAlways)) + obj.getFName().shouldMeta(SField::kSMD_CREATE | SField::kSMD_ALWAYS)) news.emplaceBack(obj); } @@ -269,7 +269,7 @@ ApplyStateTable::apply( // VFALCO For diagnostics do we want to show // metadata even when the base view is open? - JLOG(j.trace()) << "metadata " << meta.getJson(JsonOptions::KNone); + JLOG(j.trace()) << "metadata " << meta.getJson(JsonOptions::Values::None); metadata = meta; } diff --git a/src/libxrpl/ledger/Dir.cpp b/src/libxrpl/ledger/Dir.cpp index a633257b27..8744d0bc67 100644 --- a/src/libxrpl/ledger/Dir.cpp +++ b/src/libxrpl/ledger/Dir.cpp @@ -54,14 +54,14 @@ const_iterator::operator==(ConstIterator const& other) const XRPL_ASSERT( view_ == other.view_ && root_.key == other.root_.key, - "xrpl::const_iterator::operator== : views and roots are matching"); + "xrpl::Dir::ConstIterator::operator== : views and roots are matching"); return page_.key == other.page_.key && index_ == other.index_; } const_iterator::reference const_iterator::operator*() const { - XRPL_ASSERT(index_ != beast::kZERO, "xrpl::const_iterator::operator* : nonzero index"); + XRPL_ASSERT(index_ != beast::kZERO, "xrpl::Dir::ConstIterator::operator* : nonzero index"); if (!cache_) cache_ = view_->read(keylet::child(index_)); return *cache_; @@ -70,7 +70,7 @@ const_iterator::operator*() const const_iterator& const_iterator::operator++() { - XRPL_ASSERT(index_ != beast::kZERO, "xrpl::const_iterator::operator++ : nonzero index"); + XRPL_ASSERT(index_ != beast::kZERO, "xrpl::Dir::ConstIterator::operator++ : nonzero index"); if (++it_ != std::end(*indexes_)) { index_ = *it_; @@ -84,7 +84,8 @@ const_iterator::operator++() const_iterator const_iterator::operator++(int) { - XRPL_ASSERT(index_ != beast::kZERO, "xrpl::const_iterator::operator++(int) : nonzero index"); + XRPL_ASSERT( + index_ != beast::kZERO, "xrpl::Dir::ConstIterator::operator++(int) : nonzero index"); ConstIterator tmp(*this); ++(*this); return tmp; @@ -103,7 +104,7 @@ const_iterator::nextPage() { page_ = keylet::page(root_, next); sle_ = view_->read(page_); - XRPL_ASSERT(sle_, "xrpl::const_iterator::next_page : non-null SLE"); + XRPL_ASSERT(sle_, "xrpl::Dir::ConstIterator::nextPage : non-null SLE"); indexes_ = &sle_->getFieldV256(sfIndexes); if (indexes_->empty()) { diff --git a/src/libxrpl/ledger/Ledger.cpp b/src/libxrpl/ledger/Ledger.cpp index 9857b49b65..70d49de71e 100644 --- a/src/libxrpl/ledger/Ledger.cpp +++ b/src/libxrpl/ledger/Ledger.cpp @@ -315,8 +315,8 @@ Ledger::setImmutable(bool rehash) // place the hash transitions to valid if (!immutable_ && rehash) { - header_.txHash = txMap_.getHash().asUint256(); - header_.accountHash = stateMap_.getHash().asUint256(); + header_.txHash = txMap_.getHash().asUInt256(); + header_.accountHash = stateMap_.getHash().asUInt256(); } if (rehash) @@ -480,7 +480,7 @@ Ledger::digest(key_type const& key) const -> std::optional // from the NodeStore needlessly. if (!stateMap_.peekItem(key, digest)) return std::nullopt; - return digest.asUint256(); + return digest.asUInt256(); } //------------------------------------------------------------------------------ @@ -795,9 +795,9 @@ Ledger::isSensible() const return false; if (header_.accountHash.isZero()) return false; - if (header_.accountHash != stateMap_.getHash().asUint256()) + if (header_.accountHash != stateMap_.getHash().asUInt256()) return false; - if (header_.txHash != txMap_.getHash().asUint256()) + if (header_.txHash != txMap_.getHash().asUInt256()) return false; return true; } diff --git a/src/libxrpl/ledger/helpers/AMMHelpers.cpp b/src/libxrpl/ledger/helpers/AMMHelpers.cpp index 4cef02e056..cd1796468c 100644 --- a/src/libxrpl/ledger/helpers/AMMHelpers.cpp +++ b/src/libxrpl/ledger/helpers/AMMHelpers.cpp @@ -817,6 +817,9 @@ initializeFeeAuctionVote( { auctionSlot.makeFieldAbsent(sfDiscountedFee); // LCOV_EXCL_LINE } + // Clear stale auth accounts from any previous auction slot holder. + if (rules.enabled(fixCleanup3_2_0) && auctionSlot.isFieldPresent(sfAuthAccounts)) + auctionSlot.makeFieldAbsent(sfAuthAccounts); } Expected diff --git a/src/libxrpl/ledger/helpers/AccountRootHelpers.cpp b/src/libxrpl/ledger/helpers/AccountRootHelpers.cpp index 052c93739c..160629d835 100644 --- a/src/libxrpl/ledger/helpers/AccountRootHelpers.cpp +++ b/src/libxrpl/ledger/helpers/AccountRootHelpers.cpp @@ -152,7 +152,7 @@ pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey) RipeshaHasher rsh; auto const hash = sha512Half(i, view.header().parentHash, pseudoOwnerKey); rsh(hash.data(), hash.size()); - AccountID const ret{static_cast(rsh)}; + AccountID const ret = AccountID::fromRaw(static_cast(rsh)); if (!view.read(keylet::account(ret))) return ret; } @@ -183,7 +183,7 @@ getPseudoAccountFields() std::vector pseudoFields; for (auto const& field : soTemplate) { - if (field.sField().shouldMeta(SField::SMdPseudoAccount)) + if (field.sField().shouldMeta(SField::kSMD_PSEUDO_ACCOUNT)) pseudoFields.emplace_back(&field.sField()); } return pseudoFields; diff --git a/src/libxrpl/ledger/helpers/CredentialHelpers.cpp b/src/libxrpl/ledger/helpers/CredentialHelpers.cpp index 22122216bc..8954f3fd5e 100644 --- a/src/libxrpl/ledger/helpers/CredentialHelpers.cpp +++ b/src/libxrpl/ledger/helpers/CredentialHelpers.cpp @@ -1,5 +1,6 @@ #include +#include #include #include #include @@ -9,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -33,15 +35,16 @@ namespace xrpl { namespace credentials { bool -checkExpired(std::shared_ptr const& sleCredential, NetClock::time_point const& closed) +checkExpired(SLE const& sleCredential, NetClock::time_point const& closed) { std::uint32_t const exp = - (*sleCredential)[~sfExpiration].value_or(std::numeric_limits::max()); + sleCredential[~sfExpiration].value_or(std::numeric_limits::max()); std::uint32_t const now = closed.time_since_epoch().count(); return now > exp; } -bool +[[nodiscard]] +static Expected removeExpired(ApplyView& view, STVector256 const& arr, beast::Journal const j) { auto const closeTime = view.header().parentCloseTime; @@ -53,11 +56,13 @@ removeExpired(ApplyView& view, STVector256 const& arr, beast::Journal const j) auto const k = keylet::credential(h); auto const sleCred = view.peek(k); - if (sleCred && checkExpired(sleCred, closeTime)) + if (sleCred && checkExpired(*sleCred, closeTime)) { JLOG(j.trace()) << "Credentials are expired. Cred: " << sleCred->getText(); // delete expired credentials even if the transaction failed - deleteSLE(view, sleCred, j); + auto const err = deleteSLE(view, sleCred, j); + if (view.rules().enabled(fixCleanup3_1_3) && !isTesSuccess(err)) + return Unexpected(err); foundExpired = true; } } @@ -100,7 +105,7 @@ deleteSLE(ApplyView& view, std::shared_ptr const& sleCredential, beast::Jou auto const issuer = sleCredential->getAccountID(sfIssuer); auto const subject = sleCredential->getAccountID(sfSubject); - bool const accepted = (sleCredential->getFlags() & lsfAccepted) != 0u; + bool const accepted = sleCredential->isFlag(lsfAccepted); auto err = delSLE(issuer, sfIssuerNode, !accepted || (subject == issuer)); if (!isTesSuccess(err)) @@ -169,7 +174,7 @@ valid(STTx const& tx, ReadView const& view, AccountID const& src, beast::Journal return tecBAD_CREDENTIALS; } - if ((sleCred->getFlags() & lsfAccepted) == 0u) + if (!sleCred->isFlag(lsfAccepted)) { JLOG(j.trace()) << "Credential isn't accepted. Cred: " << h; return tecBAD_CREDENTIALS; @@ -205,12 +210,12 @@ validDomain(ReadView const& view, uint256 domainID, AccountID const& subject) // allows expired credentials to be deleted by any transaction. if (sleCredential) { - if (checkExpired(sleCredential, closeTime)) + if (checkExpired(*sleCredential, closeTime)) { foundExpired = true; continue; } - if ((sleCredential->getFlags() & lsfAccepted) != 0u) + if (sleCredential->isFlag(lsfAccepted)) { return tesSUCCESS; } @@ -324,18 +329,21 @@ verifyValidDomain(ApplyView& view, AccountID const& account, uint256 domainID, b credentials.pushBack(keyletCredential.key); } - bool const foundExpired = credentials::removeExpired(view, credentials, j); + auto const foundExpired = credentials::removeExpired(view, credentials, j); + if (!foundExpired.has_value()) + return foundExpired.error(); + for (auto const& h : credentials) { auto sleCredential = view.read(keylet::credential(h)); if (!sleCredential) continue; // expired, i.e. deleted in credentials::removeExpired - if ((sleCredential->getFlags() & lsfAccepted) != 0u) + if (sleCredential->isFlag(lsfAccepted)) return tesSUCCESS; } - return foundExpired ? tecEXPIRED : tecNO_PERMISSION; + return *foundExpired ? tecEXPIRED : tecNO_PERMISSION; } TER @@ -355,10 +363,17 @@ verifyDepositPreauth( bool const credentialsPresent = tx.isFieldPresent(sfCredentialIDs); - if (credentialsPresent && credentials::removeExpired(view, tx.getFieldV256(sfCredentialIDs), j)) - return tecEXPIRED; + if (credentialsPresent) + { + auto const foundExpired = + credentials::removeExpired(view, tx.getFieldV256(sfCredentialIDs), j); + if (!foundExpired.has_value()) + return foundExpired.error(); + if (*foundExpired) + return tecEXPIRED; + } - if (sleDst && ((sleDst->getFlags() & lsfDepositAuth) != 0u)) + if (sleDst && sleDst->isFlag(lsfDepositAuth)) { if (src != dst) { diff --git a/src/libxrpl/ledger/helpers/LendingHelpers.cpp b/src/libxrpl/ledger/helpers/LendingHelpers.cpp index 28b0c8976d..3bfa18e3e8 100644 --- a/src/libxrpl/ledger/helpers/LendingHelpers.cpp +++ b/src/libxrpl/ledger/helpers/LendingHelpers.cpp @@ -110,14 +110,78 @@ LoanStateDeltas::nonNegative() managementFee = kNUM_ZERO; } -/* Computes (1 + periodicRate)^paymentsRemaining for amortization calculations. +/* Computes (1 + r)^n - 1 accurately even for near-zero r, where direct + * subtraction of `power(1 + r, n) - 1` suffers catastrophic cancellation. * - * Equation (5) from XLS-66 spec, Section A-2 Equation Glossary + * The binomial expansion gives + * (1 + r)^n - 1 = sum_{k=1}^{n} C(n,k) r^k + * = nr + C(n,2) r^2 + ... + r^n + * which is a sum of positive terms when r >= 0, avoiding cancellation. + * Each term is computed from the previous via + * term_{k+1} = term_k * r * (n - k) / (k + 1) + * + * The loop terminates early once the next term is below Number precision. */ Number -computeRaisedRate(Number const& periodicRate, std::uint32_t paymentsRemaining) +computePowerMinusOne(Number const& periodicRate, std::uint32_t paymentsRemaining) { - return power(1 + periodicRate, paymentsRemaining); + XRPL_ASSERT_PARTS( + periodicRate >= beast::kZERO, + "xrpl::detail::computePowerMinusOne", + "periodicRate is non-negative"); + + if (paymentsRemaining == 0 || periodicRate == beast::kZERO) + return kNUM_ZERO; + + // k = 1 term: C(n, 1) * r = n * r + Number term = paymentsRemaining * periodicRate; + Number sum = term; + for (std::uint32_t k = 1; k < paymentsRemaining; ++k) + { + // term_{k+1} from term_k: multiply by r * (n - k) / (k + 1) + term = term * periodicRate * (paymentsRemaining - k) / (k + 1); + Number const next = sum + term; + // adding this term fell below Number's precision + if (next == sum) + break; + sum = next; + } + return sum; +} + +/* Hybrid evaluator of (1 + r)^n - 1. + * + * The closed-form `power(1 + r, n) - 1` loses sig digits to cancellation + * when `r * n` is small: the result `~r*n` sits well below the `1` that + * dominates `(1+r)^n`, so most of Number's stored precision is consumed + * by the leading `1`. + * + * A threshold of `1e-9` preserves the closed-form path for any rate the + * lending code actually sees in practice (fixtures at moderate rates are bit-exact), + * while routing the pathological near-zero regime through the binomial + * expansion where cancellation is severe. + */ +Number +computePowerMinusOneHybrid(Number const& periodicRate, std::uint32_t paymentsRemaining) +{ + XRPL_ASSERT_PARTS( + periodicRate >= beast::kZERO, + "xrpl::detail::computePowerMinusOneHybrid", + "periodicRate is non-negative"); + + if (paymentsRemaining == 0 || periodicRate == beast::kZERO) + return kNUM_ZERO; + + // Threshold 1e-9 retains ~10 sig digits of (1+r)^n - 1 against + // Number's 19-digit mantissa: the leading "1" of (1+r)^n consumes + // ~log10(1/(r*n)) digits before the subtraction. Above this point + // closed form is accurate and ~30-500x faster than the binomial + // expansion. + Number const cancellationThreshold{1, -9}; + if (paymentsRemaining * periodicRate >= cancellationThreshold) + return power(1 + periodicRate, paymentsRemaining) - 1; + + return computePowerMinusOne(periodicRate, paymentsRemaining); } /* Computes the payment factor used in standard amortization formulas. @@ -126,7 +190,10 @@ computeRaisedRate(Number const& periodicRate, std::uint32_t paymentsRemaining) * Equation (6) from XLS-66 spec, Section A-2 Equation Glossary */ Number -computePaymentFactor(Number const& periodicRate, std::uint32_t paymentsRemaining) +computePaymentFactor( + Rules const& rules, + Number const& periodicRate, + std::uint32_t paymentsRemaining) { if (paymentsRemaining == 0) return kNUM_ZERO; @@ -135,7 +202,19 @@ computePaymentFactor(Number const& periodicRate, std::uint32_t paymentsRemaining if (periodicRate == beast::kZERO) return Number{1} / paymentsRemaining; - Number const raisedRate = computeRaisedRate(periodicRate, paymentsRemaining); + if (rules.enabled(fixCleanup3_2_0)) + { + Number const raisedRateMinusOne = + computePowerMinusOneHybrid(periodicRate, paymentsRemaining); + Number const raisedRate = 1 + raisedRateMinusOne; + + return (periodicRate * raisedRate) / raisedRateMinusOne; + } + + // Pre-fixCleanup3_2_0: direct subtraction `(1+r)^n - 1` suffers + // catastrophic cancellation at near-zero rates. Retained for + // amendment-gated bit-exact pre-fix behavior. + Number const raisedRate = power(1 + periodicRate, paymentsRemaining); return (periodicRate * raisedRate) / (raisedRate - 1); } @@ -147,6 +226,7 @@ computePaymentFactor(Number const& periodicRate, std::uint32_t paymentsRemaining */ Number loanPeriodicPayment( + Rules const& rules, Number const& principalOutstanding, Number const& periodicRate, std::uint32_t paymentsRemaining) @@ -158,7 +238,7 @@ loanPeriodicPayment( if (periodicRate == beast::kZERO) return principalOutstanding / paymentsRemaining; - return principalOutstanding * computePaymentFactor(periodicRate, paymentsRemaining); + return principalOutstanding * computePaymentFactor(rules, periodicRate, paymentsRemaining); } /* Reverse-calculates principal from periodic payment amount. @@ -168,6 +248,7 @@ loanPeriodicPayment( */ Number loanPrincipalFromPeriodicPayment( + Rules const& rules, Number const& periodicPayment, Number const& periodicRate, std::uint32_t paymentsRemaining) @@ -178,7 +259,7 @@ loanPrincipalFromPeriodicPayment( if (periodicRate == 0) return periodicPayment * paymentsRemaining; - return periodicPayment / computePaymentFactor(periodicRate, paymentsRemaining); + return periodicPayment / computePaymentFactor(rules, periodicRate, paymentsRemaining); } /* @@ -402,6 +483,7 @@ doPayment( */ Expected, TER> tryOverpayment( + Rules const& rules, Asset const& asset, std::int32_t loanScale, ExtendedPaymentComponents const& overpaymentComponents, @@ -414,7 +496,7 @@ tryOverpayment( { // Calculate what the loan state SHOULD be theoretically (at full precision) auto const theoreticalState = computeTheoreticalLoanState( - periodicPayment, periodicRate, paymentRemaining, managementFeeRate); + rules, periodicPayment, periodicRate, paymentRemaining, managementFeeRate); // Calculate the accumulated rounding errors. These need to be preserved // across the re-amortization to maintain consistency with the loan's @@ -432,6 +514,7 @@ tryOverpayment( // recalculates the periodic payment, total value, and management fees // for the remaining payment schedule. auto newLoanProperties = computeLoanProperties( + rules, asset, newTheoreticalPrincipal, periodicRate, @@ -445,9 +528,12 @@ tryOverpayment( // Calculate what the new loan state should be with the new periodic payment // including rounding errors - auto const newTheoreticalState = - computeTheoreticalLoanState( - newLoanProperties.periodicPayment, periodicRate, paymentRemaining, managementFeeRate) + + auto const newTheoreticalState = computeTheoreticalLoanState( + rules, + newLoanProperties.periodicPayment, + periodicRate, + paymentRemaining, + managementFeeRate) + errors; JLOG(j.debug()) << "new theoretical value: " << newTheoreticalState.valueOutstanding @@ -582,6 +668,7 @@ tryOverpayment( template Expected doOverpayment( + Rules const& rules, Asset const& asset, std::int32_t loanScale, ExtendedPaymentComponents const& overpaymentComponents, @@ -610,6 +697,7 @@ doOverpayment( // Attempt to re-amortize the loan with the overpayment applied. // This modifies the temporary copies, leaving the proxies unchanged. auto const ret = tryOverpayment( + rules, asset, loanScale, overpaymentComponents, @@ -823,8 +911,8 @@ computeFullPayment( // Calculate the theoretical principal based on the payment schedule. // This theoretical (unrounded) value is used to compute interest and // penalties accurately. - Number const theoreticalPrincipalOutstanding = - loanPrincipalFromPeriodicPayment(periodicPayment, periodicRate, paymentRemaining); + Number const theoreticalPrincipalOutstanding = loanPrincipalFromPeriodicPayment( + view.rules(), periodicPayment, periodicRate, paymentRemaining); // Full payment interest includes both accrued interest (time since last // payment) and prepayment penalty (for closing early). @@ -929,6 +1017,7 @@ PaymentComponents::trackedInterestPart() const */ PaymentComponents computePaymentComponents( + Rules const& rules, Asset const& asset, std::int32_t scale, Number const& totalValueOutstanding, @@ -966,7 +1055,7 @@ computePaymentComponents( // Calculate what the loan state SHOULD be after this payment (the target). // This is computed at full precision using the theoretical amortization. LoanState const trueTarget = computeTheoreticalLoanState( - periodicPayment, periodicRate, paymentRemaining - 1, managementFeeRate); + rules, periodicPayment, periodicRate, paymentRemaining - 1, managementFeeRate); // Round the target to the loan's scale to match how actual loan values // are stored. @@ -1379,6 +1468,7 @@ computeFullPaymentInterest( */ LoanState computeTheoreticalLoanState( + Rules const& rules, Number const& periodicPayment, Number const& periodicRate, std::uint32_t const paymentRemaining, @@ -1396,8 +1486,8 @@ computeTheoreticalLoanState( // Equation (30) from XLS-66 spec, Section A-2 Equation Glossary Number const totalValueOutstanding = periodicPayment * paymentRemaining; - Number const principalOutstanding = - detail::loanPrincipalFromPeriodicPayment(periodicPayment, periodicRate, paymentRemaining); + Number const principalOutstanding = detail::loanPrincipalFromPeriodicPayment( + rules, periodicPayment, periodicRate, paymentRemaining); // Equation (31) from XLS-66 spec, Section A-2 Equation Glossary Number const interestOutstandingGross = totalValueOutstanding - principalOutstanding; @@ -1488,6 +1578,7 @@ computeManagementFee( */ LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, TenthBips32 interestRate, @@ -1499,6 +1590,7 @@ computeLoanProperties( auto const periodicRate = loanPeriodicRate(interestRate, paymentInterval); XRPL_ASSERT(interestRate == 0 || periodicRate > 0, "xrpl::computeLoanProperties : valid rate"); return computeLoanProperties( + rules, asset, principalOutstanding, periodicRate, @@ -1517,6 +1609,7 @@ computeLoanProperties( */ LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, Number const& periodicRate, @@ -1525,7 +1618,7 @@ computeLoanProperties( std::int32_t minimumScale) { auto const periodicPayment = - detail::loanPeriodicPayment(principalOutstanding, periodicRate, paymentsRemaining); + detail::loanPeriodicPayment(rules, principalOutstanding, periodicRate, paymentsRemaining); auto const [totalValueOutstanding, loanScale] = [&]() { // only round up if there should be interest @@ -1573,10 +1666,10 @@ computeLoanProperties( // Compute the parts for the first payment. Ensure that the // principal payment will actually change the principal. auto const startingState = computeTheoreticalLoanState( - periodicPayment, periodicRate, paymentsRemaining, managementFeeRate); + rules, periodicPayment, periodicRate, paymentsRemaining, managementFeeRate); auto const firstPaymentState = computeTheoreticalLoanState( - periodicPayment, periodicRate, paymentsRemaining - 1, managementFeeRate); + rules, periodicPayment, periodicRate, paymentsRemaining - 1, managementFeeRate); // The unrounded principal part needs to be large enough to affect // the principal. What to do if not is left to the caller @@ -1733,6 +1826,7 @@ loanMakePayment( // payment is late or regular detail::ExtendedPaymentComponents periodic{ detail::computePaymentComponents( + view.rules(), asset, loanScale, totalValueOutstandingProxy, @@ -1841,6 +1935,7 @@ loanMakePayment( periodic = detail::ExtendedPaymentComponents{ detail::computePaymentComponents( + view.rules(), asset, loanScale, totalValueOutstandingProxy, @@ -1868,8 +1963,18 @@ loanMakePayment( // ------------------------------------------------------------- // overpayment handling + // + // If the "fixCleanup3_1_3" amendment is enabled, truncate "amount", + // at the loan scale. If the raw value is used, the overpayment + // amount could be meaningless dust. Trying to process such a small + // amount will, at best, waste time when all the result values round + // to zero. At worst, it can cause logical errors with tiny amounts + // of interest that don't add up correctly. + auto const roundedAmount = view.rules().enabled(fixCleanup3_1_3) + ? roundToAsset(asset, amount, loanScale, Number::RoundingMode::TowardsZero) + : amount; if (paymentType == LoanPaymentType::Overpayment && loan->isFlag(lsfLoanOverpayment) && - paymentRemainingProxy > 0 && totalPaid < amount && + paymentRemainingProxy > 0 && totalPaid < roundedAmount && numPayments < kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION) { TenthBips32 const overpaymentInterestRate{loan->at(sfOverpaymentInterestRate)}; @@ -1878,7 +1983,7 @@ loanMakePayment( // It shouldn't be possible for the overpayment to be greater than // totalValueOutstanding, because that would have been processed as // another normal payment. But cap it just in case. - Number const overpayment = std::min(amount - totalPaid, *totalValueOutstandingProxy); + Number const overpayment = std::min(roundedAmount - totalPaid, *totalValueOutstandingProxy); detail::ExtendedPaymentComponents const overpaymentComponents = detail::computeOverpaymentComponents( @@ -1901,6 +2006,7 @@ loanMakePayment( // change auto periodicPaymentProxy = loan->at(sfPeriodicPayment); if (auto const overResult = detail::doOverpayment( + view.rules(), asset, loanScale, overpaymentComponents, diff --git a/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp b/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp index 1709674b7f..754002b109 100644 --- a/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp +++ b/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp @@ -168,7 +168,7 @@ authorizeMPToken( auto const mptokenKey = keylet::mptoken(mptIssuanceID, account); auto const sleMpt = view.peek(mptokenKey); if (!sleMpt || (*sleMpt)[sfMPTAmount] != 0 || - (view.rules().enabled(fixSecurity3_1_3) && + (view.rules().enabled(fixCleanup3_1_3) && (*sleMpt)[~sfLockedAmount].valueOr(0) != 0)) return tecINTERNAL; // LCOV_EXCL_LINE @@ -283,7 +283,7 @@ removeEmptyHolding( // accounting out of balance, so fail. Since this should be impossible // anyway, I'm not going to put any effort into it. if (mptoken->at(sfMPTAmount) != 0 || - (view.rules().enabled(fixSecurity3_1_3) && (*mptoken)[~sfLockedAmount].valueOr(0) != 0)) + (view.rules().enabled(fixCleanup3_1_3) && (*mptoken)[~sfLockedAmount].valueOr(0) != 0)) return tecHAS_OBLIGATIONS; return authorizeMPToken( @@ -357,7 +357,7 @@ requireAuth( if (maybeDomainID) { XRPL_ASSERT( - sleIssuance->getFieldU32(sfFlags) & lsfMPTRequireAuth, + sleIssuance->isFlag(lsfMPTRequireAuth), "xrpl::requireAuth : issuance requires authorization"); // ter = tefINTERNAL | tecOBJECT_NOT_FOUND | tecNO_AUTH | tecEXPIRED auto const ter = credentials::validDomain(view, *maybeDomainID, account); diff --git a/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp b/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp index eb69ec93d0..c1fdd403d6 100644 --- a/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp +++ b/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp @@ -636,8 +636,8 @@ deleteTokenOffer(ApplyView& view, std::shared_ptr const& offer) auto const nftokenID = (*offer)[sfNFTokenID]; if (!view.dirRemove( - (((*offer)[sfFlags] & lsfSellNFToken) != 0u) ? keylet::nftSells(nftokenID) - : keylet::nftBuys(nftokenID), + offer->isFlag(lsfSellNFToken) ? keylet::nftSells(nftokenID) + : keylet::nftBuys(nftokenID), (*offer)[sfNFTokenOfferNode], offer->key(), false)) @@ -888,7 +888,7 @@ tokenOfferCreatePreclaim( return tecNO_DST; // check if the destination has disallowed incoming offers - if ((sleDst->getFlags() & lsfDisallowIncomingNFTokenOffer) != 0u) + if (sleDst->isFlag(lsfDisallowIncomingNFTokenOffer)) return tecNO_PERMISSION; } @@ -901,7 +901,7 @@ tokenOfferCreatePreclaim( if (!sleOwner) return tecNO_TARGET; - if ((sleOwner->getFlags() & lsfDisallowIncomingNFTokenOffer) != 0u) + if (sleOwner->isFlag(lsfDisallowIncomingNFTokenOffer)) return tecNO_PERMISSION; } diff --git a/src/libxrpl/ledger/helpers/PermissionedDEXHelpers.cpp b/src/libxrpl/ledger/helpers/PermissionedDEXHelpers.cpp index 456c4e95d6..0151c5b2df 100644 --- a/src/libxrpl/ledger/helpers/PermissionedDEXHelpers.cpp +++ b/src/libxrpl/ledger/helpers/PermissionedDEXHelpers.cpp @@ -35,7 +35,7 @@ accountInDomain(ReadView const& view, AccountID const& account, Domain const& do if (!sleCred || !sleCred->isFlag(lsfAccepted)) return false; - return !credentials::checkExpired(sleCred, view.header().parentCloseTime); + return !credentials::checkExpired(*sleCred, view.header().parentCloseTime); }); return inDomain; @@ -60,9 +60,9 @@ offerInDomain( if (sleOffer->getFieldH256(sfDomainID) != domainID) return false; // LCOV_EXCL_LINE - if (view.rules().enabled(fixSecurity3_1_3)) + if (view.rules().enabled(fixCleanup3_1_3)) { - // post-fixSecurity3_1_3: a valid hybrid offer must have + // post-fixCleanup3_1_3: a valid hybrid offer must have // sfAdditionalBooks present with exactly 1 entry if (sleOffer->isFlag(lsfHybrid) && (!sleOffer->isFieldPresent(sfAdditionalBooks) || @@ -75,7 +75,7 @@ offerInDomain( } else { - // pre-fixSecurity3_1_3: a valid hybrid offer must have + // pre-fixCleanup3_1_3: a valid hybrid offer must have // sfAdditionalBooks present (size is not checked) if (sleOffer->isFlag(lsfHybrid) && !sleOffer->isFieldPresent(sfAdditionalBooks)) { diff --git a/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp b/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp index 58f44534cf..e31309a9dd 100644 --- a/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp +++ b/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp @@ -274,7 +274,7 @@ trustCreate( uFlags |= (bSetHigh ? lsfHighDeepFreeze : lsfLowDeepFreeze); } - if ((slePeer->getFlags() & lsfDefaultRipple) == 0) + if (!slePeer->isFlag(lsfDefaultRipple)) { // The other side's default is no rippling uFlags |= (bSetHigh ? lsfLowNoRipple : lsfHighNoRipple); @@ -341,22 +341,25 @@ updateTrustLine( { if (!state) return false; - std::uint32_t const flags(state->getFieldU32(sfFlags)); auto sle = view.peek(keylet::account(sender)); if (!sle) return false; + auto const senderReserveFlag = bSenderHigh ? lsfHighReserve : lsfLowReserve; + auto const senderNoRippleFlag = bSenderHigh ? lsfHighNoRipple : lsfLowNoRipple; + auto const senderFreezeFlag = bSenderHigh ? lsfHighFreeze : lsfLowFreeze; + auto const receiverReserveFlag = bSenderHigh ? lsfLowReserve : lsfHighReserve; + // YYY Could skip this if rippling in reverse. if (before > beast::kZERO // Sender balance was positive. && after <= beast::kZERO // Sender is zero or negative. - && ((flags & (!bSenderHigh ? lsfLowReserve : lsfHighReserve)) != 0u) + && state->isFlag(senderReserveFlag) // Sender reserve is set. - && static_cast(flags & (!bSenderHigh ? lsfLowNoRipple : lsfHighNoRipple)) != - static_cast(sle->getFlags() & lsfDefaultRipple) && - ((flags & (!bSenderHigh ? lsfLowFreeze : lsfHighFreeze)) == 0u) && + && state->isFlag(senderNoRippleFlag) != sle->isFlag(lsfDefaultRipple) && + !state->isFlag(senderFreezeFlag) && !state->getFieldAmount(!bSenderHigh ? sfLowLimit : sfHighLimit) // Sender trust limit is 0. && (state->getFieldU32(!bSenderHigh ? sfLowQualityIn : sfHighQualityIn) == 0u) @@ -369,11 +372,10 @@ updateTrustLine( adjustOwnerCount(view, sle, -1, j); // Clear reserve flag. - state->setFieldU32(sfFlags, flags & (!bSenderHigh ? ~lsfLowReserve : ~lsfHighReserve)); + state->clearFlag(senderReserveFlag); // Balance is zero, receiver reserve is clear. - if (!after // Balance is zero. - && ((flags & (bSenderHigh ? lsfLowReserve : lsfHighReserve)) == 0u)) + if (!after && !state->isFlag(receiverReserveFlag)) return true; } return false; @@ -453,7 +455,7 @@ issueIOU( if (!receiverAccount) return tefINTERNAL; // LCOV_EXCL_LINE - bool const noRipple = (receiverAccount->getFlags() & lsfDefaultRipple) == 0; + bool const noRipple = !receiverAccount->isFlag(lsfDefaultRipple); return trustCreate( view, @@ -564,12 +566,11 @@ requireAuth(ReadView const& view, Issue const& issue, AccountID const& account, // If this is a weak or legacy check, or if the account has a line, fail if // auth is required and not set on the line if (auto const issuerAccount = view.read(keylet::account(issue.account)); - issuerAccount && (((*issuerAccount)[sfFlags] & lsfRequireAuth) != 0u)) + issuerAccount && issuerAccount->isFlag(lsfRequireAuth)) { if (trustLine) { - return (((*trustLine)[sfFlags] & - ((account > issue.account) ? lsfLowAuth : lsfHighAuth)) != 0u) + return trustLine->isFlag((account > issue.account) ? lsfLowAuth : lsfHighAuth) ? tesSUCCESS : TER{tecNO_AUTH}; } @@ -774,7 +775,7 @@ deleteAMMTrustLine( } auto const uFlags = !ammLow ? lsfLowReserve : lsfHighReserve; - if ((sleState->getFlags() & uFlags) == 0u) + if (!sleState->isFlag(uFlags)) return tecINTERNAL; // LCOV_EXCL_LINE adjustOwnerCount(view, !ammLow ? sleLow : sleHigh, -1, j); diff --git a/src/libxrpl/ledger/helpers/TokenHelpers.cpp b/src/libxrpl/ledger/helpers/TokenHelpers.cpp index bc5d3bb4b6..094865837f 100644 --- a/src/libxrpl/ledger/helpers/TokenHelpers.cpp +++ b/src/libxrpl/ledger/helpers/TokenHelpers.cpp @@ -585,39 +585,41 @@ directSendNoFeeIOU( << " amount=" << saAmount.getFullText() << " after=" << saBalance.getFullText(); - std::uint32_t const uFlags(sleRippleState->getFieldU32(sfFlags)); bool bDelete = false; + auto const senderReserveFlag = bSenderHigh ? lsfHighReserve : lsfLowReserve; + auto const senderNoRippleFlag = bSenderHigh ? lsfHighNoRipple : lsfLowNoRipple; + auto const senderFreezeFlag = bSenderHigh ? lsfHighFreeze : lsfLowFreeze; + auto const receiverReserveFlag = bSenderHigh ? lsfLowReserve : lsfHighReserve; + // FIXME This NEEDS to be cleaned up and simplified. It's impossible // for anyone to understand. if (saBefore > beast::kZERO // Sender balance was positive. && saBalance <= beast::kZERO // Sender is zero or negative. - && ((uFlags & (!bSenderHigh ? lsfLowReserve : lsfHighReserve)) != 0u) + && sleRippleState->isFlag(senderReserveFlag) // Sender reserve is set. - && static_cast(uFlags & (!bSenderHigh ? lsfLowNoRipple : lsfHighNoRipple)) != - static_cast( - view.read(keylet::account(uSenderID))->getFlags() & lsfDefaultRipple) && - ((uFlags & (!bSenderHigh ? lsfLowFreeze : lsfHighFreeze)) == 0u) && - !sleRippleState->getFieldAmount(!bSenderHigh ? sfLowLimit : sfHighLimit) + && sleRippleState->isFlag(senderNoRippleFlag) != + view.read(keylet::account(uSenderID))->isFlag(lsfDefaultRipple) && + !sleRippleState->isFlag(senderFreezeFlag) && + !sleRippleState->getFieldAmount(bSenderHigh ? sfHighLimit : sfLowLimit) // Sender trust limit is 0. - && (sleRippleState->getFieldU32(!bSenderHigh ? sfLowQualityIn : sfHighQualityIn) == 0u) + && (sleRippleState->getFieldU32(bSenderHigh ? sfHighQualityIn : sfLowQualityIn) == 0u) // Sender quality in is 0. && - (sleRippleState->getFieldU32(!bSenderHigh ? sfLowQualityOut : sfHighQualityOut) == 0u)) + (sleRippleState->getFieldU32(bSenderHigh ? sfHighQualityOut : sfLowQualityOut) == 0u)) // Sender quality out is 0. { // Clear the reserve of the sender, possibly delete the line! adjustOwnerCount(view, view.peek(keylet::account(uSenderID)), -1, j); // Clear reserve flag. - sleRippleState->setFieldU32( - sfFlags, uFlags & (!bSenderHigh ? ~lsfLowReserve : ~lsfHighReserve)); + sleRippleState->clearFlag(senderReserveFlag); // Balance is zero, receiver reserve is clear. bDelete = !saBalance // Balance is zero. - && ((uFlags & (bSenderHigh ? lsfLowReserve : lsfHighReserve)) == 0u); + && !sleRippleState->isFlag(receiverReserveFlag); // Receiver reserve is clear. } @@ -634,7 +636,7 @@ directSendNoFeeIOU( view, sleRippleState, bSenderHigh ? uReceiverID : uSenderID, - !bSenderHigh ? uReceiverID : uSenderID, + bSenderHigh ? uSenderID : uReceiverID, j); } @@ -656,7 +658,7 @@ directSendNoFeeIOU( if (!sleAccount) return tefINTERNAL; // LCOV_EXCL_LINE - bool const noRipple = (sleAccount->getFlags() & lsfDefaultRipple) == 0; + bool const noRipple = !sleAccount->isFlag(lsfDefaultRipple); return trustCreate( view, @@ -1238,9 +1240,9 @@ directSendNoLimitMultiMPT( std::uint64_t const sendAmount = amount.mpt().value(); - if (view.rules().enabled(fixSecurity3_1_3)) + if (view.rules().enabled(fixCleanup3_1_3)) { - // Post-fixSecurity3_1_3: aggregate MaximumAmount + // Post-fixCleanup3_1_3: aggregate MaximumAmount // check. WARNING: the order of conditions is // critical — each guards the subtraction in the // next against unsigned underflow. Do not reorder. @@ -1258,7 +1260,7 @@ directSendNoLimitMultiMPT( } else { - // Pre-fixSecurity3_1_3: per-iteration MaximumAmount + // Pre-fixCleanup3_1_3: per-iteration MaximumAmount // check. Reads sfOutstandingAmount from a stale // view.read() snapshot — incorrect for multi-destination // sends but retained for ledger replay compatibility. diff --git a/src/libxrpl/nodestore/BatchWriter.cpp b/src/libxrpl/nodestore/BatchWriter.cpp index 28184bf174..cb42b4e92a 100644 --- a/src/libxrpl/nodestore/BatchWriter.cpp +++ b/src/libxrpl/nodestore/BatchWriter.cpp @@ -16,7 +16,7 @@ namespace xrpl::NodeStore { BatchWriter::BatchWriter(Callback& callback, Scheduler& scheduler) : callback_(callback), scheduler_(scheduler) { - writeSet_.reserve(BatchWritePreallocationSize); + writeSet_.reserve(kBATCH_WRITE_PREALLOCATION_SIZE); } BatchWriter::~BatchWriter() @@ -31,7 +31,7 @@ BatchWriter::store(std::shared_ptr const& object) // If the batch has reached its limit, we wait // until the batch writer is finished - while (writeSet_.size() >= BatchWriteLimitSize) + while (writeSet_.size() >= kBATCH_WRITE_PREALLOCATION_SIZE) writeCondition_.wait(sl); writeSet_.push_back(object); @@ -65,7 +65,7 @@ BatchWriter::writeBatch() { std::vector> set; - set.reserve(BatchWritePreallocationSize); + set.reserve(kBATCH_WRITE_PREALLOCATION_SIZE); { std::scoped_lock const sl(writeMutex_); diff --git a/src/libxrpl/nodestore/Database.cpp b/src/libxrpl/nodestore/Database.cpp index 84941d98aa..cda3307317 100644 --- a/src/libxrpl/nodestore/Database.cpp +++ b/src/libxrpl/nodestore/Database.cpp @@ -192,7 +192,7 @@ void Database::importInternal(Backend& dstBackend, Database& srcDB) { Batch batch; - batch.reserve(BatchWritePreallocationSize); + batch.reserve(kBATCH_WRITE_PREALLOCATION_SIZE); auto storeBatch = [&, fname = __func__]() { try { @@ -217,7 +217,7 @@ Database::importInternal(Backend& dstBackend, Database& srcDB) return; batch.emplace_back(std::move(nodeObject)); - if (batch.size() >= BatchWritePreallocationSize) + if (batch.size() >= kBATCH_WRITE_PREALLOCATION_SIZE) storeBatch(); }); diff --git a/src/libxrpl/protocol/AccountID.cpp b/src/libxrpl/protocol/AccountID.cpp index 6639835b41..76982560de 100644 --- a/src/libxrpl/protocol/AccountID.cpp +++ b/src/libxrpl/protocol/AccountID.cpp @@ -105,7 +105,7 @@ parseBase58(std::string const& s) auto const result = decodeBase58Token(s, TokenType::AccountID); if (result.size() != AccountID::kBYTES) return std::nullopt; - return AccountID{result}; + return AccountID::fromRaw(result); } //------------------------------------------------------------------------------ @@ -150,7 +150,7 @@ calcAccountID(PublicKey const& pk) RipeshaHasher rsh; rsh(pk.data(), pk.size()); - return AccountID{static_cast(rsh)}; + return AccountID::fromRaw(static_cast(rsh)); } AccountID const& diff --git a/src/libxrpl/protocol/Indexes.cpp b/src/libxrpl/protocol/Indexes.cpp index b37428a6bf..a74e6cedf4 100644 --- a/src/libxrpl/protocol/Indexes.cpp +++ b/src/libxrpl/protocol/Indexes.cpp @@ -287,7 +287,7 @@ quality(Keylet const& k, std::uint64_t q) noexcept Keylet NextT::operator()(Keylet const& k) const { - XRPL_ASSERT(k.type == ltDIR_NODE, "xrpl::keylet::next_t::operator() : valid input type"); + XRPL_ASSERT(k.type == ltDIR_NODE, "xrpl::keylet::NextT::operator() : valid input type"); return {ltDIR_NODE, getQualityNext(k.key)}; } @@ -385,7 +385,7 @@ nftpageMin(AccountID const& owner) { std::array buf{}; std::memcpy(buf.data(), owner.data(), owner.size()); - return {ltNFTOKEN_PAGE, uint256{buf}}; + return {ltNFTOKEN_PAGE, uint256::fromRaw(buf)}; } Keylet diff --git a/src/libxrpl/protocol/Issue.cpp b/src/libxrpl/protocol/Issue.cpp index 33ad3a0835..8de457a5cf 100644 --- a/src/libxrpl/protocol/Issue.cpp +++ b/src/libxrpl/protocol/Issue.cpp @@ -128,7 +128,7 @@ issueFromJson(json::Value const& v) } auto const issuer = parseBase58(issStr.asString()); - if (!issuer) + if (!issuer || *issuer == noAccount() || *issuer == xrpAccount()) { Throw("issueFromJson issuer must be a valid account"); } diff --git a/src/libxrpl/protocol/NFTokenID.cpp b/src/libxrpl/protocol/NFTokenID.cpp index b7822caf01..cd2c46b66b 100644 --- a/src/libxrpl/protocol/NFTokenID.cpp +++ b/src/libxrpl/protocol/NFTokenID.cpp @@ -159,7 +159,7 @@ insertNFTokenID( { std::vector const result = getNFTokenIDFromDeletedOffer(transactionMeta); - response[jss::nftoken_ids] = json::Value(json::ArrayValue); + response[jss::nftoken_ids] = json::Value(json::ValueType::Array); for (auto const& nftID : result) response[jss::nftoken_ids].append(to_string(nftID)); } diff --git a/src/libxrpl/protocol/PublicKey.cpp b/src/libxrpl/protocol/PublicKey.cpp index ad88e60fe7..c38fb781c9 100644 --- a/src/libxrpl/protocol/PublicKey.cpp +++ b/src/libxrpl/protocol/PublicKey.cpp @@ -297,7 +297,7 @@ calcNodeID(PublicKey const& pk) RipeshaHasher h; h(pk.data(), pk.size()); - return NodeID{static_cast(h)}; + return NodeID::fromRaw(static_cast(h)); } } // namespace xrpl diff --git a/src/libxrpl/protocol/Quality.cpp b/src/libxrpl/protocol/Quality.cpp index d3997cf2db..35a3a3b3a5 100644 --- a/src/libxrpl/protocol/Quality.cpp +++ b/src/libxrpl/protocol/Quality.cpp @@ -62,10 +62,10 @@ ceilInImpl(Amounts const& amount, STAmount const& limit, bool roundUp, Quality c // Clamp out if (result.out > amount.out) result.out = amount.out; - XRPL_ASSERT(result.in == limit, "xrpl::ceil_in_impl : result matches limit"); + XRPL_ASSERT(result.in == limit, "xrpl::ceilInImpl : result matches limit"); return result; } - XRPL_ASSERT(amount.in <= limit, "xrpl::ceil_in_impl : result inside limit"); + XRPL_ASSERT(amount.in <= limit, "xrpl::ceilInImpl : result inside limit"); return amount; } @@ -91,10 +91,10 @@ ceilOutImpl(Amounts const& amount, STAmount const& limit, bool roundUp, Quality // Clamp in if (result.in > amount.in) result.in = amount.in; - XRPL_ASSERT(result.out == limit, "xrpl::ceil_out_impl : result matches limit"); + XRPL_ASSERT(result.out == limit, "xrpl::ceilOutImpl : result matches limit"); return result; } - XRPL_ASSERT(amount.out <= limit, "xrpl::ceil_out_impl : result inside limit"); + XRPL_ASSERT(amount.out <= limit, "xrpl::ceilOutImpl : result inside limit"); return amount; } @@ -114,10 +114,10 @@ Quality composedQuality(Quality const& lhs, Quality const& rhs) { STAmount const lhsRate(lhs.rate()); - XRPL_ASSERT(lhsRate != beast::kZERO, "xrpl::composed_quality : nonzero left input"); + XRPL_ASSERT(lhsRate != beast::kZERO, "xrpl::composedQuality : nonzero left input"); STAmount const rhsRate(rhs.rate()); - XRPL_ASSERT(rhsRate != beast::kZERO, "xrpl::composed_quality : nonzero right input"); + XRPL_ASSERT(rhsRate != beast::kZERO, "xrpl::composedQuality : nonzero right input"); STAmount const rate(mulRound(lhsRate, rhsRate, lhsRate.asset(), true)); @@ -125,7 +125,7 @@ composedQuality(Quality const& lhs, Quality const& rhs) std::uint64_t const storedMantissa(rate.mantissa()); XRPL_ASSERT( - (storedExponent > 0) && (storedExponent <= 255), "xrpl::composed_quality : valid exponent"); + (storedExponent > 0) && (storedExponent <= 255), "xrpl::composedQuality : valid exponent"); return Quality((storedExponent << (64 - 8)) | storedMantissa); } diff --git a/src/libxrpl/protocol/RPCErr.cpp b/src/libxrpl/protocol/RPCErr.cpp index 66aef1470c..ec9a3dee9d 100644 --- a/src/libxrpl/protocol/RPCErr.cpp +++ b/src/libxrpl/protocol/RPCErr.cpp @@ -12,7 +12,7 @@ struct RPCErr; json::Value rpcError(ErrorCodeI iError) { - json::Value jvResult(json::ObjectValue); + json::Value jvResult(json::ValueType::Object); RPC::injectError(iError, jvResult); return jvResult; } diff --git a/src/libxrpl/protocol/SField.cpp b/src/libxrpl/protocol/SField.cpp index 4193bb3e27..094c67d150 100644 --- a/src/libxrpl/protocol/SField.cpp +++ b/src/libxrpl/protocol/SField.cpp @@ -98,7 +98,7 @@ SField::SField(PrivateAccessTagT, int fc, char const* fn) , fieldType(STI_UNKNOWN) , fieldValue(0) , fieldName(fn) - , fieldMeta(SMdNever) + , fieldMeta(kSMD_NEVER) , fieldNum(++num) , signingField(IsSigning::Yes) , jsonName(fieldName.c_str()) diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp index 25857d387e..20d3db45c0 100644 --- a/src/libxrpl/protocol/STAmount.cpp +++ b/src/libxrpl/protocol/STAmount.cpp @@ -642,7 +642,7 @@ canSubtract(STAmount const& a, STAmount const& b) void STAmount::setJson(json::Value& elem) const { - elem = json::ObjectValue; + elem = json::ValueType::Object; if (!native()) { @@ -1057,8 +1057,8 @@ amountFromJson(SField const& name, json::Value const& v) else if (v.isArray()) { value = v.get(json::UInt(0), 0); - currencyOrMPTID = v.get(json::UInt(1), json::NullValue); - issuer = v.get(json::UInt(2), json::NullValue); + currencyOrMPTID = v.get(json::UInt(1), json::ValueType::Null); + issuer = v.get(json::UInt(2), json::ValueType::Null); } else if (v.isString()) { diff --git a/src/libxrpl/protocol/STArray.cpp b/src/libxrpl/protocol/STArray.cpp index 537cb36630..6bfe9fe88e 100644 --- a/src/libxrpl/protocol/STArray.cpp +++ b/src/libxrpl/protocol/STArray.cpp @@ -130,12 +130,12 @@ STArray::getText() const json::Value STArray::getJson(JsonOptions p) const { - json::Value v = json::ArrayValue; + json::Value v = json::ValueType::Array; for (auto const& object : v_) { if (object.getSType() != STI_NOTPRESENT) { - json::Value& inner = v.append(json::ObjectValue); + json::Value& inner = v.append(json::ValueType::Object); inner[object.getFName().getJsonName()] = object.getJson(p); } } diff --git a/src/libxrpl/protocol/STInteger.cpp b/src/libxrpl/protocol/STInteger.cpp index d17dd49fe5..51af029011 100644 --- a/src/libxrpl/protocol/STInteger.cpp +++ b/src/libxrpl/protocol/STInteger.cpp @@ -209,7 +209,7 @@ STUInt64::getJson(JsonOptions) const return str; }; - if (auto const& fName = getFName(); fName.shouldMeta(SField::SMdBaseTen)) + if (auto const& fName = getFName(); fName.shouldMeta(SField::kSMD_BASE_TEN)) { return convertToString(value_, 10); // Convert to base 10 } diff --git a/src/libxrpl/protocol/STIssue.cpp b/src/libxrpl/protocol/STIssue.cpp index c0019c334f..c9b8109e32 100644 --- a/src/libxrpl/protocol/STIssue.cpp +++ b/src/libxrpl/protocol/STIssue.cpp @@ -28,7 +28,7 @@ STIssue::STIssue(SerialIter& sit, SField const& name) : STBase{name} { auto const currencyOrAccount = sit.get160(); - if (isXRP(static_cast(currencyOrAccount))) + if (isXRP(Currency::fromRaw(currencyOrAccount))) { asset_ = xrpIssue(); } @@ -39,7 +39,7 @@ STIssue::STIssue(SerialIter& sit, SField const& name) : STBase{name} // - 160 bits MPT issuer account // - 160 bits black hole account // - 32 bits sequence - AccountID const account = static_cast(sit.get160()); + AccountID const account = AccountID::fromRaw(sit.get160()); // MPT if (noAccount() == account) { diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp index f6481a4d5d..3bbd28e8f6 100644 --- a/src/libxrpl/protocol/STNumber.cpp +++ b/src/libxrpl/protocol/STNumber.cpp @@ -58,7 +58,7 @@ STNumber::associateAsset(Asset const& a) STTakesAsset::associateAsset(a); XRPL_ASSERT_PARTS( - getFName().shouldMeta(SField::SMdNeedsAsset), + getFName().shouldMeta(SField::kSMD_NEEDS_ASSET), "STNumber::associateAsset", "field needs asset"); @@ -76,7 +76,7 @@ STNumber::add(Serializer& s) const auto const exponent = value.exponent(); SField const& field = getFName(); - if (field.shouldMeta(SField::SMdNeedsAsset)) + if (field.shouldMeta(SField::kSMD_NEEDS_ASSET)) { // asset is defined in the STTakesAsset base class if (asset_) diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp index 6bce2f0ab2..ec44250bed 100644 --- a/src/libxrpl/protocol/STObject.cpp +++ b/src/libxrpl/protocol/STObject.cpp @@ -834,7 +834,7 @@ STObject::setFieldObject(SField const& field, STObject const& v) json::Value STObject::getJson(JsonOptions options) const { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); for (auto const& elem : v_) { diff --git a/src/libxrpl/protocol/STParsedJSON.cpp b/src/libxrpl/protocol/STParsedJSON.cpp index f6ebde4e52..c6d1d0e805 100644 --- a/src/libxrpl/protocol/STParsedJSON.cpp +++ b/src/libxrpl/protocol/STParsedJSON.cpp @@ -136,6 +136,15 @@ arrayExpected(std::string const& object, std::string const& field) RpcInvalidParams, "Field '" + makeName(object, field) + "' must be a JSON array."); } +static inline json::Value +arrayTooBig(std::string const& object, std::string const& field) +{ + return RPC::makeError( + RpcInvalidParams, + "Field '" + makeName(object, field) + "' exceeds allowed JSON array size of " + + std::to_string(kMAX_PARSED_JSON_ARRAY_SIZE) + " elements per field."); +} + static inline json::Value stringExpected(std::string const& object, std::string const& field) { @@ -224,7 +233,7 @@ parseUnsigned( template static std::optional -parseUint16( +parseUInt16( SField const& field, std::string const& jsonName, std::string const& fieldName, @@ -285,7 +294,7 @@ parseUint16( template static std::optional -parseUint32( +parseUInt32( SField const& field, std::string const& jsonName, std::string const& fieldName, @@ -434,14 +443,14 @@ parseLeaf( break; case STI_UINT16: - ret = parseUint16(field, jsonName, fieldName, name, value, error); + ret = parseUInt16(field, jsonName, fieldName, name, value, error); if (!ret) return ret; break; case STI_UINT32: - ret = parseUint32(field, jsonName, fieldName, name, value, error); + ret = parseUInt32(field, jsonName, fieldName, name, value, error); if (!ret) return ret; @@ -456,7 +465,7 @@ parseLeaf( std::uint64_t val = 0; - bool const useBase10 = field.shouldMeta(SField::SMdBaseTen); + bool const useBase10 = field.shouldMeta(SField::kSMD_BASE_TEN); // if the field is amount, serialize as base 10 auto [p, ec] = std::from_chars( @@ -681,12 +690,18 @@ parseLeaf( break; case STI_VECTOR256: - if (!value.isArrayOrNull()) + if (not value.isArrayOrNull()) { error = arrayExpected(jsonName, fieldName); return ret; } + if (not value.isNull() and value.size() > kMAX_PARSED_JSON_ARRAY_SIZE) + { + error = arrayTooBig(jsonName, fieldName); + return ret; + } + try { STVector256 tail(field); @@ -708,12 +723,18 @@ parseLeaf( break; case STI_PATHSET: - if (!value.isArrayOrNull()) + if (not value.isArrayOrNull()) { error = arrayExpected(jsonName, fieldName); return ret; } + if (not value.isNull() and value.size() > kMAX_PARSED_JSON_ARRAY_SIZE) + { + error = arrayTooBig(jsonName, fieldName); + return ret; + } + try { STPathSet tail(field); @@ -722,7 +743,7 @@ parseLeaf( { STPath p; - if (!value[i].isArrayOrNull()) + if (not value[i].isArrayOrNull()) { std::stringstream ss; ss << fieldName << "[" << i << "]"; @@ -730,6 +751,14 @@ parseLeaf( return ret; } + if (not value[i].isNull() and value[i].size() > kMAX_PARSED_JSON_ARRAY_SIZE) + { + std::stringstream ss; + ss << fieldName << "[" << i << "]"; + error = arrayTooBig(jsonName, ss.str()); + return ret; + } + for (json::UInt j = 0; value[i].isValidIndex(j); ++j) { std::stringstream ss; @@ -946,8 +975,6 @@ parseLeaf( return ret; } -static int const kMAX_DEPTH = 64; - // Forward declaration since parseObject() and parseArray() call each other. static std::optional parseArray( @@ -965,13 +992,13 @@ parseObject( int depth, json::Value& error) { - if (!json.isObjectOrNull()) + if (not json.isObjectOrNull()) { error = notAnObject(jsonName); return std::nullopt; } - if (depth > kMAX_DEPTH) + if (depth > kMAX_PARSED_JSON_DEPTH) { error = tooDeep(jsonName); return std::nullopt; @@ -984,7 +1011,6 @@ parseObject( for (auto const& fieldName : json.getMemberNames()) { json::Value const& value = json[fieldName]; - auto const& field = SField::getField(fieldName); if (field == kSF_INVALID) @@ -1079,18 +1105,24 @@ parseArray( int depth, json::Value& error) { - if (!json.isArrayOrNull()) + if (not json.isArrayOrNull()) { error = notAnArray(jsonName); return std::nullopt; } - if (depth > kMAX_DEPTH) + if (depth > kMAX_PARSED_JSON_DEPTH) { error = tooDeep(jsonName); return std::nullopt; } + if (not json.isNull() and json.size() > kMAX_PARSED_JSON_ARRAY_SIZE) + { + error = arrayTooBig(jsonName, ""); + return std::nullopt; + } + try { STArray tail(inName); @@ -1108,10 +1140,8 @@ parseArray( } // TODO: There doesn't seem to be a nice way to get just the - // first/only key in an object without copying all keys into - // a vector + // first/only key in an object without copying all keys into a vector std::string const memberName(json[i].getMemberNames()[0]); - ; auto const& nameField(SField::getField(memberName)); if (nameField == kSF_INVALID) diff --git a/src/libxrpl/protocol/STPathSet.cpp b/src/libxrpl/protocol/STPathSet.cpp index 8c4b139792..35d5fd782b 100644 --- a/src/libxrpl/protocol/STPathSet.cpp +++ b/src/libxrpl/protocol/STPathSet.cpp @@ -93,7 +93,7 @@ STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name) XRPL_ASSERT( !(hasCurrency && hasMPT), "xrpl::STPathSet::STPathSet : not has Currency and MPT"); if (hasCurrency) - asset = static_cast(sit.get160()); + asset = Currency::fromRaw(sit.get160()); if (hasMPT) asset = sit.get192(); @@ -167,11 +167,11 @@ STPath::hasSeen(AccountID const& account, PathAsset const& asset, AccountID cons json::Value STPath::getJson(JsonOptions) const { - json::Value ret(json::ArrayValue); + json::Value ret(json::ValueType::Array); for (auto const& it : path_) { - json::Value elem(json::ObjectValue); + json::Value elem(json::ValueType::Object); auto const iType = it.getNodeType(); elem[jss::type] = iType; @@ -201,7 +201,7 @@ STPath::getJson(JsonOptions) const json::Value STPathSet::getJson(JsonOptions options) const { - json::Value ret(json::ArrayValue); + json::Value ret(json::ValueType::Array); for (auto const& it : value_) ret.append(it.getJson(options)); diff --git a/src/libxrpl/protocol/STTakesAsset.cpp b/src/libxrpl/protocol/STTakesAsset.cpp index de7de002b0..1fe01b1e84 100644 --- a/src/libxrpl/protocol/STTakesAsset.cpp +++ b/src/libxrpl/protocol/STTakesAsset.cpp @@ -17,7 +17,7 @@ associateAsset(SLE& sle, Asset const& asset) { STBase& entry = sle.getIndex(i); SField const& field = entry.getFName(); - if (field.shouldMeta(SField::SMdNeedsAsset)) + if (field.shouldMeta(SField::kSMD_NEEDS_ASSET)) { auto const type = entry.getSType(); // If the field is not set or present, skip it. diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp index d335988ac3..06731e9072 100644 --- a/src/libxrpl/protocol/STTx.cpp +++ b/src/libxrpl/protocol/STTx.cpp @@ -315,8 +315,8 @@ STTx::checkBatchSign(Rules const& rules) const json::Value STTx::getJson(JsonOptions options) const { - json::Value ret = STObject::getJson(JsonOptions::KNone); - if (!(options & JsonOptions::KDisableApiPriorV2)) + json::Value ret = STObject::getJson(JsonOptions::Values::None); + if (!(options & JsonOptions::Values::DisableApiPriorV2)) ret[jss::hash] = to_string(getTransactionID()); return ret; } @@ -324,7 +324,7 @@ STTx::getJson(JsonOptions options) const json::Value STTx::getJson(JsonOptions options, bool binary) const { - bool const v1 = !(options & JsonOptions::KDisableApiPriorV2); + bool const v1 = !(options & JsonOptions::Values::DisableApiPriorV2); if (binary) { @@ -333,7 +333,7 @@ STTx::getJson(JsonOptions options, bool binary) const if (v1) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret[jss::tx] = dataBin; ret[jss::hash] = to_string(getTransactionID()); return ret; @@ -342,7 +342,7 @@ STTx::getJson(JsonOptions options, bool binary) const return json::Value{dataBin}; } - json::Value ret = STObject::getJson(JsonOptions::KNone); + json::Value ret = STObject::getJson(JsonOptions::Values::None); if (v1) ret[jss::hash] = to_string(getTransactionID()); diff --git a/src/libxrpl/protocol/STVector256.cpp b/src/libxrpl/protocol/STVector256.cpp index d720067508..7aca309667 100644 --- a/src/libxrpl/protocol/STVector256.cpp +++ b/src/libxrpl/protocol/STVector256.cpp @@ -30,7 +30,7 @@ STVector256::STVector256(SerialIter& sit, SField const& name) : STBase(name) value_.reserve(cnt); for (std::size_t i = 0; i != cnt; ++i) - value_.emplace_back(slice.substr(i * uint256::size(), uint256::size())); + value_.push_back(uint256::fromRaw(slice.substr(i * uint256::size(), uint256::size()))); } STBase* @@ -75,7 +75,7 @@ STVector256::isEquivalent(STBase const& t) const json::Value STVector256::getJson(JsonOptions) const { - json::Value ret(json::ArrayValue); + json::Value ret(json::ValueType::Array); for (auto const& vEntry : value_) ret.append(to_string(vEntry)); diff --git a/src/libxrpl/protocol/STXChainBridge.cpp b/src/libxrpl/protocol/STXChainBridge.cpp index 35f47f891e..97b46852fd 100644 --- a/src/libxrpl/protocol/STXChainBridge.cpp +++ b/src/libxrpl/protocol/STXChainBridge.cpp @@ -64,7 +64,8 @@ STXChainBridge::STXChainBridge(SField const& name, json::Value const& v) : STBas } auto checkExtra = [](json::Value const& v) { - static auto const kBRIDGE_JSON = xrpl::STXChainBridge().getJson(xrpl::JsonOptions::KNone); + static auto const kBRIDGE_JSON = + xrpl::STXChainBridge().getJson(xrpl::JsonOptions::Values::None); for (auto it = v.begin(); it != v.end(); ++it) { std::string const name = it.memberName(); diff --git a/src/libxrpl/protocol/SecretKey.cpp b/src/libxrpl/protocol/SecretKey.cpp index d5fe54867a..f33b1871e1 100644 --- a/src/libxrpl/protocol/SecretKey.cpp +++ b/src/libxrpl/protocol/SecretKey.cpp @@ -56,7 +56,7 @@ SecretKey::toString() const namespace detail { void -copyUint32(std::uint8_t* out, std::uint32_t v) +copyUInt32(std::uint8_t* out, std::uint32_t v) { *out++ = v >> 24; *out++ = (v >> 16) & 0xff; @@ -84,7 +84,7 @@ deriveDeterministicRootKey(Seed const& seed) // more iterations loop a few times. for (std::uint32_t seq = 0; seq != 128; ++seq) { - copyUint32(buf.data() + 16, seq); + copyUInt32(buf.data() + 16, seq); auto const ret = sha512Half(buf); @@ -137,13 +137,13 @@ private: std::array buf{}; std::ranges::copy(generator_, buf.begin()); - copyUint32(buf.data() + 33, seq); + copyUInt32(buf.data() + 33, seq); // The odds that this loop executes more than once are negligible // but we impose a maximum limit just in case. for (std::uint32_t subseq = 0; subseq != 128; ++subseq) { - copyUint32(buf.data() + 37, subseq); + copyUInt32(buf.data() + 37, subseq); auto const ret = sha512HalfS(buf); diff --git a/src/libxrpl/protocol/Seed.cpp b/src/libxrpl/protocol/Seed.cpp index f15d4dcff0..42b2e85498 100644 --- a/src/libxrpl/protocol/Seed.cpp +++ b/src/libxrpl/protocol/Seed.cpp @@ -105,7 +105,7 @@ parseGenericSeed(std::string const& str, bool rfc1751) if (RFC1751::getKeyFromEnglish(key, str) == 1) { Blob const blob(key.rbegin(), key.rend()); - return Seed{uint128{blob}}; + return Seed{uint128::fromRaw(blob)}; } } diff --git a/src/libxrpl/server/Port.cpp b/src/libxrpl/server/Port.cpp index 228b65df43..9a6b6dce35 100644 --- a/src/libxrpl/server/Port.cpp +++ b/src/libxrpl/server/Port.cpp @@ -61,7 +61,7 @@ operator<<(std::ostream& os, Port const& p) if (!p.secure_gateway_nets_v4.empty() || !p.secure_gateway_nets_v6.empty()) { - os << "secureGateway nets:"; + os << "secure_gateway nets:"; for (auto const& net : p.secure_gateway_nets_v4) { os << net.to_string(); @@ -287,7 +287,7 @@ parsePort(ParsedPort& port, Section const& section, std::ostream& log) populate(section, "admin", log, port.admin_nets_v4, port.admin_nets_v6); populate( - section, "secureGateway", log, port.secure_gateway_nets_v4, port.secure_gateway_nets_v6); + section, "secure_gateway", log, port.secure_gateway_nets_v4, port.secure_gateway_nets_v6); set(port.user, "user", section); set(port.password, "password", section); diff --git a/src/libxrpl/server/State.cpp b/src/libxrpl/server/State.cpp index 3d2ed37e98..b9cb7c6ff2 100644 --- a/src/libxrpl/server/State.cpp +++ b/src/libxrpl/server/State.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include // IWYU pragma: keep #include #include diff --git a/src/libxrpl/server/Wallet.cpp b/src/libxrpl/server/Wallet.cpp index ee579c7b9f..3f2be6267a 100644 --- a/src/libxrpl/server/Wallet.cpp +++ b/src/libxrpl/server/Wallet.cpp @@ -17,7 +17,7 @@ #include #include -#include +#include // IWYU pragma: keep #include #include diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp index 795c097118..dafca12c22 100644 --- a/src/libxrpl/shamap/SHAMap.cpp +++ b/src/libxrpl/shamap/SHAMap.cpp @@ -169,7 +169,7 @@ intr_ptr::SharedPtr SHAMap::fetchNodeFromDB(SHAMapHash const& hash) const { XRPL_ASSERT(backed_, "xrpl::SHAMap::fetchNodeFromDB : is backed"); - auto obj = f_.db().fetchNodeObject(hash.asUint256(), ledgerSeq_); + auto obj = f_.db().fetchNodeObject(hash.asUInt256(), ledgerSeq_); return finishFetch(hash, obj); } @@ -185,7 +185,7 @@ SHAMap::finishFetch(SHAMapHash const& hash, std::shared_ptr const& o if (full_) { full_ = false; - f_.missingNodeAcquireBySeq(ledgerSeq_, hash.asUint256()); + f_.missingNodeAcquireBySeq(ledgerSeq_, hash.asUInt256()); } return {}; } @@ -398,7 +398,7 @@ SHAMap::descendAsync( if (!ptr && backed_) { f_.db().asyncFetch( - hash.asUint256(), + hash.asUInt256(), ledgerSeq_, [this, hash, cb{std::move(callback)}](std::shared_ptr const& object) { auto node = finishFetch(hash, object); @@ -947,7 +947,7 @@ SHAMap::writeNode(NodeObjectType t, intr_ptr::SharedPtr node) co Serializer s; node->serializeWithPrefix(s); - f_.db().store(t, std::move(s.modData()), node->getHash().asUint256(), ledgerSeq_); + f_.db().store(t, std::move(s.modData()), node->getHash().asUInt256(), ledgerSeq_); return node; } @@ -1158,7 +1158,7 @@ SHAMap::dump(bool hash) const intr_ptr::SharedPtr SHAMap::cacheLookup(SHAMapHash const& hash) const { - auto ret = f_.getTreeNodeCache()->fetch(hash.asUint256()); + auto ret = f_.getTreeNodeCache()->fetch(hash.asUInt256()); XRPL_ASSERT(!ret || !ret->cowid(), "xrpl::SHAMap::cacheLookup : not found or zero cowid"); return ret; } @@ -1170,7 +1170,7 @@ SHAMap::canonicalize(SHAMapHash const& hash, intr_ptr::SharedPtr XRPL_ASSERT(node->cowid() == 0, "xrpl::SHAMap::canonicalize : valid node input"); XRPL_ASSERT(node->getHash() == hash, "xrpl::SHAMap::canonicalize : node hash do match"); - f_.getTreeNodeCache()->canonicalizeReplaceClient(hash.asUint256(), node); + f_.getTreeNodeCache()->canonicalizeReplaceClient(hash.asUInt256(), node); } void diff --git a/src/libxrpl/shamap/SHAMapInnerNode.cpp b/src/libxrpl/shamap/SHAMapInnerNode.cpp index a0adc10a61..ef38819599 100644 --- a/src/libxrpl/shamap/SHAMapInnerNode.cpp +++ b/src/libxrpl/shamap/SHAMapInnerNode.cpp @@ -133,7 +133,7 @@ SHAMapInnerNode::makeFullInner(Slice data, SHAMapHash const& hash, bool hashVali for (int i = 0; i < kBRANCH_FACTOR; ++i) { - hashes[i].asUint256() = si.getBitString<256>(); + hashes[i].asUInt256() = si.getBitString<256>(); if (hashes[i].isNonZero()) ret->isBranch_ |= (1 << i); @@ -177,7 +177,7 @@ SHAMapInnerNode::makeCompressedInner(Slice data) if (pos >= kBRANCH_FACTOR) Throw("invalid CI node"); - hashes[pos].asUint256() = hash; + hashes[pos].asUInt256() = hash; if (hashes[pos].isNonZero()) ret->isBranch_ |= (1 << pos); @@ -228,14 +228,14 @@ SHAMapInnerNode::serializeForWire(Serializer& s) const // compressed node auto hashes = hashesAndChildren_.getHashes(); iterNonEmptyChildIndexes([&](auto branchNum, auto indexNum) { - s.addBitString(hashes[indexNum].asUint256()); + s.addBitString(hashes[indexNum].asUInt256()); s.add8(branchNum); }); s.add8(kWIRE_TYPE_COMPRESSED_INNER); } else { - iterChildren([&](SHAMapHash const& hh) { s.addBitString(hh.asUint256()); }); + iterChildren([&](SHAMapHash const& hh) { s.addBitString(hh.asUInt256()); }); s.add8(kWIRE_TYPE_INNER); } } @@ -246,7 +246,7 @@ SHAMapInnerNode::serializeWithPrefix(Serializer& s) const XRPL_ASSERT(!isEmpty(), "xrpl::SHAMapInnerNode::serializeWithPrefix : is non-empty"); s.add32(HashPrefix::InnerNode); - iterChildren([&](SHAMapHash const& hh) { s.addBitString(hh.asUint256()); }); + iterChildren([&](SHAMapHash const& hh) { s.addBitString(hh.asUInt256()); }); } std::string diff --git a/src/libxrpl/shamap/SHAMapLeafNode.cpp b/src/libxrpl/shamap/SHAMapLeafNode.cpp index ce41a64e56..84c4498698 100644 --- a/src/libxrpl/shamap/SHAMapLeafNode.cpp +++ b/src/libxrpl/shamap/SHAMapLeafNode.cpp @@ -19,7 +19,7 @@ SHAMapLeafNode::SHAMapLeafNode(boost::intrusive_ptr item, std: : SHAMapTreeNode(cowid), item_(std::move(item)) { XRPL_ASSERT( - item_->size() >= 12, + item_->size() >= kMIN_SHA_MAP_ITEM_BYTES, "xrpl::SHAMapLeafNode::SHAMapLeafNode(boost::intrusive_ptr<" "SHAMapItem const>, std::uint32_t) : minimum input size"); } @@ -31,7 +31,7 @@ SHAMapLeafNode::SHAMapLeafNode( : SHAMapTreeNode(cowid, hash), item_(std::move(item)) { XRPL_ASSERT( - item_->size() >= 12, + item_->size() >= kMIN_SHA_MAP_ITEM_BYTES, "xrpl::SHAMapLeafNode::SHAMapLeafNode(boost::intrusive_ptr<" "SHAMapItem const>, std::uint32_t, SHAMapHash const&) : minimum input " "size"); diff --git a/src/libxrpl/shamap/SHAMapNodeID.cpp b/src/libxrpl/shamap/SHAMapNodeID.cpp index f7caf8ae02..4eb6742aac 100644 --- a/src/libxrpl/shamap/SHAMapNodeID.cpp +++ b/src/libxrpl/shamap/SHAMapNodeID.cpp @@ -16,25 +16,23 @@ namespace xrpl { static uint256 const& depthMask(unsigned int depth) { - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { MaskSize = 65 }; + static constexpr auto kMASK_SIZE = 65; struct MasksT { - uint256 entry[MaskSize]; + uint256 entry[kMASK_SIZE]; MasksT() { uint256 selector; - for (int i = 0; i < MaskSize - 1; i += 2) + for (int i = 0; i < kMASK_SIZE - 1; i += 2) { entry[i] = selector; *(selector.begin() + (i / 2)) = 0xF0; entry[i + 1] = selector; *(selector.begin() + (i / 2)) = 0xFF; } - entry[MaskSize - 1] = selector; + entry[kMASK_SIZE - 1] = selector; } }; diff --git a/src/libxrpl/shamap/SHAMapSync.cpp b/src/libxrpl/shamap/SHAMapSync.cpp index 348928f863..935f5b4e4a 100644 --- a/src/libxrpl/shamap/SHAMapSync.cpp +++ b/src/libxrpl/shamap/SHAMapSync.cpp @@ -196,7 +196,7 @@ SHAMap::gmnProcessNodes(MissingNodes& mn, MissingNodes::StackEntry& se) // we already know this child node is missing fullBelow = false; } - else if (!backed_ || !f_.getFullBelowCache()->touchIfExists(childHash.asUint256())) + else if (!backed_ || !f_.getFullBelowCache()->touchIfExists(childHash.asUInt256())) { bool pending = false; auto d = descendAsync( @@ -223,7 +223,7 @@ SHAMap::gmnProcessNodes(MissingNodes& mn, MissingNodes::StackEntry& se) fullBelow = false; // for now, not known full below mn.missingHashes.insert(childHash); - mn.missingNodes.emplace_back(nodeID.getChildNodeID(branch), childHash.asUint256()); + mn.missingNodes.emplace_back(nodeID.getChildNodeID(branch), childHash.asUInt256()); if (--mn.max <= 0) return; @@ -250,7 +250,7 @@ SHAMap::gmnProcessNodes(MissingNodes& mn, MissingNodes::StackEntry& se) node->setFullBelowGen(mn.generation); if (backed_) { - f_.getFullBelowCache()->insert(node->getHash().asUint256()); + f_.getFullBelowCache()->insert(node->getHash().asUInt256()); } } @@ -292,7 +292,7 @@ SHAMap::gmnProcessDeferredReads(MissingNodes& mn) } else if ((mn.max > 0) && (mn.missingHashes.insert(nodeHash).second)) { - mn.missingNodes.emplace_back(parentID.getChildNodeID(branch), nodeHash.asUint256()); + mn.missingNodes.emplace_back(parentID.getChildNodeID(branch), nodeHash.asUInt256()); --mn.max; } } @@ -572,7 +572,7 @@ SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncF } auto childHash = inner->getChildHash(branch); - if (f_.getFullBelowCache()->touchIfExists(childHash.asUint256())) + if (f_.getFullBelowCache()->touchIfExists(childHash.asUInt256())) { return SHAMapAddNode::duplicate(); } diff --git a/src/libxrpl/shamap/SHAMapTreeNode.cpp b/src/libxrpl/shamap/SHAMapTreeNode.cpp index ac405f3286..66eced2192 100644 --- a/src/libxrpl/shamap/SHAMapTreeNode.cpp +++ b/src/libxrpl/shamap/SHAMapTreeNode.cpp @@ -28,6 +28,13 @@ namespace xrpl { intr_ptr::SharedPtr SHAMapTreeNode::makeTransaction(Slice data, SHAMapHash const& hash, bool hashValid) { + if (data.size() < kMIN_SHA_MAP_ITEM_BYTES) + { + Throw( + "Short TXN node: " + std::to_string(data.size()) + " bytes (minimum " + + std::to_string(kMIN_SHA_MAP_ITEM_BYTES) + " required)"); + } + auto item = makeShamapitem(sha512Half(HashPrefix::TransactionId, data), data); if (hashValid) @@ -44,14 +51,30 @@ SHAMapTreeNode::makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool uint256 tag; if (s.size() < tag.kBYTES) - Throw("Short TXN+MD node"); + { + Throw( + "Short TXN+MD node: " + std::to_string(s.size()) + " bytes (minimum " + + std::to_string(tag.kBYTES) + " required for tag)"); + } // FIXME: improve this interface so that the above check isn't needed if (!s.getBitString(tag, s.size() - tag.kBYTES)) - Throw("Short TXN+MD node (" + std::to_string(s.size()) + ")"); + { + Throw( + "Short TXN+MD node: failed to read tag at offset " + + std::to_string(s.size() - tag.kBYTES)); + } s.chop(tag.kBYTES); + if (s.size() < kMIN_SHA_MAP_ITEM_BYTES) + { + Throw( + "Short TXN+MD node: " + std::to_string(s.size()) + + " bytes after tag removal (minimum " + std::to_string(kMIN_SHA_MAP_ITEM_BYTES) + + " required)"); + } + auto item = makeShamapitem(tag, s.slice()); if (hashValid) @@ -68,17 +91,31 @@ SHAMapTreeNode::makeAccountState(Slice data, SHAMapHash const& hash, bool hashVa uint256 tag; if (s.size() < tag.kBYTES) - Throw("short AS node"); + { + Throw( + "Short AS node: " + std::to_string(s.size()) + " bytes (minimum " + + std::to_string(tag.kBYTES) + " required for tag)"); + } // FIXME: improve this interface so that the above check isn't needed if (!s.getBitString(tag, s.size() - tag.kBYTES)) - Throw("Short AS node (" + std::to_string(s.size()) + ")"); + { + Throw( + "Short AS node: failed to read tag at offset " + std::to_string(s.size() - tag.kBYTES)); + } s.chop(tag.kBYTES); if (tag.isZero()) Throw("Invalid AS node"); + if (s.size() < kMIN_SHA_MAP_ITEM_BYTES) + { + Throw( + "Short AS node: " + std::to_string(s.size()) + " bytes after tag removal (minimum " + + std::to_string(kMIN_SHA_MAP_ITEM_BYTES) + " required)"); + } + auto item = makeShamapitem(tag, s.slice()); if (hashValid) diff --git a/src/libxrpl/tx/ApplyContext.cpp b/src/libxrpl/tx/ApplyContext.cpp index 94d35cf5d9..88e37baf00 100644 --- a/src/libxrpl/tx/ApplyContext.cpp +++ b/src/libxrpl/tx/ApplyContext.cpp @@ -124,7 +124,7 @@ ApplyContext::checkInvariantsHelper( if (!std::all_of(finalizers.cbegin(), finalizers.cend(), [](auto const& b) { return b; })) { JLOG(journal.fatal()) << "Transaction has failed one or more global invariants: " - << to_string(tx.getJson(JsonOptions::KNone)); + << to_string(tx.getJson(JsonOptions::Values::None)); return failInvariantCheck(result); } @@ -133,7 +133,7 @@ ApplyContext::checkInvariantsHelper( { JLOG(journal.fatal()) << "Transaction caused an exception in a global invariant" << ", ex: " << ex.what() - << ", tx: " << to_string(tx.getJson(JsonOptions::KNone)); + << ", tx: " << to_string(tx.getJson(JsonOptions::Values::None)); return failInvariantCheck(result); } diff --git a/src/libxrpl/tx/Transactor.cpp b/src/libxrpl/tx/Transactor.cpp index 79dec33c66..6af781145c 100644 --- a/src/libxrpl/tx/Transactor.cpp +++ b/src/libxrpl/tx/Transactor.cpp @@ -1010,7 +1010,14 @@ removeExpiredCredentials(ApplyView& view, std::vector const& creds, bea for (auto const& index : creds) { if (auto const sle = view.peek(keylet::credential(index))) - credentials::deleteSLE(view, sle, viewJ); + { + if (auto const ter = credentials::deleteSLE(view, sle, viewJ); !isTesSuccess(ter)) + { + JLOG(viewJ.error()) + << "removeExpiredCredentials: failed to delete expired credential. Err: " + << transToken(ter); + } + } } } @@ -1135,7 +1142,7 @@ Transactor::checkTransactionInvariants(TER result, XRPAmount fee) { JLOG(ctx_.journal.fatal()) << // "Transaction has failed one or more transaction invariants, tx: " << // - to_string(ctx_.tx.getJson(JsonOptions::KNone)); + to_string(ctx_.tx.getJson(JsonOptions::Values::None)); return tecINVARIANT_FAILED; } } @@ -1145,7 +1152,7 @@ Transactor::checkTransactionInvariants(TER result, XRPAmount fee) "Exception while checking transaction invariants: " << // ex.what() << // ", tx: " << // - to_string(ctx_.tx.getJson(JsonOptions::KNone)); + to_string(ctx_.tx.getJson(JsonOptions::Values::None)); return tecINVARIANT_FAILED; } @@ -1198,8 +1205,8 @@ Transactor::operator()() { // LCOV_EXCL_START JLOG(j_.fatal()) << "Transaction serdes mismatch"; - JLOG(j_.fatal()) << ctx_.tx.getJson(JsonOptions::KNone); - JLOG(j_.fatal()) << s2.getJson(JsonOptions::KNone); + JLOG(j_.fatal()) << ctx_.tx.getJson(JsonOptions::Values::None); + JLOG(j_.fatal()) << s2.getJson(JsonOptions::Values::None); UNREACHABLE("xrpl::Transactor::operator() : transaction serdes mismatch"); // LCOV_EXCL_STOP } diff --git a/src/libxrpl/tx/applySteps.cpp b/src/libxrpl/tx/applySteps.cpp index 7833341808..99b3425275 100644 --- a/src/libxrpl/tx/applySteps.cpp +++ b/src/libxrpl/tx/applySteps.cpp @@ -113,29 +113,29 @@ withTxnType(Rules const& rules, TxType txnType, F&& f) // building with Visual Studio 2017 we can consider replacing the four // templates with a single template function that uses if constexpr. // -// For Transactor::Normal +// For ConsequencesFactoryType::Normal // template - requires(T::kCONSEQUENCES_FACTORY == Transactor::Normal) + requires(T::kCONSEQUENCES_FACTORY == Transactor::ConsequencesFactoryType::Normal) TxConsequences consequencesHelper(PreflightContext const& ctx) { return TxConsequences(ctx.tx); }; -// For Transactor::Blocker +// For ConsequencesFactoryType::Blocker template - requires(T::kCONSEQUENCES_FACTORY == Transactor::Blocker) + requires(T::kCONSEQUENCES_FACTORY == Transactor::ConsequencesFactoryType::Blocker) TxConsequences consequencesHelper(PreflightContext const& ctx) { return TxConsequences(ctx.tx, TxConsequences::Category::Blocker); }; -// For Transactor::Custom +// For ConsequencesFactoryType::Custom template - requires(T::kCONSEQUENCES_FACTORY == Transactor::Custom) + requires(T::kCONSEQUENCES_FACTORY == Transactor::ConsequencesFactoryType::Custom) TxConsequences consequencesHelper(PreflightContext const& ctx) { @@ -158,7 +158,7 @@ invokePreflight(PreflightContext const& ctx) // Should never happen // LCOV_EXCL_START JLOG(ctx.j.fatal()) << "Unknown transaction type in preflight: " << e.txnType; - UNREACHABLE("xrpl::invoke_preflight : unknown transaction type"); + UNREACHABLE("xrpl::invokePreflight : unknown transaction type"); return {temUNKNOWN, TxConsequences{temUNKNOWN}}; // LCOV_EXCL_STOP } @@ -217,7 +217,7 @@ invokePreclaim(PreclaimContext const& ctx) // Should never happen // LCOV_EXCL_START JLOG(ctx.j.fatal()) << "Unknown transaction type in preclaim: " << e.txnType; - UNREACHABLE("xrpl::invoke_preclaim : unknown transaction type"); + UNREACHABLE("xrpl::invokePreclaim : unknown transaction type"); return temUNKNOWN; // LCOV_EXCL_STOP } @@ -307,7 +307,7 @@ invokeApply(ApplyContext& ctx) // Should never happen // LCOV_EXCL_START JLOG(ctx.journal.fatal()) << "Unknown transaction type in apply: " << e.txnType; - UNREACHABLE("xrpl::invoke_apply : unknown transaction type"); + UNREACHABLE("xrpl::invokeApply : unknown transaction type"); return {temUNKNOWN, false}; // LCOV_EXCL_STOP } diff --git a/src/libxrpl/tx/invariants/InvariantCheck.cpp b/src/libxrpl/tx/invariants/InvariantCheck.cpp index 4f25a91bdf..a945b0f117 100644 --- a/src/libxrpl/tx/invariants/InvariantCheck.cpp +++ b/src/libxrpl/tx/invariants/InvariantCheck.cpp @@ -341,7 +341,7 @@ NoZeroEscrow::visitEntry( bad_ |= true; }; - bool const overwriteFixEnabled = isFeatureEnabled(fixSecurity3_1_3, true); + bool const overwriteFixEnabled = isFeatureEnabled(fixCleanup3_1_3, true); if (after && after->getType() == ltMPTOKEN_ISSUANCE) { @@ -467,7 +467,7 @@ AccountRootsDeletedClean::finalize( // transaction processing results, however unlikely, only fail if the // feature is enabled. Enabled, or not, though, a fatal-level message will // be logged - [[maybe_unused]] bool const enforce = view.rules().enabled(featureInvariantsV1_1) || + [[maybe_unused]] bool const enforce = view.rules().enabled(fixCleanup3_2_0) || view.rules().enabled(featureSingleAssetVault) || view.rules().enabled(featureLendingProtocol); @@ -628,7 +628,7 @@ NoXRPTrustLines::visitEntry( std::shared_ptr const&, std::shared_ptr const& after) { - bool const overwriteFixEnabled = isFeatureEnabled(fixSecurity3_1_3, true); + bool const overwriteFixEnabled = isFeatureEnabled(fixCleanup3_1_3, true); if (after && after->getType() == ltRIPPLE_STATE) { @@ -673,14 +673,13 @@ NoDeepFreezeTrustLinesWithoutFreeze::visitEntry( { if (after && after->getType() == ltRIPPLE_STATE) { - bool const overwriteFixEnabled = isFeatureEnabled(fixSecurity3_1_3, true); + bool const overwriteFixEnabled = isFeatureEnabled(fixCleanup3_1_3, true); - std::uint32_t const uFlags = after->getFieldU32(sfFlags); - bool const lowFreeze = (uFlags & lsfLowFreeze) != 0u; - bool const lowDeepFreeze = (uFlags & lsfLowDeepFreeze) != 0u; + bool const lowFreeze = after->isFlag(lsfLowFreeze); + bool const lowDeepFreeze = after->isFlag(lsfLowDeepFreeze); - bool const highFreeze = (uFlags & lsfHighFreeze) != 0u; - bool const highDeepFreeze = (uFlags & lsfHighDeepFreeze) != 0u; + bool const highFreeze = after->isFlag(lsfHighFreeze); + bool const highDeepFreeze = after->isFlag(lsfHighDeepFreeze); bool const bad = (lowDeepFreeze && !lowFreeze) || (highDeepFreeze && !highFreeze); if (overwriteFixEnabled) diff --git a/src/libxrpl/tx/invariants/LoanBrokerInvariant.cpp b/src/libxrpl/tx/invariants/LoanBrokerInvariant.cpp index b98d769393..56995ef94c 100644 --- a/src/libxrpl/tx/invariants/LoanBrokerInvariant.cpp +++ b/src/libxrpl/tx/invariants/LoanBrokerInvariant.cpp @@ -197,7 +197,7 @@ ValidLoanBroker::finalize( return false; } - if (view.rules().enabled(fixSecurity3_1_3)) + if (view.rules().enabled(fixCleanup3_1_3)) { // Don't check the balance when LoanBroker is deleted, // sfCoverAvailable is not zeroed diff --git a/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp b/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp index 6466812743..b480b90a31 100644 --- a/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp +++ b/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp @@ -41,14 +41,14 @@ ValidPermissionedDEX::visitEntry( regularOffers_ = true; } - // pre-fixSecurity3_1_3: hybrid offer missing domain, missing + // pre-fixCleanup3_1_3: hybrid offer missing domain, missing // sfAdditionalBooks, or sfAdditionalBooks has more than one entry if (after->isFlag(lsfHybrid) && (!after->isFieldPresent(sfDomainID) || !after->isFieldPresent(sfAdditionalBooks) || after->getFieldArray(sfAdditionalBooks).size() > 1)) badHybridsOld_ = true; - // post-fixSecurity3_1_3: same as above but also catches size == 0 + // post-fixCleanup3_1_3: same as above but also catches size == 0 if (after->isFlag(lsfHybrid) && (!after->isFieldPresent(sfDomainID) || !after->isFieldPresent(sfAdditionalBooks) || after->getFieldArray(sfAdditionalBooks).size() != 1)) @@ -70,7 +70,7 @@ ValidPermissionedDEX::finalize( // For each offercreate transaction, check if // permissioned offers are valid - bool const isMalformed = view.rules().enabled(fixSecurity3_1_3) ? badHybrids_ : badHybridsOld_; + bool const isMalformed = view.rules().enabled(fixCleanup3_1_3) ? badHybrids_ : badHybridsOld_; if (txType == ttOFFER_CREATE && isMalformed) { JLOG(j.fatal()) << "Invariant failed: hybrid offer is malformed"; diff --git a/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp b/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp index 784a2503ca..60cc897f99 100644 --- a/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp +++ b/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp @@ -102,7 +102,7 @@ ValidPermissionedDomain::finalize( return true; }; - if (view.rules().enabled(fixPermissionedDomainInvariant)) + if (view.rules().enabled(fixCleanup3_1_3)) { // No permissioned domains should be affected if the transaction failed if (!isTesSuccess(result)) diff --git a/src/libxrpl/tx/paths/BookStep.cpp b/src/libxrpl/tx/paths/BookStep.cpp index 113155e530..4fde4fe58e 100644 --- a/src/libxrpl/tx/paths/BookStep.cpp +++ b/src/libxrpl/tx/paths/BookStep.cpp @@ -1357,8 +1357,7 @@ BookStep::check(StrandContext const& ctx) const auto sle = view.read(keylet::line(*prev, cur, issue.currency)); if (!sle) return terNO_LINE; - if (((*sle)[sfFlags] & ((cur > *prev) ? lsfHighNoRipple : lsfLowNoRipple)) != - 0u) + if (sle->isFlag((cur > *prev) ? lsfHighNoRipple : lsfLowNoRipple)) return terNO_RIPPLE; return std::nullopt; }, diff --git a/src/libxrpl/tx/paths/DirectStep.cpp b/src/libxrpl/tx/paths/DirectStep.cpp index 7373f8a341..0564e22947 100644 --- a/src/libxrpl/tx/paths/DirectStep.cpp +++ b/src/libxrpl/tx/paths/DirectStep.cpp @@ -429,8 +429,8 @@ DirectIPaymentStep::check(StrandContext const& ctx, std::shared_ptr c auto const authField = (src_ > dst_) ? lsfHighAuth : lsfLowAuth; - if ((((*sleSrc)[sfFlags] & lsfRequireAuth) != 0u) && - (((*sleLine)[sfFlags] & authField) == 0u) && (*sleLine)[sfBalance] == beast::kZERO) + if (sleSrc->isFlag(lsfRequireAuth) && !sleLine->isFlag(authField) && + (*sleLine)[sfBalance] == beast::kZERO) { JLOG(j_.debug()) << "DirectStepI: can't receive IOUs from issuer without auth." << " src: " << src_; @@ -441,9 +441,7 @@ DirectIPaymentStep::check(StrandContext const& ctx, std::shared_ptr c { if (ctx.prevStep->bookStepBook()) { - auto const noRippleSrcToDst = - ((*sleLine)[sfFlags] & ((src_ > dst_) ? lsfHighNoRipple : lsfLowNoRipple)); - if (noRippleSrcToDst != 0u) + if (sleLine->isFlag((src_ > dst_) ? lsfHighNoRipple : lsfLowNoRipple)) return terNO_RIPPLE; } } diff --git a/src/libxrpl/tx/paths/PaySteps.cpp b/src/libxrpl/tx/paths/PaySteps.cpp index 68bd501d87..2d6e89ce2c 100644 --- a/src/libxrpl/tx/paths/PaySteps.cpp +++ b/src/libxrpl/tx/paths/PaySteps.cpp @@ -662,7 +662,7 @@ toStrands( { lastFailTer = ter; JLOG(j.trace()) << "failed to add path: ter: " << ter - << "path: " << p.getJson(JsonOptions::KNone); + << "path: " << p.getJson(JsonOptions::Values::None); if (isTemMalformed(ter)) return {ter, std::vector{}}; } diff --git a/src/libxrpl/tx/transactors/account/AccountDelete.cpp b/src/libxrpl/tx/transactors/account/AccountDelete.cpp index f9d1913dff..7b72817aaa 100644 --- a/src/libxrpl/tx/transactors/account/AccountDelete.cpp +++ b/src/libxrpl/tx/transactors/account/AccountDelete.cpp @@ -231,7 +231,7 @@ AccountDelete::preclaim(PreclaimContext const& ctx) if (!sleDst) return tecNO_DST; - if ((((*sleDst)[sfFlags] & lsfRequireDestTag) != 0u) && !ctx.tx[~sfDestinationTag]) + if (sleDst->isFlag(lsfRequireDestTag) && !ctx.tx[~sfDestinationTag]) return tecDST_TAG_NEEDED; // If credentials are provided - check them anyway @@ -243,7 +243,7 @@ AccountDelete::preclaim(PreclaimContext const& ctx) if (!ctx.tx.isFieldPresent(sfCredentialIDs)) { // Check whether the destination account requires deposit authorization. - if ((sleDst->getFlags() & lsfDepositAuth) != 0u) + if (sleDst->isFlag(lsfDepositAuth)) { if (!ctx.view.exists(keylet::depositPreauth(dst, account))) return tecNO_PERMISSION; @@ -422,6 +422,7 @@ AccountDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -432,6 +433,7 @@ AccountDelete::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/account/AccountSet.cpp b/src/libxrpl/tx/transactors/account/AccountSet.cpp index da24640bfa..c3cb8a72b8 100644 --- a/src/libxrpl/tx/transactors/account/AccountSet.cpp +++ b/src/libxrpl/tx/transactors/account/AccountSet.cpp @@ -69,8 +69,6 @@ AccountSet::preflight(PreflightContext const& ctx) auto& tx = ctx.tx; auto& j = ctx.j; - std::uint32_t const uTxFlags = tx.getFlags(); - std::uint32_t const uSetFlag = tx.getFieldU32(sfSetFlag); std::uint32_t const uClearFlag = tx.getFieldU32(sfClearFlag); @@ -83,9 +81,8 @@ AccountSet::preflight(PreflightContext const& ctx) // // RequireAuth // - bool const bSetRequireAuth = ((uTxFlags & tfRequireAuth) != 0u) || (uSetFlag == asfRequireAuth); - bool const bClearRequireAuth = - ((uTxFlags & tfOptionalAuth) != 0u) || (uClearFlag == asfRequireAuth); + bool const bSetRequireAuth = tx.isFlag(tfRequireAuth) || (uSetFlag == asfRequireAuth); + bool const bClearRequireAuth = tx.isFlag(tfOptionalAuth) || (uClearFlag == asfRequireAuth); if (bSetRequireAuth && bClearRequireAuth) { @@ -96,10 +93,8 @@ AccountSet::preflight(PreflightContext const& ctx) // // RequireDestTag // - bool const bSetRequireDest = - ((uTxFlags & tfRequireDestTag) != 0u) || (uSetFlag == asfRequireDest); - bool const bClearRequireDest = - ((uTxFlags & tfOptionalDestTag) != 0u) || (uClearFlag == asfRequireDest); + bool const bSetRequireDest = tx.isFlag(tfRequireDestTag) || (uSetFlag == asfRequireDest); + bool const bClearRequireDest = tx.isFlag(tfOptionalDestTag) || (uClearFlag == asfRequireDest); if (bSetRequireDest && bClearRequireDest) { @@ -110,9 +105,8 @@ AccountSet::preflight(PreflightContext const& ctx) // // DisallowXRP // - bool const bSetDisallowXRP = ((uTxFlags & tfDisallowXRP) != 0u) || (uSetFlag == asfDisallowXRP); - bool const bClearDisallowXRP = - ((uTxFlags & tfAllowXRP) != 0u) || (uClearFlag == asfDisallowXRP); + bool const bSetDisallowXRP = tx.isFlag(tfDisallowXRP) || (uSetFlag == asfDisallowXRP); + bool const bClearDisallowXRP = tx.isFlag(tfAllowXRP) || (uClearFlag == asfDisallowXRP); if (bSetDisallowXRP && bClearDisallowXRP) { @@ -195,12 +189,11 @@ AccountSet::checkPermission(ReadView const& view, STTx const& tx) auto const uSetFlag = tx.getFieldU32(sfSetFlag); auto const uClearFlag = tx.getFieldU32(sfClearFlag); - auto const uTxFlags = tx.getFlags(); // We don't support any flag based granular permission under // AccountSet transaction. If any delegated account is trying to // update the flag on behalf of another account, it is not // authorized. - if (uSetFlag != 0 || uClearFlag != 0 || ((uTxFlags & tfUniversalMask) != 0u)) + if (uSetFlag != 0 || uClearFlag != 0 || ((tx.getFlags() & tfUniversalMask) != 0u)) return terNO_DELEGATE_PERMISSION; if (tx.isFieldPresent(sfEmailHash) && !granularPermissions.contains(AccountEmailHashSet)) @@ -229,23 +222,19 @@ AccountSet::preclaim(PreclaimContext const& ctx) { auto const id = ctx.tx[sfAccount]; - std::uint32_t const uTxFlags = ctx.tx.getFlags(); - auto const sle = ctx.view.read(keylet::account(id)); if (!sle) return terNO_ACCOUNT; - std::uint32_t const uFlagsIn = sle->getFieldU32(sfFlags); - std::uint32_t const uSetFlag = ctx.tx.getFieldU32(sfSetFlag); // legacy AccountSet flags - bool const bSetRequireAuth = ((uTxFlags & tfRequireAuth) != 0u) || (uSetFlag == asfRequireAuth); + bool const bSetRequireAuth = ctx.tx.isFlag(tfRequireAuth) || (uSetFlag == asfRequireAuth); // // RequireAuth // - if (bSetRequireAuth && ((uFlagsIn & lsfRequireAuth) == 0u)) + if (bSetRequireAuth && !sle->isFlag(lsfRequireAuth)) { if (!dirIsEmpty(ctx.view, keylet::ownerDir(id))) { @@ -261,7 +250,7 @@ AccountSet::preclaim(PreclaimContext const& ctx) { if (uSetFlag == asfAllowTrustLineClawback) { - if ((uFlagsIn & lsfNoFreeze) != 0u) + if (sle->isFlag(lsfNoFreeze)) { JLOG(ctx.j.trace()) << "Can't set Clawback if NoFreeze is set"; return tecNO_PERMISSION; @@ -276,7 +265,7 @@ AccountSet::preclaim(PreclaimContext const& ctx) else if (uSetFlag == asfNoFreeze) { // Cannot set NoFreeze if clawback is enabled - if ((uFlagsIn & lsfAllowTrustLineClawback) != 0u) + if (sle->isFlag(lsfAllowTrustLineClawback)) { JLOG(ctx.j.trace()) << "Can't set NoFreeze if clawback is enabled"; return tecNO_PERMISSION; @@ -302,16 +291,12 @@ AccountSet::doApply() std::uint32_t const uClearFlag{tx.getFieldU32(sfClearFlag)}; // legacy AccountSet flags - std::uint32_t const uTxFlags{tx.getFlags()}; - bool const bSetRequireDest{ - ((uTxFlags & tfRequireDestTag) != 0u) || (uSetFlag == asfRequireDest)}; - bool const bClearRequireDest{ - ((uTxFlags & tfOptionalDestTag) != 0u) || (uClearFlag == asfRequireDest)}; - bool const bSetRequireAuth{((uTxFlags & tfRequireAuth) != 0u) || (uSetFlag == asfRequireAuth)}; - bool const bClearRequireAuth{ - ((uTxFlags & tfOptionalAuth) != 0u) || (uClearFlag == asfRequireAuth)}; - bool const bSetDisallowXRP{((uTxFlags & tfDisallowXRP) != 0u) || (uSetFlag == asfDisallowXRP)}; - bool const bClearDisallowXRP{((uTxFlags & tfAllowXRP) != 0u) || (uClearFlag == asfDisallowXRP)}; + bool const bSetRequireDest{tx.isFlag(tfRequireDestTag) || (uSetFlag == asfRequireDest)}; + bool const bClearRequireDest{tx.isFlag(tfOptionalDestTag) || (uClearFlag == asfRequireDest)}; + bool const bSetRequireAuth{tx.isFlag(tfRequireAuth) || (uSetFlag == asfRequireAuth)}; + bool const bClearRequireAuth{tx.isFlag(tfOptionalAuth) || (uClearFlag == asfRequireAuth)}; + bool const bSetDisallowXRP{tx.isFlag(tfDisallowXRP) || (uSetFlag == asfDisallowXRP)}; + bool const bClearDisallowXRP{tx.isFlag(tfAllowXRP) || (uClearFlag == asfDisallowXRP)}; bool const sigWithMaster{[&tx, &acct = account_]() { auto const spk = tx.getSigningPubKey(); @@ -329,13 +314,13 @@ AccountSet::doApply() // // RequireAuth // - if (bSetRequireAuth && ((uFlagsIn & lsfRequireAuth) == 0u)) + if (bSetRequireAuth && !sle->isFlag(lsfRequireAuth)) { JLOG(j_.trace()) << "Set RequireAuth."; uFlagsOut |= lsfRequireAuth; } - if (bClearRequireAuth && ((uFlagsIn & lsfRequireAuth) != 0u)) + if (bClearRequireAuth && sle->isFlag(lsfRequireAuth)) { JLOG(j_.trace()) << "Clear RequireAuth."; uFlagsOut &= ~lsfRequireAuth; @@ -344,13 +329,13 @@ AccountSet::doApply() // // RequireDestTag // - if (bSetRequireDest && ((uFlagsIn & lsfRequireDestTag) == 0u)) + if (bSetRequireDest && !sle->isFlag(lsfRequireDestTag)) { JLOG(j_.trace()) << "Set lsfRequireDestTag."; uFlagsOut |= lsfRequireDestTag; } - if (bClearRequireDest && ((uFlagsIn & lsfRequireDestTag) != 0u)) + if (bClearRequireDest && sle->isFlag(lsfRequireDestTag)) { JLOG(j_.trace()) << "Clear lsfRequireDestTag."; uFlagsOut &= ~lsfRequireDestTag; @@ -359,13 +344,13 @@ AccountSet::doApply() // // DisallowXRP // - if (bSetDisallowXRP && ((uFlagsIn & lsfDisallowXRP) == 0u)) + if (bSetDisallowXRP && !sle->isFlag(lsfDisallowXRP)) { JLOG(j_.trace()) << "Set lsfDisallowXRP."; uFlagsOut |= lsfDisallowXRP; } - if (bClearDisallowXRP && ((uFlagsIn & lsfDisallowXRP) != 0u)) + if (bClearDisallowXRP && sle->isFlag(lsfDisallowXRP)) { JLOG(j_.trace()) << "Clear lsfDisallowXRP."; uFlagsOut &= ~lsfDisallowXRP; @@ -374,7 +359,7 @@ AccountSet::doApply() // // DisableMaster // - if ((uSetFlag == asfDisableMaster) && ((uFlagsIn & lsfDisableMaster) == 0u)) + if ((uSetFlag == asfDisableMaster) && !sle->isFlag(lsfDisableMaster)) { if (!sigWithMaster) { @@ -392,7 +377,7 @@ AccountSet::doApply() uFlagsOut |= lsfDisableMaster; } - if ((uClearFlag == asfDisableMaster) && ((uFlagsIn & lsfDisableMaster) != 0u)) + if ((uClearFlag == asfDisableMaster) && sle->isFlag(lsfDisableMaster)) { JLOG(j_.trace()) << "Clear lsfDisableMaster."; uFlagsOut &= ~lsfDisableMaster; @@ -417,7 +402,7 @@ AccountSet::doApply() // if (uSetFlag == asfNoFreeze) { - if (!sigWithMaster && ((uFlagsIn & lsfDisableMaster) == 0u)) + if (!sigWithMaster && !sle->isFlag(lsfDisableMaster)) { JLOG(j_.trace()) << "Must use master key to set NoFreeze."; return tecNEED_MASTER_KEY; @@ -663,11 +648,13 @@ AccountSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AccountSet::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/account/SetRegularKey.cpp b/src/libxrpl/tx/transactors/account/SetRegularKey.cpp index bc59ed4fc1..f74407b433 100644 --- a/src/libxrpl/tx/transactors/account/SetRegularKey.cpp +++ b/src/libxrpl/tx/transactors/account/SetRegularKey.cpp @@ -29,7 +29,7 @@ SetRegularKey::calculateBaseFee(ReadView const& view, STTx const& tx) { auto const sle = view.read(keylet::account(id)); - if (sle && ((sle->getFlags() & lsfPasswordSpent) == 0u)) + if (sle && !sle->isFlag(lsfPasswordSpent)) { // flag is armed and they signed with the right account return XRPAmount{0}; @@ -86,6 +86,7 @@ SetRegularKey::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -96,6 +97,7 @@ SetRegularKey::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/account/SignerListSet.cpp b/src/libxrpl/tx/transactors/account/SignerListSet.cpp index 3060abe6df..92b6d18d40 100644 --- a/src/libxrpl/tx/transactors/account/SignerListSet.cpp +++ b/src/libxrpl/tx/transactors/account/SignerListSet.cpp @@ -197,7 +197,7 @@ removeSignersFromLedger( // If the lsfOneOwnerCount bit is set then remove just one owner count. // Otherwise use the pre-MultiSignReserve amendment calculation. int removeFromOwnerCount = -1; - if ((signers->getFlags() & lsfOneOwnerCount) == 0) + if (!signers->isFlag(lsfOneOwnerCount)) { STArray const& actualList = signers->getFieldArray(sfSignerEntries); removeFromOwnerCount = @@ -411,6 +411,7 @@ SignerListSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -421,6 +422,7 @@ SignerListSet::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp index 09e5a7284a..75d6b30315 100644 --- a/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp +++ b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp @@ -130,7 +130,7 @@ checkAttestationPublicKey( if (accountFromPK == attestationSignerAccount) { // master key - if ((sleAttestationSigningAccount->getFieldU32(sfFlags) & lsfDisableMaster) != 0u) + if (sleAttestationSigningAccount->isFlag(lsfDisableMaster)) { JLOG(j.trace()) << "Attempt to add an attestation with " "disabled master key."; @@ -408,7 +408,7 @@ transferHelper( { // Check dst tag and deposit auth - if (((sleDst->getFlags() & lsfRequireDestTag) != 0u) && !dstTag) + if (sleDst->isFlag(lsfRequireDestTag) && !dstTag) return tecDST_TAG_NEEDED; // If the destination is the claim owner, and this is a claim @@ -417,7 +417,7 @@ transferHelper( bool const canBypassDepositAuth = dst == claimOwner && depositAuthPolicy == DepositAuthPolicy::DstCanBypass; - if (!canBypassDepositAuth && ((sleDst->getFlags() & lsfDepositAuth) != 0u) && + if (!canBypassDepositAuth && sleDst->isFlag(lsfDepositAuth) && !psb.exists(keylet::depositPreauth(dst, src))) { return tecNO_PERMISSION; @@ -1425,7 +1425,7 @@ XChainCreateBridge::preclaim(PreclaimContext const& ctx) // Allowing clawing back funds would break the bridge's invariant that // wrapped funds are always backed by locked funds - if ((sleIssuer->getFlags() & lsfAllowTrustLineClawback) != 0u) + if (sleIssuer->isFlag(lsfAllowTrustLineClawback)) return tecNO_PERMISSION; } @@ -1504,7 +1504,7 @@ BridgeModify::preflight(PreflightContext const& ctx) auto const reward = ctx.tx[~sfSignatureReward]; auto const minAccountCreate = ctx.tx[~sfMinAccountCreateAmount]; auto const bridgeSpec = ctx.tx[sfXChainBridge]; - bool const clearAccountCreate = (ctx.tx.getFlags() & tfClearAccountCreateAmount) != 0u; + bool const clearAccountCreate = ctx.tx.isFlag(tfClearAccountCreateAmount); if (!reward && !minAccountCreate && !clearAccountCreate) { @@ -1562,7 +1562,7 @@ BridgeModify::doApply() auto const bridgeSpec = ctx_.tx[sfXChainBridge]; auto const reward = ctx_.tx[~sfSignatureReward]; auto const minAccountCreate = ctx_.tx[~sfMinAccountCreateAmount]; - bool const clearAccountCreate = (ctx_.tx.getFlags() & tfClearAccountCreateAmount) != 0u; + bool const clearAccountCreate = ctx_.tx.isFlag(tfClearAccountCreateAmount); auto const sleAcct = ctx_.view().peek(keylet::account(account)); if (!sleAcct) @@ -2228,6 +2228,7 @@ XChainCreateBridge::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2238,6 +2239,7 @@ XChainCreateBridge::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2247,6 +2249,7 @@ BridgeModify::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2257,6 +2260,7 @@ BridgeModify::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2266,11 +2270,13 @@ XChainClaim::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool XChainClaim::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2280,6 +2286,7 @@ XChainCommit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2290,6 +2297,7 @@ XChainCommit::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2299,6 +2307,7 @@ XChainCreateClaimID::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2309,6 +2318,7 @@ XChainCreateClaimID::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2318,6 +2328,7 @@ XChainAddClaimAttestation::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2328,6 +2339,7 @@ XChainAddClaimAttestation::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2337,6 +2349,7 @@ XChainAddAccountCreateAttestation::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2347,6 +2360,7 @@ XChainAddAccountCreateAttestation::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2356,6 +2370,7 @@ XChainCreateAccountCommit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2366,6 +2381,7 @@ XChainCreateAccountCommit::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/check/CheckCancel.cpp b/src/libxrpl/tx/transactors/check/CheckCancel.cpp index c30c116e58..7f1708fd81 100644 --- a/src/libxrpl/tx/transactors/check/CheckCancel.cpp +++ b/src/libxrpl/tx/transactors/check/CheckCancel.cpp @@ -107,11 +107,13 @@ CheckCancel::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool CheckCancel::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/check/CheckCash.cpp b/src/libxrpl/tx/transactors/check/CheckCash.cpp index 4cf8a5d514..c3455df8c3 100644 --- a/src/libxrpl/tx/transactors/check/CheckCash.cpp +++ b/src/libxrpl/tx/transactors/check/CheckCash.cpp @@ -115,8 +115,7 @@ CheckCash::preclaim(PreclaimContext const& ctx) return tecNO_ENTRY; } - if (((sleDst->getFlags() & lsfRequireDestTag) != 0u) && - !sleCheck->isFieldPresent(sfDestinationTag)) + if (sleDst->isFlag(lsfRequireDestTag) && !sleCheck->isFieldPresent(sfDestinationTag)) { // The tag is basically account-specific information we don't // understand, but we can require someone to fill it in. @@ -200,7 +199,7 @@ CheckCash::preclaim(PreclaimContext const& ctx) return tecNO_ISSUER; } - if ((sleIssuer->at(sfFlags) & lsfRequireAuth) != 0u) + if (sleIssuer->isFlag(lsfRequireAuth)) { if (!sleTrustLine) { @@ -434,21 +433,21 @@ CheckCash::doApply() initialBalance.get().account = noAccount(); if (TER const ter = trustCreate( - psb, // payment sandbox - destLow, // is dest low? - deliverIssuer, // source - account_, // destination - trustLineKey->key, // ledger index - sleDst, // Account to add to - false, // authorize account - (sleDst->getFlags() & lsfDefaultRipple) == 0, // - false, // freeze trust line - false, // deep freeze trust line - initialBalance, // zero initial balance - Issue(currency, account_), // limit of zero - 0, // quality in - 0, // quality out - viewJ); // journal + psb, // payment sandbox + destLow, // is dest low? + deliverIssuer, // source + account_, // destination + trustLineKey->key, // ledger index + sleDst, // Account to add to + false, // authorize account + !sleDst->isFlag(lsfDefaultRipple), // + false, // freeze trust line + false, // deep freeze trust line + initialBalance, // zero initial balance + Issue(currency, account_), // limit of zero + 0, // quality in + 0, // quality out + viewJ); // journal !isTesSuccess(ter)) { return ter; @@ -595,11 +594,13 @@ CheckCash::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool CheckCash::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/check/CheckCreate.cpp b/src/libxrpl/tx/transactors/check/CheckCreate.cpp index 91f019f471..7ce695039e 100644 --- a/src/libxrpl/tx/transactors/check/CheckCreate.cpp +++ b/src/libxrpl/tx/transactors/check/CheckCreate.cpp @@ -86,10 +86,8 @@ CheckCreate::preclaim(PreclaimContext const& ctx) return tecNO_DST; } - auto const flags = sleDst->getFlags(); - // Check if the destination has disallowed incoming checks - if ((flags & lsfDisallowIncomingCheck) != 0u) + if (sleDst->isFlag(lsfDisallowIncomingCheck)) return tecNO_PERMISSION; // Pseudo-accounts cannot cash checks. Note, this is not amendment-gated @@ -99,7 +97,7 @@ CheckCreate::preclaim(PreclaimContext const& ctx) if (isPseudoAccount(sleDst)) return tecNO_PERMISSION; - if (((flags & lsfRequireDestTag) != 0u) && !ctx.tx.isFieldPresent(sfDestinationTag)) + if (sleDst->isFlag(lsfRequireDestTag) && !ctx.tx.isFieldPresent(sfDestinationTag)) { // The tag is basically account-specific information we don't // understand, but we can require someone to fill it in. @@ -265,11 +263,13 @@ CheckCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool CheckCreate::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp b/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp index 0dd21d3bd5..10c5334504 100644 --- a/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp +++ b/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp @@ -73,7 +73,7 @@ CredentialAccept::preclaim(PreclaimContext const& ctx) return tecNO_ENTRY; } - if ((sleCred->getFieldU32(sfFlags) & lsfAccepted) != 0u) + if (sleCred->isFlag(lsfAccepted)) { JLOG(ctx.j.warn()) << "Credential already accepted: " << to_string(subject) << ", " << to_string(issuer) << ", " << credType; @@ -105,8 +105,10 @@ CredentialAccept::doApply() auto const credType(ctx_.tx[sfCredentialType]); Keylet const credentialKey = keylet::credential(account_, issuer, credType); auto const sleCred = view().peek(credentialKey); // Checked in preclaim() + if (!sleCred) + return tefINTERNAL; // LCOV_EXCL_LINE - if (checkExpired(sleCred, view().header().parentCloseTime)) + if (checkExpired(*sleCred, view().header().parentCloseTime)) { JLOG(j_.trace()) << "Credential is expired: " << sleCred->getText(); // delete expired credentials even if the transaction failed @@ -129,6 +131,7 @@ CredentialAccept::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -139,6 +142,7 @@ CredentialAccept::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp b/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp index e54c48287f..9d6231afe1 100644 --- a/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp +++ b/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp @@ -184,6 +184,7 @@ CredentialCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -194,6 +195,7 @@ CredentialCreate::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp b/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp index 42880bfdf8..e83a8b09dc 100644 --- a/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp +++ b/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp @@ -87,7 +87,7 @@ CredentialDelete::doApply() return tefINTERNAL; // LCOV_EXCL_LINE if ((subject != account_) && (issuer != account_) && - !checkExpired(sleCred, ctx_.view().header().parentCloseTime)) + !checkExpired(*sleCred, ctx_.view().header().parentCloseTime)) { JLOG(j_.trace()) << "Can't delete non-expired credential."; return tecNO_PERMISSION; @@ -102,6 +102,7 @@ CredentialDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -112,6 +113,7 @@ CredentialDelete::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp b/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp index baf208a305..feae97720f 100644 --- a/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp +++ b/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp @@ -179,11 +179,13 @@ DelegateSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool DelegateSet::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/AMMBid.cpp b/src/libxrpl/tx/transactors/dex/AMMBid.cpp index d4783c783b..894e6a9451 100644 --- a/src/libxrpl/tx/transactors/dex/AMMBid.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMBid.cpp @@ -384,11 +384,13 @@ AMMBid::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AMMBid::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/AMMClawback.cpp b/src/libxrpl/tx/transactors/dex/AMMClawback.cpp index 112d290e72..f034180cd6 100644 --- a/src/libxrpl/tx/transactors/dex/AMMClawback.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMClawback.cpp @@ -71,9 +71,7 @@ AMMClawback::preflight(PreflightContext const& ctx) if (isXRP(asset)) return temMALFORMED; - auto const flags = ctx.tx.getFlags(); - - if (((flags & tfClawTwoAssets) != 0u) && asset.getIssuer() != asset2.getIssuer()) + if (ctx.tx.isFlag(tfClawTwoAssets) && asset.getIssuer() != asset2.getIssuer()) { JLOG(ctx.j.trace()) << "AMMClawback: tfClawTwoAssets can only be enabled when two " "assets in the AMM pool are both issued by the issuer"; @@ -119,13 +117,11 @@ AMMClawback::preclaim(PreclaimContext const& ctx) return terNO_AMM; } - std::uint32_t const issuerFlagsIn = sleIssuer->getFieldU32(sfFlags); if (!ctx.view.rules().enabled(featureMPTokensV2)) { // If AllowTrustLineClawback is not set or NoFreeze is set, return no // permission - if (((issuerFlagsIn & lsfAllowTrustLineClawback) == 0u) || - ((issuerFlagsIn & lsfNoFreeze) != 0u)) + if (!sleIssuer->isFlag(lsfAllowTrustLineClawback) || sleIssuer->isFlag(lsfNoFreeze)) { return tecNO_PERMISSION; } @@ -137,8 +133,8 @@ AMMClawback::preclaim(PreclaimContext const& ctx) if (issue.native()) return false; // LCOV_EXCL_LINE - return ((issuerFlagsIn & lsfAllowTrustLineClawback) != 0u) && - ((issuerFlagsIn & lsfNoFreeze) == 0u); + return sleIssuer->isFlag(lsfAllowTrustLineClawback) && + !sleIssuer->isFlag(lsfNoFreeze); }, [&](MPTIssue const& issue) { auto const sleIssuance = ctx.view.read(keylet::mptIssuance(issue.getMptID())); @@ -288,8 +284,7 @@ AMMClawback::applyGuts(Sandbox& sb) if (!amount2Withdraw) return tecINTERNAL; // LCOV_EXCL_LINE - auto const flags = ctx_.tx.getFlags(); - if ((flags & tfClawTwoAssets) != 0u) + if (ctx_.tx.isFlag(tfClawTwoAssets)) return sendAmount(*amount2Withdraw); return tesSUCCESS; @@ -393,11 +388,13 @@ AMMClawback::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AMMClawback::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/AMMCreate.cpp b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp index a5503339b6..59ae6e9da4 100644 --- a/src/libxrpl/tx/transactors/dex/AMMCreate.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp @@ -136,7 +136,7 @@ AMMCreate::preclaim(PreclaimContext const& ctx) return false; if (auto const issuerAccount = view.read(keylet::account(asset.getIssuer()))) - return (issuerAccount->getFlags() & lsfDefaultRipple) == 0; + return !issuerAccount->isFlag(lsfDefaultRipple); return false; }; @@ -402,11 +402,13 @@ AMMCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AMMCreate::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/AMMDelete.cpp b/src/libxrpl/tx/transactors/dex/AMMDelete.cpp index 0ca7fd7c34..d9056fcbc0 100644 --- a/src/libxrpl/tx/transactors/dex/AMMDelete.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMDelete.cpp @@ -72,11 +72,13 @@ AMMDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AMMDelete::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp b/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp index b57698f706..9fc12be811 100644 --- a/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp @@ -74,35 +74,35 @@ AMMDeposit::preflight(PreflightContext const& ctx) JLOG(ctx.j.debug()) << "AMM Deposit: invalid flags."; return temMALFORMED; } - if ((flags & tfLPToken) != 0u) + if (ctx.tx.isFlag(tfLPToken)) { // if included then both amount and amount2 are deposit min if (!lpTokens || ePrice || (amount && !amount2) || (!amount && amount2) || tradingFee) return temMALFORMED; } - else if ((flags & tfSingleAsset) != 0u) + else if (ctx.tx.isFlag(tfSingleAsset)) { // if included then lpTokens is deposit min if (!amount || amount2 || ePrice || tradingFee) return temMALFORMED; } - else if ((flags & tfTwoAsset) != 0u) + else if (ctx.tx.isFlag(tfTwoAsset)) { // if included then lpTokens is deposit min if (!amount || !amount2 || ePrice || tradingFee) return temMALFORMED; } - else if ((flags & tfOneAssetLPToken) != 0u) + else if (ctx.tx.isFlag(tfOneAssetLPToken)) { if (!amount || !lpTokens || amount2 || ePrice || tradingFee) return temMALFORMED; } - else if ((flags & tfLimitLPToken) != 0u) + else if (ctx.tx.isFlag(tfLimitLPToken)) { if (!amount || !ePrice || lpTokens || amount2 || tradingFee) return temMALFORMED; } - else if ((flags & tfTwoAssetIfEmpty) != 0u) + else if (ctx.tx.isFlag(tfTwoAssetIfEmpty)) { if (!amount || !amount2 || ePrice || lpTokens) return temMALFORMED; @@ -197,7 +197,7 @@ AMMDeposit::preclaim(PreclaimContext const& ctx) if (!expected) return expected.error(); // LCOV_EXCL_LINE auto const [amountBalance, amount2Balance, lptAMMBalance] = *expected; - if ((ctx.tx.getFlags() & tfTwoAssetIfEmpty) != 0u) + if (ctx.tx.isFlag(tfTwoAssetIfEmpty)) { if (lptAMMBalance != beast::kZERO) return tecAMM_NOT_EMPTY; @@ -332,7 +332,7 @@ AMMDeposit::preclaim(PreclaimContext const& ctx) }; // amount and amount2 are deposit min in case of tfLPToken - if ((ctx.tx.getFlags() & tfLPToken) == 0u) + if (!ctx.tx.isFlag(tfLPToken)) { if (auto const ter = checkAmount(amount, true)) return ter; @@ -1014,11 +1014,13 @@ AMMDeposit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AMMDeposit::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/AMMVote.cpp b/src/libxrpl/tx/transactors/dex/AMMVote.cpp index 4ab3653792..eb4a5e87be 100644 --- a/src/libxrpl/tx/transactors/dex/AMMVote.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMVote.cpp @@ -255,11 +255,13 @@ AMMVote::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AMMVote::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp b/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp index f9546c585a..f57ff7f8dc 100644 --- a/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp @@ -81,37 +81,37 @@ AMMWithdraw::preflight(PreflightContext const& ctx) JLOG(ctx.j.debug()) << "AMM Withdraw: invalid flags."; return temMALFORMED; } - if ((flags & tfLPToken) != 0u) + if (ctx.tx.isFlag(tfLPToken)) { if (!lpTokens || amount || amount2 || ePrice) return temMALFORMED; } - else if ((flags & tfWithdrawAll) != 0u) + else if (ctx.tx.isFlag(tfWithdrawAll)) { if (lpTokens || amount || amount2 || ePrice) return temMALFORMED; } - else if ((flags & tfOneAssetWithdrawAll) != 0u) + else if (ctx.tx.isFlag(tfOneAssetWithdrawAll)) { if (!amount || lpTokens || amount2 || ePrice) return temMALFORMED; } - else if ((flags & tfSingleAsset) != 0u) + else if (ctx.tx.isFlag(tfSingleAsset)) { if (!amount || lpTokens || amount2 || ePrice) return temMALFORMED; } - else if ((flags & tfTwoAsset) != 0u) + else if (ctx.tx.isFlag(tfTwoAsset)) { if (!amount || !amount2 || lpTokens || ePrice) return temMALFORMED; } - else if ((flags & tfOneAssetLPToken) != 0u) + else if (ctx.tx.isFlag(tfOneAssetLPToken)) { if (!amount || !lpTokens || amount2 || ePrice) return temMALFORMED; } - else if ((flags & tfLimitLPToken) != 0u) + else if (ctx.tx.isFlag(tfLimitLPToken)) { if (!amount || !ePrice || lpTokens || amount2) return temMALFORMED; @@ -1147,11 +1147,13 @@ AMMWithdraw::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool AMMWithdraw::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/OfferCancel.cpp b/src/libxrpl/tx/transactors/dex/OfferCancel.cpp index 72682149a3..547db00dca 100644 --- a/src/libxrpl/tx/transactors/dex/OfferCancel.cpp +++ b/src/libxrpl/tx/transactors/dex/OfferCancel.cpp @@ -75,11 +75,13 @@ OfferCancel::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool OfferCancel::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp index 4e542e5105..a94accfe72 100644 --- a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp +++ b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp @@ -91,13 +91,11 @@ OfferCreate::preflight(PreflightContext const& ctx) auto& tx = ctx.tx; auto& j = ctx.j; - std::uint32_t const uTxFlags = tx.getFlags(); - if (tx.isFlag(tfHybrid) && !tx.isFieldPresent(sfDomainID)) return temINVALID_FLAG; - bool const bImmediateOrCancel((uTxFlags & tfImmediateOrCancel) != 0u); - bool const bFillOrKill((uTxFlags & tfFillOrKill) != 0u); + bool const bImmediateOrCancel(tx.isFlag(tfImmediateOrCancel)); + bool const bFillOrKill(tx.isFlag(tfFillOrKill)); if (bImmediateOrCancel && bFillOrKill) { @@ -278,7 +276,7 @@ OfferCreate::checkAcceptAsset( return asset.visit( [&](Issue const& issue) -> TER { auto const& issuer = issue.getIssuer(); - if (((*issuerAccount)[sfFlags] & lsfRequireAuth) != 0u) + if (issuerAccount->isFlag(lsfRequireAuth)) { auto const trustLine = view.read(keylet::line(id, issuer, issue.currency)); @@ -293,8 +291,7 @@ OfferCreate::checkAcceptAsset( // access. bool const canonicalGt(id > issuer); - bool const isAuthorized( - ((*trustLine)[sfFlags] & (canonicalGt ? lsfLowAuth : lsfHighAuth)) != 0u); + bool const isAuthorized(trustLine->isFlag(canonicalGt ? lsfLowAuth : lsfHighAuth)); if (!isAuthorized) { @@ -390,8 +387,7 @@ OfferCreate::flowCross( // If we're creating a passive offer adjust the threshold so we only // cross offers that have a better quality than this one. - std::uint32_t const txFlags = ctx_.tx.getFlags(); - if ((txFlags & tfPassive) != 0u) + if (ctx_.tx.isFlag(tfPassive)) ++threshold; // Don't send more than our balance. @@ -413,7 +409,7 @@ OfferCreate::flowCross( STAmount deliver = takerAmount.out; auto const& deliverAsset = deliver.asset(); OfferCrossing offerCrossing = OfferCrossing::Yes; - if ((txFlags & tfSell) != 0u) + if (ctx_.tx.isFlag(tfSell)) { offerCrossing = OfferCrossing::Sell; // We are selling, so we will accept *more* than the offer @@ -447,9 +443,9 @@ OfferCreate::flowCross( account_, account_, paths, - true, // default path - (txFlags & tfFillOrKill) == 0u, // partial payment - true, // owner pays transfer fee + true, // default path + !ctx_.tx.isFlag(tfFillOrKill), // partial payment + true, // owner pays transfer fee offerCrossing, threshold, sendMax, @@ -488,7 +484,7 @@ OfferCreate::flowCross( { STAmount const rate{Quality{takerAmount.out, takerAmount.in}.rate()}; - if ((txFlags & tfSell) != 0u) + if (ctx_.tx.isFlag(tfSell)) { // If selling then scale the new out amount based on how // much we sold during crossing. This preserves the offer @@ -607,13 +603,11 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) { using beast::kZERO; - std::uint32_t const uTxFlags = ctx_.tx.getFlags(); - - bool const bPassive((uTxFlags & tfPassive) != 0u); - bool const bImmediateOrCancel((uTxFlags & tfImmediateOrCancel) != 0u); - bool const bFillOrKill((uTxFlags & tfFillOrKill) != 0u); - bool const bSell((uTxFlags & tfSell) != 0u); - bool const bHybrid((uTxFlags & tfHybrid) != 0u); + bool const bPassive(ctx_.tx.isFlag(tfPassive)); + bool const bImmediateOrCancel(ctx_.tx.isFlag(tfImmediateOrCancel)); + bool const bFillOrKill(ctx_.tx.isFlag(tfFillOrKill)); + bool const bSell(ctx_.tx.isFlag(tfSell)); + bool const bHybrid(ctx_.tx.isFlag(tfHybrid)); auto saTakerPays = ctx_.tx[sfTakerPays]; auto saTakerGets = ctx_.tx[sfTakerGets]; @@ -988,11 +982,13 @@ OfferCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool OfferCreate::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/did/DIDDelete.cpp b/src/libxrpl/tx/transactors/did/DIDDelete.cpp index a323822b9c..9f9f54e6f6 100644 --- a/src/libxrpl/tx/transactors/did/DIDDelete.cpp +++ b/src/libxrpl/tx/transactors/did/DIDDelete.cpp @@ -76,11 +76,13 @@ DIDDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool DIDDelete::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/did/DIDSet.cpp b/src/libxrpl/tx/transactors/did/DIDSet.cpp index 69bb9dd839..fbed821280 100644 --- a/src/libxrpl/tx/transactors/did/DIDSet.cpp +++ b/src/libxrpl/tx/transactors/did/DIDSet.cpp @@ -156,11 +156,13 @@ DIDSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool DIDSet::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp index 9a48123201..05d6a29454 100644 --- a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp +++ b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp @@ -225,6 +225,7 @@ EscrowCancel::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -235,6 +236,7 @@ EscrowCancel::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp index d5bbe17325..e9c7857072 100644 --- a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp +++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp @@ -442,7 +442,7 @@ EscrowCreate::doApply() auto const sled = ctx_.view().read(keylet::account(ctx_.tx[sfDestination])); if (!sled) return tecNO_DST; // LCOV_EXCL_LINE - if ((((*sled)[sfFlags] & lsfRequireDestTag) != 0u) && !ctx_.tx[~sfDestinationTag]) + if (sled->isFlag(lsfRequireDestTag) && !ctx_.tx[~sfDestinationTag]) return tecDST_TAG_NEEDED; } @@ -536,6 +536,7 @@ EscrowCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -546,6 +547,7 @@ EscrowCreate::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp index 116466a1a3..fb6c77c61a 100644 --- a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp +++ b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp @@ -405,6 +405,7 @@ EscrowFinish::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -415,6 +416,7 @@ EscrowFinish::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp index 14bc5f7a51..c59a02d4c2 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp @@ -365,6 +365,7 @@ LoanBrokerCoverClawback::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -375,6 +376,7 @@ LoanBrokerCoverClawback::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp index a8fa91b648..a35878f5c6 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp @@ -139,6 +139,7 @@ LoanBrokerCoverDeposit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -149,6 +150,7 @@ LoanBrokerCoverDeposit::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp index ca4136be0a..127d23a270 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp @@ -192,6 +192,7 @@ LoanBrokerCoverWithdraw::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -202,6 +203,7 @@ LoanBrokerCoverWithdraw::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp index 0d6d6e6cd6..2c5767f9cc 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp @@ -197,6 +197,7 @@ LoanBrokerDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -207,6 +208,7 @@ LoanBrokerDelete::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp index bf00a344a7..97ef73515a 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp @@ -284,6 +284,7 @@ LoanBrokerSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -294,6 +295,7 @@ LoanBrokerSet::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp index ff33bfb9fb..928ba67db4 100644 --- a/src/libxrpl/tx/transactors/lending/LoanDelete.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp @@ -147,11 +147,13 @@ LoanDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool LoanDelete::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanManage.cpp b/src/libxrpl/tx/transactors/lending/LoanManage.cpp index d1cd5de505..46c85c9f96 100644 --- a/src/libxrpl/tx/transactors/lending/LoanManage.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanManage.cpp @@ -424,7 +424,7 @@ LoanManage::doApply() // Pre-amendment, associateAsset was only called on the noop (no flags) // path. Post-amendment, we call associateAsset on all successful paths. - if (view.rules().enabled(fixSecurity3_1_3) && isTesSuccess(result)) + if (view.rules().enabled(fixCleanup3_1_3) && isTesSuccess(result)) { associateAsset(*loanSle, vaultAsset); associateAsset(*brokerSle, vaultAsset); @@ -440,11 +440,13 @@ LoanManage::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool LoanManage::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanPay.cpp b/src/libxrpl/tx/transactors/lending/LoanPay.cpp index b8d73bfd65..a9668d9f4c 100644 --- a/src/libxrpl/tx/transactors/lending/LoanPay.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp @@ -30,6 +30,7 @@ #include #include #include +#include namespace xrpl { @@ -141,14 +142,36 @@ LoanPay::calculateBaseFee(ReadView const& view, STTx const& tx) NumberRoundModeGuard const mg( tx.isFlag(tfLoanOverpayment) ? Number::RoundingMode::Upward : Number::RoundingMode::Downward); + + static_assert(kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION % kLOAN_PAYMENTS_PER_FEE_INCREMENT == 0); + std::int64_t constexpr kMAX_FEE_INCREMENTS = + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION / kLOAN_PAYMENTS_PER_FEE_INCREMENT; + + if (view.rules().enabled(fixCleanup3_1_3) && + amount >= regularPayment * kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION) + { + // The payment handler will never process more than + // loanMaximumPaymentsPerTransaction payments (including overpayments), + // and one fee increment is charged for every + // loanPaymentsPerFeeIncrement, so don't charge more than + // loanMaximumPaymentsPerTransaction / loanPaymentsPerFeeIncrement fee + // increments. + return kMAX_FEE_INCREMENTS * normalCost; + } + // Estimate how many payments will be made Number const numPaymentEstimate = static_cast(amount / regularPayment); // Charge one base fee per paymentsPerFeeIncrement payments, rounding up. + // This set round is safe because there's a mode guard just above Number::setround(Number::RoundingMode::Upward); auto const feeIncrements = std::max( std::int64_t(1), static_cast(numPaymentEstimate / kLOAN_PAYMENTS_PER_FEE_INCREMENT)); + XRPL_ASSERT( + !view.rules().enabled(fixCleanup3_1_3) || feeIncrements <= kMAX_FEE_INCREMENTS, + "xrpl::LoanPay::calculateBaseFee : number of fee increments is in " + "range"); return feeIncrements * normalCost; } @@ -178,7 +201,7 @@ LoanPay::preclaim(PreclaimContext const& ctx) if (tx.isFlag(tfLoanOverpayment) && !loanSle->isFlag(lsfLoanOverpayment)) { JLOG(ctx.j.warn()) << "Requested overpayment on a loan that doesn't allow it"; - return ctx.view.rules().enabled(fixSecurity3_1_3) ? TER{tecNO_PERMISSION} : temINVALID_FLAG; + return ctx.view.rules().enabled(fixCleanup3_1_3) ? TER{tecNO_PERMISSION} : temINVALID_FLAG; } auto const principalOutstanding = loanSle->at(sfPrincipalOutstanding); @@ -442,9 +465,10 @@ LoanPay::doApply() // Vault object state changes view.update(vaultSle); + Number const assetsAvailableBefore = *assetsAvailableProxy; + Number const assetsTotalBefore = *assetsTotalProxy; #if !NDEBUG { - Number const assetsAvailableBefore = *assetsAvailableProxy; Number const pseudoAccountBalanceBefore = accountHolds( view, vaultPseudoAccount, @@ -468,16 +492,6 @@ LoanPay::doApply() "xrpl::LoanPay::doApply", "assets available must not be greater than assets outstanding"); - if (*assetsAvailableProxy > *assetsTotalProxy) - { - // LCOV_EXCL_START - JLOG(j_.fatal()) << "Vault assets available must not be greater " - "than assets outstanding. Available: " - << *assetsAvailableProxy << ", Total: " << *assetsTotalProxy; - return tecINTERNAL; - // LCOV_EXCL_STOP - } - JLOG(j_.debug()) << "total paid to vault raw: " << totalPaidToVaultRaw << ", total paid to vault rounded: " << totalPaidToVaultRounded << ", total paid to broker: " << totalPaidToBroker @@ -503,12 +517,68 @@ LoanPay::doApply() associateAsset(*vaultSle, asset); // Duplicate some checks after rounding + Number const assetsAvailableAfter = *assetsAvailableProxy; + Number const assetsTotalAfter = *assetsTotalProxy; + XRPL_ASSERT_PARTS( - *assetsAvailableProxy <= *assetsTotalProxy, + assetsAvailableAfter <= assetsTotalAfter, "xrpl::LoanPay::doApply", "assets available must not be greater than assets outstanding"); + if (assetsAvailableAfter == assetsAvailableBefore) + { + // An unchanged assetsAvailable indicates that the amount paid to the + // vault was zero, or rounded to zero. That should be impossible, but I + // can't rule it out for extreme edge cases, so fail gracefully if it + // happens. + // + // LCOV_EXCL_START + JLOG(j_.warn()) << "LoanPay: Vault assets available unchanged after rounding: " // + << "Before: " << assetsAvailableBefore // + << ", After: " << assetsAvailableAfter; + return tecPRECISION_LOSS; + // LCOV_EXCL_STOP + } + if (paymentParts->valueChange != beast::kZERO && assetsTotalAfter == assetsTotalBefore) + { + // Non-zero valueChange with an unchanged assetsTotal indicates that the + // actual value change rounded to zero. That should be impossible, but I + // can't rule it out for extreme edge cases, so fail gracefully if it + // happens. + // + // LCOV_EXCL_START + JLOG(j_.warn()) + << "LoanPay: Vault assets expected change, but unchanged after rounding: " // + << "Before: " << assetsTotalBefore // + << ", After: " << assetsTotalAfter // + << ", ValueChange: " << paymentParts->valueChange; + return tecPRECISION_LOSS; + // LCOV_EXCL_STOP + } + if (paymentParts->valueChange == beast::kZERO && assetsTotalAfter != assetsTotalBefore) + { + // A change in assetsTotal when there was no valueChange indicates that + // something really weird happened. That should be flat out impossible. + // + // LCOV_EXCL_START + JLOG(j_.fatal()) << "LoanPay: Vault assets changed unexpectedly after rounding: " // + << "Before: " << assetsTotalBefore // + << ", After: " << assetsTotalAfter // + << ", ValueChange: " << paymentParts->valueChange; + return tecINTERNAL; + // LCOV_EXCL_STOP + } + if (assetsAvailableAfter > assetsTotalAfter) + { + // Assets available are not allowed to be larger than assets total. + // LCOV_EXCL_START + JLOG(j_.fatal()) << "LoanPay: Vault assets available must not be greater " + "than assets outstanding. Available: " + << assetsAvailableAfter << ", Total: " << assetsTotalAfter; + return tecINTERNAL; + // LCOV_EXCL_STOP + } -#if !NDEBUG + // These three values are used to check that funds are conserved after the transfers auto const accountBalanceBefore = accountHolds( view, account_, @@ -536,7 +606,6 @@ LoanPay::doApply() AuthHandling::IgnoreAuth, j_, SpendableHandling::FullBalance); -#endif if (totalPaidToVaultRounded != beast::kZERO) { @@ -572,19 +641,22 @@ LoanPay::doApply() return ter; #if !NDEBUG - Number const assetsAvailableAfter = *assetsAvailableProxy; - Number const pseudoAccountBalanceAfter = accountHolds( - view, - vaultPseudoAccount, - asset, - FreezeHandling::IgnoreFreeze, - AuthHandling::IgnoreAuth, - j_); - XRPL_ASSERT_PARTS( - assetsAvailableAfter == pseudoAccountBalanceAfter, - "xrpl::LoanPay::doApply", - "vault pseudo balance agrees after"); + { + Number const pseudoAccountBalanceAfter = accountHolds( + view, + vaultPseudoAccount, + asset, + FreezeHandling::IgnoreFreeze, + AuthHandling::IgnoreAuth, + j_); + XRPL_ASSERT_PARTS( + assetsAvailableAfter == pseudoAccountBalanceAfter, + "xrpl::LoanPay::doApply", + "vault pseudo balance agrees after"); + } +#endif + // Check that funds are conserved auto const accountBalanceAfter = accountHolds( view, account_, @@ -612,14 +684,121 @@ LoanPay::doApply() AuthHandling::IgnoreAuth, j_, SpendableHandling::FullBalance); + auto const balanceScale = [&]() { + // Find a reasonable scale to use for the balance comparisons. + // + // First find the minimum and maximum exponent of all the non-zero balances, before and + // after. If min and max are equal, use that value. If they are not, use "max + 1" to reduce + // rounding discrepancies without making the result meaningless. Cap the scale at + // STAmount::kMAX_OFFSET, just in case the numbers are all very large. + std::vector exponents; + exponents.reserve(6); + for (auto const& a : { + accountBalanceBefore, + vaultBalanceBefore, + brokerBalanceBefore, + accountBalanceAfter, + vaultBalanceAfter, + brokerBalanceAfter, + }) + { + // Exclude zeroes + if (a != beast::kZERO) + exponents.push_back(a.exponent()); + } + if (exponents.empty()) + { + UNREACHABLE("xrpl::LoanPay::doApply : all zeroes"); + return 0; + } + auto const [minItr, maxItr] = std::ranges::minmax_element(exponents); + auto const min = *minItr; + auto const max = *maxItr; + JLOG(j_.trace()) << "Min scale: " << min << ", max scale: " << max; + // IOU rounding can be interesting. We want all the balance checks to agree, but don't want + // to round to such an extreme that it becomes meaningless. e.g. Everything rounds to one + // digit. So add 1 to the max (reducing the number of digits after the decimal point by 1) + // if the scales are not already all the same. + return std::min(min == max ? max : max + 1, STAmount::kMAX_OFFSET); + }(); + + // No object changes are made below this point XRPL_ASSERT_PARTS( - accountBalanceBefore + vaultBalanceBefore + brokerBalanceBefore == - accountBalanceAfter + vaultBalanceAfter + brokerBalanceAfter, + Number::getround() == Number::RoundingMode::ToNearest, "xrpl::LoanPay::doApply", - "funds are conserved (with rounding)"); + "Number rounding ToNearest"); + NumberRoundModeGuard const mg(Number::RoundingMode::ToNearest); + + auto const accountBalanceBeforeRounded = roundToScale(accountBalanceBefore, balanceScale); + auto const vaultBalanceBeforeRounded = roundToScale(vaultBalanceBefore, balanceScale); + auto const brokerBalanceBeforeRounded = roundToScale(brokerBalanceBefore, balanceScale); + + auto const totalBalanceBefore = accountBalanceBefore + vaultBalanceBefore + brokerBalanceBefore; + auto const totalBalanceBeforeRounded = roundToScale(totalBalanceBefore, balanceScale); + + JLOG(j_.trace()) << "Before: " // + << "account " << Number(accountBalanceBeforeRounded) << " (" + << Number(accountBalanceBefore) << ")" + << ", vault " << Number(vaultBalanceBeforeRounded) << " (" + << Number(vaultBalanceBefore) << ")" + << ", broker " << Number(brokerBalanceBeforeRounded) << " (" + << Number(brokerBalanceBefore) << ")" + << ", total " << Number(totalBalanceBeforeRounded) << " (" + << Number(totalBalanceBefore) << ")"; + + auto const accountBalanceAfterRounded = roundToScale(accountBalanceAfter, balanceScale); + auto const vaultBalanceAfterRounded = roundToScale(vaultBalanceAfter, balanceScale); + auto const brokerBalanceAfterRounded = roundToScale(brokerBalanceAfter, balanceScale); + + auto const totalBalanceAfter = accountBalanceAfter + vaultBalanceAfter + brokerBalanceAfter; + auto const totalBalanceAfterRounded = roundToScale(totalBalanceAfter, balanceScale); + + JLOG(j_.trace()) << "After: " // + << "account " << Number(accountBalanceAfterRounded) << " (" + << Number(accountBalanceAfter) << ")" + << ", vault " << Number(vaultBalanceAfterRounded) << " (" + << Number(vaultBalanceAfter) << ")" + << ", broker " << Number(brokerBalanceAfterRounded) << " (" + << Number(brokerBalanceAfter) << ")" + << ", total " << Number(totalBalanceAfterRounded) << " (" + << Number(totalBalanceAfter) << ")"; + + auto const accountBalanceChange = accountBalanceAfter - accountBalanceBefore; + auto const vaultBalanceChange = vaultBalanceAfter - vaultBalanceBefore; + auto const brokerBalanceChange = brokerBalanceAfter - brokerBalanceBefore; + + auto const totalBalanceChange = accountBalanceChange + vaultBalanceChange + brokerBalanceChange; + auto const totalBalanceChangeRounded = roundToScale(totalBalanceChange, balanceScale); + + JLOG(j_.trace()) << "Changes: " // + << "account " << to_string(accountBalanceChange) // + << ", vault " << to_string(vaultBalanceChange) // + << ", broker " << to_string(brokerBalanceChange) // + << ", total " << to_string(totalBalanceChangeRounded) << " (" + << Number(totalBalanceChange) << ")"; + + bool const goodRounding = totalBalanceBeforeRounded == totalBalanceAfterRounded || + totalBalanceChangeRounded == beast::kZERO; + if (totalBalanceBeforeRounded != totalBalanceAfterRounded) + { + JLOG((goodRounding ? j_.debug() : j_.warn())) + << "Total rounded balances don't match" + << (totalBalanceChangeRounded == beast::kZERO ? ", but total changes do" : ""); + } + if (totalBalanceChangeRounded != beast::kZERO) + { + JLOG((goodRounding ? j_.debug() : j_.warn())) + << "Total balance changes don't match" + << (totalBalanceBeforeRounded == totalBalanceAfterRounded ? ", but total balances do" + : ""); + } + + // Rounding for IOUs can be weird, so check a few different ways to show + // that funds are conserved. XRPL_ASSERT_PARTS( - accountBalanceAfter >= beast::kZERO, "xrpl::LoanPay::doApply", "positive account balance"); + goodRounding, "xrpl::LoanPay::doApply", "funds are conserved (with rounding)"); + XRPL_ASSERT_PARTS( accountBalanceAfter < accountBalanceBefore || account_ == asset.getIssuer(), "xrpl::LoanPay::doApply", @@ -640,7 +819,6 @@ LoanPay::doApply() vaultBalanceAfter > vaultBalanceBefore || brokerBalanceAfter > brokerBalanceBefore, "xrpl::LoanPay::doApply", "vault and/or broker balance increased"); -#endif return tesSUCCESS; } @@ -651,11 +829,13 @@ LoanPay::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool LoanPay::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/lending/LoanSet.cpp b/src/libxrpl/tx/transactors/lending/LoanSet.cpp index 9503eeef03..3f5bbfb1a3 100644 --- a/src/libxrpl/tx/transactors/lending/LoanSet.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp @@ -418,6 +418,7 @@ LoanSet::doApply() auto const paymentTotal = tx[~sfPaymentTotal].value_or(kDEFAULT_PAYMENT_TOTAL); auto const properties = computeLoanProperties( + view.rules(), vaultAsset, principalRequested, interestRate, @@ -652,11 +653,13 @@ LoanSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool LoanSet::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp index 06bd1301cb..0888066aef 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp @@ -68,10 +68,10 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx) if (hasExpired(ctx.view, (*offerSLE)[~sfExpiration])) { - // Before fixSecurity3_1_3 amendment, expired offers caused tecEXPIRED in preclaim, + // Before fixCleanup3_1_3 amendment, expired offers caused tecEXPIRED in preclaim, // leaving them on ledger forever. After the amendment, we allow expired offers to // reach doApply() where they get deleted and tecEXPIRED is returned. - if (!ctx.view.rules().enabled(fixSecurity3_1_3)) + if (!ctx.view.rules().enabled(fixCleanup3_1_3)) return {nullptr, tecEXPIRED}; // Amendment enabled: return the expired offer to be handled in doApply. } @@ -159,7 +159,7 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx) if (bo) { - if (((*bo)[sfFlags] & lsfSellNFToken) == lsfSellNFToken) + if (bo->isFlag(lsfSellNFToken)) return tecNFTOKEN_OFFER_TYPE_MISMATCH; // An account can't accept an offer it placed: @@ -218,7 +218,7 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx) if (so) { - if (((*so)[sfFlags] & lsfSellNFToken) != lsfSellNFToken) + if (!so->isFlag(lsfSellNFToken)) return tecNFTOKEN_OFFER_TYPE_MISMATCH; // An account can't accept an offer it placed: @@ -450,9 +450,9 @@ NFTokenAcceptOffer::doApply() auto bo = loadToken(ctx_.tx[~sfNFTokenBuyOffer]); auto so = loadToken(ctx_.tx[~sfNFTokenSellOffer]); - // With fixSecurity3_1_3 amendment, check for expired offers and delete them, returning + // With fixCleanup3_1_3 amendment, check for expired offers and delete them, returning // tecEXPIRED. This ensures expired offers are properly cleaned up from the ledger. - if (view().rules().enabled(fixSecurity3_1_3)) + if (view().rules().enabled(fixCleanup3_1_3)) { bool foundExpired = false; @@ -574,6 +574,7 @@ NFTokenAcceptOffer::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -584,6 +585,7 @@ NFTokenAcceptOffer::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp b/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp index fb57b14c15..95791d220e 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp @@ -100,11 +100,13 @@ NFTokenBurn::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool NFTokenBurn::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp index e76d7677aa..9186d32424 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp @@ -103,6 +103,7 @@ NFTokenCancelOffer::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -113,6 +114,7 @@ NFTokenCancelOffer::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/nft/NFTokenCreateOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenCreateOffer.cpp index 9ca5220a8c..9c7fe7d5ef 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenCreateOffer.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenCreateOffer.cpp @@ -55,9 +55,8 @@ NFTokenCreateOffer::preclaim(PreclaimContext const& ctx) uint256 const nftokenID = ctx.tx[sfNFTokenID]; std::uint32_t const txFlags = ctx.tx.getFlags(); - if (!nft::findToken( - ctx.view, ctx.tx[((txFlags & tfSellNFToken) != 0u) ? sfAccount : sfOwner], nftokenID)) + ctx.view, ctx.tx[ctx.tx.isFlag(tfSellNFToken) ? sfAccount : sfOwner], nftokenID)) return tecNO_ENTRY; // Use implementation shared with NFTokenMint @@ -97,6 +96,7 @@ NFTokenCreateOffer::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -107,6 +107,7 @@ NFTokenCreateOffer::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp b/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp index c7cb37ad94..358e9b6bd6 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp @@ -349,11 +349,13 @@ NFTokenMint::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool NFTokenMint::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp b/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp index b56ee9b061..a21196ff57 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp @@ -74,6 +74,7 @@ NFTokenModify::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -84,6 +85,7 @@ NFTokenModify::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/oracle/OracleDelete.cpp b/src/libxrpl/tx/transactors/oracle/OracleDelete.cpp index c6896b78d4..99f2a14900 100644 --- a/src/libxrpl/tx/transactors/oracle/OracleDelete.cpp +++ b/src/libxrpl/tx/transactors/oracle/OracleDelete.cpp @@ -94,6 +94,7 @@ OracleDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -104,6 +105,7 @@ OracleDelete::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/oracle/OracleSet.cpp b/src/libxrpl/tx/transactors/oracle/OracleSet.cpp index 7c2a817ed1..ea828256b8 100644 --- a/src/libxrpl/tx/transactors/oracle/OracleSet.cpp +++ b/src/libxrpl/tx/transactors/oracle/OracleSet.cpp @@ -334,11 +334,13 @@ OracleSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool OracleSet::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp b/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp index e4a060ea31..2e298a70d5 100644 --- a/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp +++ b/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp @@ -303,6 +303,7 @@ DepositPreauth::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -313,6 +314,7 @@ DepositPreauth::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/payment/Payment.cpp b/src/libxrpl/tx/transactors/payment/Payment.cpp index d283874296..fc7bf753b1 100644 --- a/src/libxrpl/tx/transactors/payment/Payment.cpp +++ b/src/libxrpl/tx/transactors/payment/Payment.cpp @@ -122,14 +122,12 @@ Payment::preflight(PreflightContext const& ctx) if (!ctx.rules.enabled(featureMPTokensV1) && isDstMPT) return temDISABLED; - std::uint32_t const txFlags = tx.getFlags(); - if (!mpTokensV2 && isDstMPT && ctx.tx.isFieldPresent(sfPaths)) return temMALFORMED; - bool const partialPaymentAllowed = (txFlags & tfPartialPayment) != 0u; - bool const limitQuality = (txFlags & tfLimitQuality) != 0u; - bool const defaultPathsAllowed = (txFlags & tfNoRippleDirect) == 0u; + bool const partialPaymentAllowed = tx.isFlag(tfPartialPayment); + bool const limitQuality = tx.isFlag(tfLimitQuality); + bool const defaultPathsAllowed = !tx.isFlag(tfNoRippleDirect); bool const hasPaths = tx.isFieldPresent(sfPaths); bool const hasMax = tx.isFieldPresent(sfSendMax); @@ -311,8 +309,7 @@ TER Payment::preclaim(PreclaimContext const& ctx) { // Ripple if source or destination is non-native or if there are paths. - std::uint32_t const txFlags = ctx.tx.getFlags(); - bool const partialPaymentAllowed = (txFlags & tfPartialPayment) != 0u; + bool const partialPaymentAllowed = ctx.tx.isFlag(tfPartialPayment); auto const hasPaths = ctx.tx.isFieldPresent(sfPaths); auto const sendMax = ctx.tx[~sfSendMax]; @@ -357,9 +354,7 @@ Payment::preclaim(PreclaimContext const& ctx) return tecNO_DST_INSUF_XRP; } } - else if ( - ((sleDst->getFlags() & lsfRequireDestTag) != 0u) && - !ctx.tx.isFieldPresent(sfDestinationTag)) + else if (sleDst->isFlag(lsfRequireDestTag) && !ctx.tx.isFieldPresent(sfDestinationTag)) { // The tag is basically account-specific information we don't // understand, but we can require someone to fill it in. @@ -406,10 +401,9 @@ Payment::doApply() auto const deliverMin = ctx_.tx[~sfDeliverMin]; // Ripple if source or destination is non-native or if there are paths. - std::uint32_t const txFlags = ctx_.tx.getFlags(); - bool const partialPaymentAllowed = (txFlags & tfPartialPayment) != 0u; - bool const limitQuality = (txFlags & tfLimitQuality) != 0u; - bool const defaultPathsAllowed = (txFlags & tfNoRippleDirect) == 0u; + bool const partialPaymentAllowed = ctx_.tx.isFlag(tfPartialPayment); + bool const limitQuality = ctx_.tx.isFlag(tfLimitQuality); + bool const defaultPathsAllowed = !ctx_.tx.isFlag(tfNoRippleDirect); auto const hasPaths = ctx_.tx.isFieldPresent(sfPaths); auto const sendMax = ctx_.tx[~sfSendMax]; @@ -672,7 +666,7 @@ Payment::doApply() sleDst->setFieldAmount(sfBalance, sleDst->getFieldAmount(sfBalance) + dstAmount); // Re-arm the password change fee if we can and need to. - if ((sleDst->getFlags() & lsfPasswordSpent) != 0u) + if (sleDst->isFlag(lsfPasswordSpent)) sleDst->clearFlag(lsfPasswordSpent); return tesSUCCESS; @@ -684,11 +678,13 @@ Payment::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool Payment::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelClaim.cpp b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelClaim.cpp index ec2d4dd70d..272100d792 100644 --- a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelClaim.cpp +++ b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelClaim.cpp @@ -55,9 +55,7 @@ PaymentChannelClaim::preflight(PreflightContext const& ctx) return temBAD_AMOUNT; { - auto const flags = ctx.tx.getFlags(); - - if (((flags & tfClose) != 0u) && ((flags & tfRenew) != 0u)) + if (ctx.tx.isFlag(tfClose) && ctx.tx.isFlag(tfRenew)) return temMALFORMED; } @@ -173,7 +171,7 @@ PaymentChannelClaim::doApply() ctx_.view().update(slep); } - if ((ctx_.tx.getFlags() & tfRenew) != 0u) + if (ctx_.tx.isFlag(tfRenew)) { if (src != txAccount) return tecNO_PERMISSION; @@ -181,7 +179,7 @@ PaymentChannelClaim::doApply() ctx_.view().update(slep); } - if ((ctx_.tx.getFlags() & tfClose) != 0u) + if (ctx_.tx.isFlag(tfClose)) { // Channel will close immediately if dry or the receiver closes if (dst == txAccount || (*slep)[sfBalance] == (*slep)[sfAmount]) @@ -207,6 +205,7 @@ PaymentChannelClaim::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -217,6 +216,7 @@ PaymentChannelClaim::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelCreate.cpp b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelCreate.cpp index c86590aa98..13670b7f80 100644 --- a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelCreate.cpp +++ b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelCreate.cpp @@ -96,13 +96,11 @@ PaymentChannelCreate::preclaim(PreclaimContext const& ctx) if (!sled) return tecNO_DST; - auto const flags = sled->getFlags(); - // Check if they have disallowed incoming payment channels - if ((flags & lsfDisallowIncomingPayChan) != 0u) + if (sled->isFlag(lsfDisallowIncomingPayChan)) return tecNO_PERMISSION; - if (((flags & lsfRequireDestTag) != 0u) && !ctx.tx[~sfDestinationTag]) + if (sled->isFlag(lsfRequireDestTag) && !ctx.tx[~sfDestinationTag]) return tecDST_TAG_NEEDED; // Pseudo-accounts cannot receive payment channels, other than native @@ -192,6 +190,7 @@ PaymentChannelCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -202,6 +201,7 @@ PaymentChannelCreate::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelFund.cpp b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelFund.cpp index 4d2590c382..e392df213a 100644 --- a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelFund.cpp +++ b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelFund.cpp @@ -112,6 +112,7 @@ PaymentChannelFund::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -122,6 +123,7 @@ PaymentChannelFund::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } } // namespace xrpl diff --git a/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp index befae454b7..0f62c5d28f 100644 --- a/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp +++ b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp @@ -79,6 +79,7 @@ PermissionedDomainDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -89,6 +90,7 @@ PermissionedDomainDelete::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp index 92f260db4e..83921e8526 100644 --- a/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp +++ b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp @@ -110,12 +110,13 @@ PermissionedDomainSet::doApply() if (balance < reserve) return tecINSUFFICIENT_RESERVE; - Keylet const pdKeylet = - keylet::permissionedDomain(account_, ctx_.tx.getFieldU32(sfSequence)); + bool const fixEnabled = view().rules().enabled(fixCleanup3_1_3); + auto const seq = fixEnabled ? ctx_.tx.getSeqValue() : ctx_.tx.getFieldU32(sfSequence); + Keylet const pdKeylet = keylet::permissionedDomain(account_, seq); auto slePd = std::make_shared(pdKeylet); slePd->setAccountID(sfOwner, account_); - slePd->setFieldU32(sfSequence, ctx_.tx.getFieldU32(sfSequence)); + slePd->setFieldU32(sfSequence, seq); slePd->peekFieldArray(sfAcceptedCredentials) = std::move(sortedLE); auto const page = view().dirInsert(keylet::ownerDir(account_), pdKeylet, describeOwnerDir(account_)); @@ -137,6 +138,7 @@ PermissionedDomainSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -147,6 +149,7 @@ PermissionedDomainSet::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/system/Batch.cpp b/src/libxrpl/tx/transactors/system/Batch.cpp index f9ae9dc912..a278b838b9 100644 --- a/src/libxrpl/tx/transactors/system/Batch.cpp +++ b/src/libxrpl/tx/transactors/system/Batch.cpp @@ -287,7 +287,7 @@ Batch::preflight(PreflightContext const& ctx) return temINVALID_INNER_BATCH; } - if ((stx.getFlags() & tfInnerBatchTxn) == 0u) + if (!stx.isFlag(tfInnerBatchTxn)) { JLOG(ctx.j.debug()) << "BatchTrace[" << parentBatchId << "]: " << "inner txn must have the tfInnerBatchTxn flag. " @@ -523,11 +523,13 @@ Batch::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool Batch::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/system/Change.cpp b/src/libxrpl/tx/transactors/system/Change.cpp index 5f51f935f3..151e7f7256 100644 --- a/src/libxrpl/tx/transactors/system/Change.cpp +++ b/src/libxrpl/tx/transactors/system/Change.cpp @@ -177,10 +177,8 @@ Change::applyAmendment() if (std::ranges::find(amendments, amendment) != amendments.end()) return tefALREADY; - auto flags = ctx_.tx.getFlags(); - - bool const gotMajority = (flags & tfGotMajority) != 0; - bool const lostMajority = (flags & tfLostMajority) != 0; + bool const gotMajority = ctx_.tx.isFlag(tfGotMajority); + bool const lostMajority = ctx_.tx.isFlag(tfLostMajority); if (gotMajority && lostMajority) return temINVALID_FLAG; @@ -416,11 +414,13 @@ Change::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool Change::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp index 2bc71f8c86..2f30311e6f 100644 --- a/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp +++ b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp @@ -78,6 +78,7 @@ LedgerStateFix::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -88,6 +89,7 @@ LedgerStateFix::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/system/TicketCreate.cpp b/src/libxrpl/tx/transactors/system/TicketCreate.cpp index 75095772dd..f690243d86 100644 --- a/src/libxrpl/tx/transactors/system/TicketCreate.cpp +++ b/src/libxrpl/tx/transactors/system/TicketCreate.cpp @@ -140,6 +140,7 @@ TicketCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -150,6 +151,7 @@ TicketCreate::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/token/Clawback.cpp b/src/libxrpl/tx/transactors/token/Clawback.cpp index 8c99ce9b08..99c933d1c4 100644 --- a/src/libxrpl/tx/transactors/token/Clawback.cpp +++ b/src/libxrpl/tx/transactors/token/Clawback.cpp @@ -23,7 +23,6 @@ #include #include -#include #include #include @@ -105,12 +104,9 @@ preclaimHelper( AccountID const& holder, STAmount const& clawAmount) { - std::uint32_t const issuerFlagsIn = sleIssuer.getFieldU32(sfFlags); - // If AllowTrustLineClawback is not set or NoFreeze is set, return no // permission - if (((issuerFlagsIn & lsfAllowTrustLineClawback) == 0u) || - ((issuerFlagsIn & lsfNoFreeze) != 0u)) + if (!sleIssuer.isFlag(lsfAllowTrustLineClawback) || sleIssuer.isFlag(lsfNoFreeze)) return tecNO_PERMISSION; auto const sleRippleState = @@ -163,7 +159,7 @@ preclaimHelper( if (!sleIssuance) return tecOBJECT_NOT_FOUND; - if (((*sleIssuance)[sfFlags] & lsfMPTCanClawback) == 0u) + if (!sleIssuance->isFlag(lsfMPTCanClawback)) return tecNO_PERMISSION; if (sleIssuance->getAccountID(sfIssuer) != issuer) @@ -284,11 +280,13 @@ Clawback::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool Clawback::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp b/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp index c0fbb7f10b..eb1cb04fc7 100644 --- a/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp +++ b/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp @@ -58,7 +58,7 @@ MPTokenAuthorize::preclaim(PreclaimContext const& ctx) // before fetching the MPTIssuance object. // if holder wants to delete/unauthorize a mpt - if ((ctx.tx.getFlags() & tfMPTUnauthorize) != 0u) + if (ctx.tx.isFlag(tfMPTUnauthorize)) { if (!sleMpt) return tecOBJECT_NOT_FOUND; @@ -112,8 +112,6 @@ MPTokenAuthorize::preclaim(PreclaimContext const& ctx) if (!sleMptIssuance) return tecOBJECT_NOT_FOUND; - std::uint32_t const mptIssuanceFlags = sleMptIssuance->getFieldU32(sfFlags); - // If tx is submitted by issuer, they would either try to do the following // for allowlisting: // 1. authorize an account @@ -126,7 +124,7 @@ MPTokenAuthorize::preclaim(PreclaimContext const& ctx) // If tx is submitted by issuer, it only applies for MPT with // lsfMPTRequireAuth set - if ((mptIssuanceFlags & lsfMPTRequireAuth) == 0u) + if (!sleMptIssuance->isFlag(lsfMPTRequireAuth)) return tecNO_AUTH; // The holder must create the MPT before the issuer can authorize it. @@ -162,6 +160,7 @@ MPTokenAuthorize::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -172,6 +171,7 @@ MPTokenAuthorize::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp b/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp index 64652a80b0..430d513670 100644 --- a/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp +++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp @@ -72,7 +72,7 @@ MPTokenIssuanceCreate::preflight(PreflightContext const& ctx) return temMALFORMED; // Domain present implies that MPTokenIssuance is not public - if ((ctx.tx.getFlags() & tfMPTRequireAuth) == 0) + if (!ctx.tx.isFlag(tfMPTRequireAuth)) return temMALFORMED; } @@ -178,6 +178,7 @@ MPTokenIssuanceCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -188,6 +189,7 @@ MPTokenIssuanceCreate::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp b/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp index 80b185641a..be03d78c64 100644 --- a/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp +++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp @@ -64,6 +64,7 @@ MPTokenIssuanceDestroy::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -74,6 +75,7 @@ MPTokenIssuanceDestroy::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp b/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp index fb0ff06ac2..438d7614c5 100644 --- a/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp +++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp @@ -86,10 +86,8 @@ MPTokenIssuanceSet::preflight(PreflightContext const& ctx) if (ctx.tx.isFieldPresent(sfDomainID) && ctx.tx.isFieldPresent(sfHolder)) return temMALFORMED; - auto const txFlags = ctx.tx.getFlags(); - // fails if both flags are set - if (((txFlags & tfMPTLock) != 0u) && ((txFlags & tfMPTUnlock) != 0u)) + if (ctx.tx.isFlag(tfMPTLock) && ctx.tx.isFlag(tfMPTUnlock)) return temINVALID_FLAG; auto const accountID = ctx.tx[sfAccount]; @@ -100,7 +98,7 @@ MPTokenIssuanceSet::preflight(PreflightContext const& ctx) if (ctx.rules.enabled(featureSingleAssetVault) || ctx.rules.enabled(featureDynamicMPT)) { // Is this transaction actually changing anything ? - if (txFlags == 0 && !ctx.tx.isFieldPresent(sfDomainID) && !isMutate) + if (ctx.tx.getFlags() == 0 && !ctx.tx.isFieldPresent(sfDomainID) && !isMutate) return temMALFORMED; } @@ -111,7 +109,7 @@ MPTokenIssuanceSet::preflight(PreflightContext const& ctx) return temMALFORMED; // Can not set flags when mutating MPTokenIssuance - if (isMutate && ((txFlags & tfUniversalMask) != 0u)) + if (isMutate && ((ctx.tx.getFlags() & tfUniversalMask) != 0u)) return temMALFORMED; if (transferFee && *transferFee > kMAX_TRANSFER_FEE) @@ -157,20 +155,18 @@ MPTokenIssuanceSet::checkPermission(ReadView const& view, STTx const& tx) if (isTesSuccess(checkTxPermission(sle, tx))) return tesSUCCESS; - auto const txFlags = tx.getFlags(); - // this is added in case more flags will be added for MPTokenIssuanceSet // in the future. Currently unreachable. - if ((txFlags & tfMPTokenIssuanceSetMask) != 0u) + if ((tx.getFlags() & tfMPTokenIssuanceSetMask) != 0u) return terNO_DELEGATE_PERMISSION; // LCOV_EXCL_LINE std::unordered_set granularPermissions; loadGranularPermission(sle, ttMPTOKEN_ISSUANCE_SET, granularPermissions); - if (((txFlags & tfMPTLock) != 0u) && !granularPermissions.contains(MPTokenIssuanceLock)) + if (tx.isFlag(tfMPTLock) && !granularPermissions.contains(MPTokenIssuanceLock)) return terNO_DELEGATE_PERMISSION; - if (((txFlags & tfMPTUnlock) != 0u) && !granularPermissions.contains(MPTokenIssuanceUnlock)) + if (tx.isFlag(tfMPTUnlock) && !granularPermissions.contains(MPTokenIssuanceUnlock)) return terNO_DELEGATE_PERMISSION; return tesSUCCESS; @@ -273,7 +269,6 @@ TER MPTokenIssuanceSet::doApply() { auto const mptIssuanceID = ctx_.tx[sfMPTokenIssuanceID]; - auto const txFlags = ctx_.tx.getFlags(); auto const holderID = ctx_.tx[~sfHolder]; auto const domainID = ctx_.tx[~sfDomainID]; std::shared_ptr sle; @@ -293,11 +288,11 @@ MPTokenIssuanceSet::doApply() std::uint32_t const flagsIn = sle->getFieldU32(sfFlags); std::uint32_t flagsOut = flagsIn; - if ((txFlags & tfMPTLock) != 0u) + if (ctx_.tx.isFlag(tfMPTLock)) { flagsOut |= lsfMPTLocked; } - else if ((txFlags & tfMPTUnlock) != 0u) + else if (ctx_.tx.isFlag(tfMPTUnlock)) { flagsOut &= ~lsfMPTLocked; } @@ -384,6 +379,7 @@ MPTokenIssuanceSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -394,6 +390,7 @@ MPTokenIssuanceSet::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/token/TrustSet.cpp b/src/libxrpl/tx/transactors/token/TrustSet.cpp index 27252aef46..d260281304 100644 --- a/src/libxrpl/tx/transactors/token/TrustSet.cpp +++ b/src/libxrpl/tx/transactors/token/TrustSet.cpp @@ -78,13 +78,11 @@ TrustSet::preflight(PreflightContext const& ctx) auto& tx = ctx.tx; auto& j = ctx.j; - std::uint32_t const uTxFlags = tx.getFlags(); - if (!ctx.rules.enabled(featureDeepFreeze)) { // Even though the deep freeze flags are included in the // `tfTrustSetMask`, they are not valid if the amendment is not enabled. - if ((uTxFlags & (tfSetDeepFreeze | tfClearDeepFreeze)) != 0u) + if ((tx.getFlags() & (tfSetDeepFreeze | tfClearDeepFreeze)) != 0u) { return temINVALID_FLAG; } @@ -142,12 +140,10 @@ TrustSet::checkPermission(ReadView const& view, STTx const& tx) if (isTesSuccess(checkTxPermission(sle, tx))) return tesSUCCESS; - std::uint32_t const txFlags = tx.getFlags(); - // Currently we only support TrustlineAuthorize, TrustlineFreeze and // TrustlineUnfreeze granular permission. Setting other flags returns // error. - if ((txFlags & tfTrustSetPermissionMask) != 0u) + if ((tx.getFlags() & tfTrustSetPermissionMask) != 0u) return terNO_DELEGATE_PERMISSION; if (tx.isFieldPresent(sfQualityIn) || tx.isFieldPresent(sfQualityOut)) @@ -166,11 +162,11 @@ TrustSet::checkPermission(ReadView const& view, STTx const& tx) std::unordered_set granularPermissions; loadGranularPermission(sle, ttTRUST_SET, granularPermissions); - if (((txFlags & tfSetfAuth) != 0u) && !granularPermissions.contains(TrustlineAuthorize)) + if (tx.isFlag(tfSetfAuth) && !granularPermissions.contains(TrustlineAuthorize)) return terNO_DELEGATE_PERMISSION; - if (((txFlags & tfSetFreeze) != 0u) && !granularPermissions.contains(TrustlineFreeze)) + if (tx.isFlag(tfSetFreeze) && !granularPermissions.contains(TrustlineFreeze)) return terNO_DELEGATE_PERMISSION; - if (((txFlags & tfClearFreeze) != 0u) && !granularPermissions.contains(TrustlineUnfreeze)) + if (tx.isFlag(tfClearFreeze) && !granularPermissions.contains(TrustlineUnfreeze)) return terNO_DELEGATE_PERMISSION; // updating LimitAmount is not allowed only with granular permissions, @@ -197,11 +193,9 @@ TrustSet::preclaim(PreclaimContext const& ctx) if (!sle) return terNO_ACCOUNT; - std::uint32_t const uTxFlags = ctx.tx.getFlags(); + bool const bSetAuth = ctx.tx.isFlag(tfSetfAuth); - bool const bSetAuth = (uTxFlags & tfSetfAuth) != 0u; - - if (bSetAuth && ((sle->getFieldU32(sfFlags) & lsfRequireAuth) == 0u)) + if (bSetAuth && !sle->isFlag(lsfRequireAuth)) { JLOG(ctx.j.trace()) << "Retry: Auth not required."; return tefNO_AUTH_REQUIRED; @@ -223,7 +217,7 @@ TrustSet::preclaim(PreclaimContext const& ctx) // If the destination has opted to disallow incoming trustlines // then honour that flag - if ((sleDst->getFlags() & lsfDisallowIncomingTrustline) != 0u) + if (sleDst->isFlag(lsfDisallowIncomingTrustline)) { // The original implementation of featureDisallowIncoming was // too restrictive. If @@ -288,8 +282,8 @@ TrustSet::preclaim(PreclaimContext const& ctx) if (ctx.view.rules().enabled(featureDeepFreeze)) { bool const bNoFreeze = sle->isFlag(lsfNoFreeze); - bool const bSetFreeze = (uTxFlags & tfSetFreeze) != 0u; - bool const bSetDeepFreeze = (uTxFlags & tfSetDeepFreeze) != 0u; + bool const bSetFreeze = ctx.tx.isFlag(tfSetFreeze); + bool const bSetDeepFreeze = ctx.tx.isFlag(tfSetDeepFreeze); if (bNoFreeze && (bSetFreeze || bSetDeepFreeze)) { @@ -297,8 +291,8 @@ TrustSet::preclaim(PreclaimContext const& ctx) return tecNO_PERMISSION; } - bool const bClearFreeze = (uTxFlags & tfClearFreeze) != 0u; - bool const bClearDeepFreeze = (uTxFlags & tfClearDeepFreeze) != 0u; + bool const bClearFreeze = ctx.tx.isFlag(tfClearFreeze); + bool const bClearDeepFreeze = ctx.tx.isFlag(tfClearDeepFreeze); if ((bSetFreeze || bSetDeepFreeze) && (bClearFreeze || bClearDeepFreeze)) { // Freezing and unfreezing in the same transaction should be @@ -378,15 +372,13 @@ TrustSet::doApply() if (bQualityOut && QUALITY_ONE == uQualityOut) uQualityOut = 0; - std::uint32_t const uTxFlags = ctx_.tx.getFlags(); - - bool const bSetAuth = (uTxFlags & tfSetfAuth) != 0u; - bool const bSetNoRipple = (uTxFlags & tfSetNoRipple) != 0u; - bool const bClearNoRipple = (uTxFlags & tfClearNoRipple) != 0u; - bool const bSetFreeze = (uTxFlags & tfSetFreeze) != 0u; - bool const bClearFreeze = (uTxFlags & tfClearFreeze) != 0u; - bool const bSetDeepFreeze = (uTxFlags & tfSetDeepFreeze) != 0u; - bool const bClearDeepFreeze = (uTxFlags & tfClearDeepFreeze) != 0u; + bool const bSetAuth = ctx_.tx.isFlag(tfSetfAuth); + bool const bSetNoRipple = ctx_.tx.isFlag(tfSetNoRipple); + bool const bClearNoRipple = ctx_.tx.isFlag(tfClearNoRipple); + bool const bSetFreeze = ctx_.tx.isFlag(tfSetFreeze); + bool const bClearFreeze = ctx_.tx.isFlag(tfClearFreeze); + bool const bSetDeepFreeze = ctx_.tx.isFlag(tfSetDeepFreeze); + bool const bClearDeepFreeze = ctx_.tx.isFlag(tfClearDeepFreeze); auto viewJ = ctx_.registry.get().getJournal("View"); @@ -538,8 +530,8 @@ TrustSet::doApply() if (QUALITY_ONE == uHighQualityOut) uHighQualityOut = 0; - bool const bLowDefRipple = (sleLowAccount->getFlags() & lsfDefaultRipple) != 0u; - bool const bHighDefRipple = (sleHighAccount->getFlags() & lsfDefaultRipple) != 0u; + bool const bLowDefRipple = sleLowAccount->isFlag(lsfDefaultRipple); + bool const bHighDefRipple = sleHighAccount->isFlag(lsfDefaultRipple); bool const bLowReserveSet = (uLowQualityIn != 0u) || (uLowQualityOut != 0u) || ((uFlagsOut & lsfLowNoRipple) == 0) != bLowDefRipple || @@ -553,8 +545,8 @@ TrustSet::doApply() bool const bDefault = bLowReserveClear && bHighReserveClear; - bool const bLowReserved = (uFlagsIn & lsfLowReserve) != 0u; - bool const bHighReserved = (uFlagsIn & lsfHighReserve) != 0u; + bool const bLowReserved = sleRippleState->isFlag(lsfLowReserve); + bool const bHighReserved = sleRippleState->isFlag(lsfHighReserve); bool bReserveIncrease = false; @@ -682,11 +674,13 @@ TrustSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool TrustSet::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/vault/VaultClawback.cpp b/src/libxrpl/tx/transactors/vault/VaultClawback.cpp index 8743227e5c..8bd8e6112e 100644 --- a/src/libxrpl/tx/transactors/vault/VaultClawback.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultClawback.cpp @@ -26,7 +26,6 @@ #include #include -#include #include #include #include @@ -186,8 +185,7 @@ VaultClawback::preclaim(PreclaimContext const& ctx) if (mptIssue == nullptr) return tecOBJECT_NOT_FOUND; - std::uint32_t const issueFlags = mptIssue->getFieldU32(sfFlags); - if ((issueFlags & lsfMPTCanClawback) == 0u) + if (!mptIssue->isFlag(lsfMPTCanClawback)) { JLOG(ctx.j.debug()) << "VaultClawback: cannot clawback " "MPT vault asset."; @@ -206,9 +204,7 @@ VaultClawback::preclaim(PreclaimContext const& ctx) // LCOV_EXCL_STOP } - std::uint32_t const issuerFlags = issuerSle->getFieldU32(sfFlags); - if (((issuerFlags & lsfAllowTrustLineClawback) == 0u) || - ((issuerFlags & lsfNoFreeze) != 0u)) + if (!issuerSle->isFlag(lsfAllowTrustLineClawback) || issuerSle->isFlag(lsfNoFreeze)) { JLOG(ctx.j.debug()) << "VaultClawback: cannot clawback " "IOU vault asset."; @@ -243,11 +239,11 @@ VaultClawback::assetsToClawback( auto const mptIssuanceID = *vault->at(sfShareMPTID); MPTIssue const share{mptIssuanceID}; - // Pre-fixSecurity3_1_3: zero-amount clawback returned early without + // Pre-fixCleanup3_1_3: zero-amount clawback returned early without // clamping to assetsAvailable, allowing more assets to be recovered // than available when there was an outstanding loan. Retained for // ledger replay compatibility. - if (!ctx_.view().rules().enabled(fixSecurity3_1_3) && clawbackAmount == beast::kZERO) + if (!ctx_.view().rules().enabled(fixCleanup3_1_3) && clawbackAmount == beast::kZERO) { auto const sharesDestroyed = accountHolds( view(), holder, share, FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, j_); @@ -461,6 +457,7 @@ VaultClawback::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -471,6 +468,7 @@ VaultClawback::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/vault/VaultCreate.cpp b/src/libxrpl/tx/transactors/vault/VaultCreate.cpp index 0346503ae7..ca7d0cc5fa 100644 --- a/src/libxrpl/tx/transactors/vault/VaultCreate.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultCreate.cpp @@ -68,7 +68,7 @@ VaultCreate::preflight(PreflightContext const& ctx) { return temMALFORMED; } - if ((ctx.tx.getFlags() & tfVaultPrivate) == 0) + if (!ctx.tx.isFlag(tfVaultPrivate)) { return temMALFORMED; // DomainID only allowed on private vaults } @@ -173,11 +173,10 @@ VaultCreate::doApply() ? 0 : ctx_.tx[~sfScale].value_or(kVAULT_DEFAULT_IOU_SCALE); - auto txFlags = tx.getFlags(); std::uint32_t mptFlags = 0; - if ((txFlags & tfVaultShareNonTransferable) == 0) + if (!tx.isFlag(tfVaultShareNonTransferable)) mptFlags |= (lsfMPTCanEscrow | lsfMPTCanTrade | lsfMPTCanTransfer); - if ((txFlags & tfVaultPrivate) != 0u) + if (tx.isFlag(tfVaultPrivate)) mptFlags |= lsfMPTRequireAuth; // Note, here we are **not** creating an MPToken for the assets held in @@ -203,7 +202,7 @@ VaultCreate::doApply() auto const& mptIssuanceID = *maybeShare; vault->setFieldIssue(sfAsset, STIssue{sfAsset, asset}); - vault->at(sfFlags) = txFlags & tfVaultPrivate; + vault->at(sfFlags) = tx.getFlags() & tfVaultPrivate; vault->at(sfSequence) = sequence; vault->at(sfOwner) = account_; vault->at(sfAccount) = pseudoId; @@ -236,7 +235,7 @@ VaultCreate::doApply() return err; // If the vault is private, set the authorized flag for the vault owner - if ((txFlags & tfVaultPrivate) != 0u) + if (tx.isFlag(tfVaultPrivate)) { if (auto const err = authorizeMPToken( view(), preFeeBalance_, mptIssuanceID, pseudoId, ctx_.journal, {}, account_); @@ -255,11 +254,13 @@ VaultCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool VaultCreate::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/vault/VaultDelete.cpp b/src/libxrpl/tx/transactors/vault/VaultDelete.cpp index 58b0fdee82..20415b7816 100644 --- a/src/libxrpl/tx/transactors/vault/VaultDelete.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultDelete.cpp @@ -218,11 +218,13 @@ VaultDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool VaultDelete::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp b/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp index 501ba58ca5..4b8d8b5c18 100644 --- a/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp @@ -284,6 +284,7 @@ VaultDeposit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -294,6 +295,7 @@ VaultDeposit::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/vault/VaultSet.cpp b/src/libxrpl/tx/transactors/vault/VaultSet.cpp index 92dbb198f3..684413399d 100644 --- a/src/libxrpl/tx/transactors/vault/VaultSet.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultSet.cpp @@ -103,7 +103,7 @@ VaultSet::preclaim(PreclaimContext const& ctx) } // Sanity check only, this should be enforced by VaultCreate - if ((sleIssuance->getFlags() & lsfMPTRequireAuth) == 0) + if (!sleIssuance->isFlag(lsfMPTRequireAuth)) { // LCOV_EXCL_START JLOG(ctx.j.error()) << "VaultSet: issuance of vault shares is not private."; @@ -185,11 +185,13 @@ VaultSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool VaultSet::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp b/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp index 6932dc21f2..5b4949ccf6 100644 --- a/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp @@ -80,9 +80,9 @@ VaultWithdraw::preclaim(PreclaimContext const& ctx) // LCOV_EXCL_STOP } - if (ctx.view.rules().enabled(fixSecurity3_1_3) && amount.asset() == vaultShare) + if (ctx.view.rules().enabled(fixCleanup3_1_3) && amount.asset() == vaultShare) { - // Post-fixSecurity3_1_3: if the user specified shares, convert + // Post-fixCleanup3_1_3: if the user specified shares, convert // to the equivalent asset amount before checking withdrawal // limits. Pre-amendment the limit check was skipped for // share-denominated withdrawals. @@ -297,6 +297,7 @@ VaultWithdraw::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -307,6 +308,7 @@ VaultWithdraw::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/test/app/AMMExtendedMPT_test.cpp b/src/test/app/AMMExtendedMPT_test.cpp index 47afaafe5d..34c9044c6d 100644 --- a/src/test/app/AMMExtendedMPT_test.cpp +++ b/src/test/app/AMMExtendedMPT_test.cpp @@ -437,7 +437,7 @@ private: env(offer(dan, XRP(500), eth(50'000'000'000'000))); env.close(); - json::Value jtp{json::ArrayValue}; + json::Value jtp{json::ValueType::Array}; jtp[0u][0u][jss::currency] = "XRP"; env(pay(alice_, bob_, eth(30'000'000'000'000)), Json(jss::Paths, jtp), @@ -621,7 +621,7 @@ private: env.current()->read(keylet::account(bob_.id()))->getFieldU32(sfSequence); payment[jss::tx_json][jss::Fee] = to_string(env.current()->fees().base); payment[jss::tx_json][jss::SendMax] = - xts(15'000'000'000'000).value().getJson(JsonOptions::KNone); + xts(15'000'000'000'000).value().getJson(JsonOptions::Values::None); payment[jss::tx_json][jss::Flags] = tfPartialPayment; auto const jrr = env.rpc("json", "submit", to_string(payment)); BEAST_EXPECT(jrr[jss::result][jss::status] == "success"); diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp index 8132c012ad..69514fe77b 100644 --- a/src/test/app/AMMExtended_test.cpp +++ b/src/test/app/AMMExtended_test.cpp @@ -506,7 +506,7 @@ private: env(offer(dan, XRP(500), euR1(50))); env.close(); - json::Value jtp{json::ArrayValue}; + json::Value jtp{json::ValueType::Array}; jtp[0u][0u][jss::currency] = "XRP"; env(pay(alice_, bob_, euR1(30)), Json(jss::Paths, jtp), Sendmax(usD1(333))); env.close(); @@ -681,7 +681,8 @@ private: payment[jss::tx_json][jss::Sequence] = env.current()->read(keylet::account(bob_.id()))->getFieldU32(sfSequence); payment[jss::tx_json][jss::Fee] = to_string(env.current()->fees().base); - payment[jss::tx_json][jss::SendMax] = bob_["XTS"](1.5).value().getJson(JsonOptions::KNone); + payment[jss::tx_json][jss::SendMax] = + bob_["XTS"](1.5).value().getJson(JsonOptions::Values::None); payment[jss::tx_json][jss::Flags] = tfPartialPayment; auto const jrr = env.rpc("json", "submit", to_string(payment)); BEAST_EXPECT(jrr[jss::result][jss::status] == "success"); @@ -3084,12 +3085,14 @@ private: // Is cleared via a TrustSet with ClearFreeze flag // test: sets LowFreeze | HighFreeze flags env(trust(g1, bob["USD"](0), tfClearFreeze)); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 2u))) return; auto ff = affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName]; BEAST_EXPECT( - ff[sfLowLimit.fieldName] == g1["USD"](0).value().getJson(JsonOptions::KNone)); + ff[sfLowLimit.fieldName] == + g1["USD"](0).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfLowFreeze)); BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighFreeze)); env.close(); diff --git a/src/test/app/AMMMPT_test.cpp b/src/test/app/AMMMPT_test.cpp index 736ba4ff68..8437d69356 100644 --- a/src/test/app/AMMMPT_test.cpp +++ b/src/test/app/AMMMPT_test.cpp @@ -411,13 +411,14 @@ private: // LPTokenOut can not be MPT { - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::Account] = alice_.human(); jv[jss::TransactionType] = jss::AMMDeposit; - jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::Values::None); jv[jss::Asset2] = - STIssue(sfAsset, MPT(ammAlice[1])).getJson(JsonOptions::KNone); - jv[jss::LPTokenOut] = MPT(ammAlice[1])(100).value().getJson(JsonOptions::KNone); + STIssue(sfAsset, MPT(ammAlice[1])).getJson(JsonOptions::Values::None); + jv[jss::LPTokenOut] = + MPT(ammAlice[1])(100).value().getJson(JsonOptions::Values::None); jv[jss::Flags] = tfLPToken; env(jv, Ter(telENV_RPC_FAILED)); } @@ -425,13 +426,13 @@ private: // Provided LPTokenOut does not match AMM pool's LPToken // asset { - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::Account] = alice_.human(); jv[jss::TransactionType] = jss::AMMDeposit; - jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::Values::None); jv[jss::Asset2] = - STIssue(sfAsset, MPT(ammAlice[1])).getJson(JsonOptions::KNone); - jv[jss::LPTokenOut] = USD(100).value().getJson(JsonOptions::KNone); + STIssue(sfAsset, MPT(ammAlice[1])).getJson(JsonOptions::Values::None); + jv[jss::LPTokenOut] = USD(100).value().getJson(JsonOptions::Values::None); jv[jss::Flags] = tfLPToken; env(jv, Ter(temBAD_AMM_TOKENS)); } @@ -6255,7 +6256,8 @@ private: amm.deposit(carol_, 1'000); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; try { bool found = false; diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp index 8e2c0255ef..fc8b42f27f 100644 --- a/src/test/app/AMM_test.cpp +++ b/src/test/app/AMM_test.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -552,11 +553,11 @@ private: { // bad preflight1 - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::Account] = alice_.human(); jv[jss::TransactionType] = jss::AMMDeposit; - jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, USD).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, USD).getJson(JsonOptions::Values::None); jv[jss::Fee] = "-1"; env(jv, Ter(temBAD_FEE)); } @@ -567,12 +568,12 @@ private: alice_, IOUAmount{-1}, std::nullopt, std::nullopt, Ter(temBAD_AMM_TOKENS)); { - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::Account] = alice_.human(); jv[jss::TransactionType] = jss::AMMDeposit; - jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, USD).getJson(JsonOptions::KNone); - jv[jss::LPTokenOut] = USD(100).value().getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, XRP).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, USD).getJson(JsonOptions::Values::None); + jv[jss::LPTokenOut] = USD(100).value().getJson(JsonOptions::Values::None); jv[jss::Flags] = tfLPToken; env(jv, Ter(temBAD_AMM_TOKENS)); } @@ -5215,7 +5216,8 @@ private: fail(); } amm.deposit(carol_, 1'000); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; try { bool found = false; @@ -7080,6 +7082,95 @@ private: {all}); } + void + testStaleAuthAccountsAfterReinit(FeatureBitset features) + { + testcase("Test AuthAccounts reset after empty pool reinitialization"); + using namespace jtx; + + Env env( + *this, + envconfig([](std::unique_ptr cfg) { + cfg->FEES.reference_fee = XRPAmount(1); + return cfg; + }), + features); + Account const dan("dan"); + Account const ed("ed"); + fund(env, gw_, {alice_, carol_, bob_, dan, ed}, XRP(50'000), {USD(50'000)}); + AMM amm(env, alice_, XRP(10'000), USD(10'000)); + // Create excess trustlines to prevent AMM auto-deletion on withdrawal. + for (auto i = 0; i < kMAX_DELETABLE_AMM_TRUST_LINES + 10; ++i) + { + Account const a{std::to_string(i)}; + env.fund(XRP(1'000), a); + env(trust(a, STAmount{amm.lptIssue(), 10'000})); + env.close(); + } + // Carol deposits so she has LP tokens to bid. + amm.deposit(carol_, 1'000'000); + // Carol wins the auction slot, authorizing bob and dan. + env(amm.bid({ + .account = carol_, + .bidMin = 100, + .authAccounts = {bob_, dan}, + })); + env.close(); + BEAST_EXPECT(amm.expectAuctionSlot({bob_.id(), dan.id()})); + // Withdraw all — AMM enters empty state but is not deleted because + // excess trustlines prevent auto-deletion. + amm.withdrawAll(alice_); + amm.withdrawAll(carol_); + BEAST_EXPECT(amm.ammExists()); + // Pre-conditions before re-init: AMM is empty and stale sfAuthAccounts + // from carol's bid are still present. + BEAST_EXPECT(amm.getLPTokensBalance() == IOUAmount{0}); + BEAST_EXPECT(amm.expectAuctionSlot({bob_.id(), dan.id()})); + // Ed re-initializes the AMM via tfTwoAssetIfEmpty with fee=500. + amm.deposit( + ed, + std::nullopt, + XRP(10'000), + USD(10'000), + std::nullopt, + tfTwoAssetIfEmpty, + std::nullopt, + std::nullopt, + 500); + + auto const ammSle = env.current()->read(keylet::amm(amm[0], amm[1])); + BEAST_EXPECT(ammSle && ammSle->isFieldPresent(sfAuctionSlot)); + auto const& slot = safeDowncast(ammSle->peekAtField(sfAuctionSlot)); + + // sfDiscountedFee = 500 / AUCTION_SLOT_DISCOUNTED_FEE_FRACTION = 50, + // sfPrice = 0 (reset on init), time interval = 0 (freshly issued slot). + BEAST_EXPECT(amm.expectAuctionSlot(50, 0, IOUAmount{0})); + // sfAccount must be the re-initializing depositor, not the previous + // slot holder (carol). + BEAST_EXPECT(slot[sfAccount] == ed.id()); + // sfTradingFee on the AMM SLE must reflect ed's deposit fee. + BEAST_EXPECT(ammSle->getFieldU16(sfTradingFee) == 500); + // sfVoteSlots must be reset to a single entry for ed. + auto const& votes = ammSle->getFieldArray(sfVoteSlots); + BEAST_EXPECT(votes.size() == 1); + if (!votes.empty()) + { + BEAST_EXPECT(votes[0].getAccountID(sfAccount) == ed.id()); + BEAST_EXPECT(votes[0].getFieldU16(sfTradingFee) == 500); + BEAST_EXPECT(votes[0].getFieldU32(sfVoteWeight) == kVOTE_WEIGHT_SCALE_FACTOR); + } + // sfAuthAccounts behaviour depends on the fix. + if (features[fixCleanup3_2_0]) + { + BEAST_EXPECT(!slot.isFieldPresent(sfAuthAccounts)); + } + else + { + BEAST_EXPECT( + slot.isFieldPresent(sfAuthAccounts) && !slot.getFieldArray(sfAuthAccounts).empty()); + } + } + void run() override { @@ -7150,6 +7241,8 @@ private: testWithdrawRounding(all); testWithdrawRounding(all - fixAMMv1_3); testFailedPseudoAccount(); + testStaleAuthAccountsAfterReinit(all); + testStaleAuthAccountsAfterReinit(all - fixCleanup3_2_0); } }; diff --git a/src/test/app/AccountDelete_test.cpp b/src/test/app/AccountDelete_test.cpp index a30691b175..3ad931cfa6 100644 --- a/src/test/app/AccountDelete_test.cpp +++ b/src/test/app/AccountDelete_test.cpp @@ -57,7 +57,8 @@ private: verifyDeliveredAmount(jtx::Env& env, STAmount const& amount) { // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; // Verify DeliveredAmount and delivered_amount metadata are correct. // We can't use env.meta() here, because meta() doesn't include @@ -71,7 +72,7 @@ private: // DeliveredAmount and delivered_amount should both be present and // equal amount. - json::Value const jsonExpect{amount.getJson(JsonOptions::KNone)}; + json::Value const jsonExpect{amount.getJson(JsonOptions::Values::None)}; BEAST_EXPECT(meta[sfDeliveredAmount.jsonName] == jsonExpect); BEAST_EXPECT(meta[jss::delivered_amount] == jsonExpect); } @@ -90,7 +91,7 @@ private: jv[jss::TransactionType] = jss::PaymentChannelCreate; jv[jss::Account] = account.human(); jv[jss::Destination] = to.human(); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); jv[sfSettleDelay.jsonName] = settleDelay.count(); jv[sfCancelAfter.jsonName] = cancelAfter.time_since_epoch().count() + 2; jv[sfPublicKey.jsonName] = strHex(pk.slice()); diff --git a/src/test/app/AccountTxPaging_test.cpp b/src/test/app/AccountTxPaging_test.cpp index 6697be44e0..30ea780eef 100644 --- a/src/test/app/AccountTxPaging_test.cpp +++ b/src/test/app/AccountTxPaging_test.cpp @@ -30,7 +30,7 @@ class AccountTxPaging_test : public beast::unit_test::Suite int ledgerMax, int limit, bool forward, - json::Value const& marker = json::NullValue) + json::Value const& marker = json::ValueType::Null) { json::Value jvc; jvc[jss::account] = account.human(); diff --git a/src/test/app/Batch_test.cpp b/src/test/app/Batch_test.cpp index 8010b1e120..bff8d76cb1 100644 --- a/src/test/app/Batch_test.cpp +++ b/src/test/app/Batch_test.cpp @@ -388,8 +388,8 @@ class Batch_test : public beast::unit_test::Suite auto const seq = env.seq(alice); auto const batchFee = batch::calcBatchFee(env, 0, 2); auto tx1 = pay(alice, bob, XRP(1)); - tx1[sfSigners.jsonName] = json::ArrayValue; - tx1[sfSigners.jsonName][0U][sfSigner.jsonName] = json::ObjectValue; + tx1[sfSigners.jsonName] = json::ValueType::Array; + tx1[sfSigners.jsonName][0U][sfSigner.jsonName] = json::ValueType::Object; tx1[sfSigners.jsonName][0U][sfSigner.jsonName][sfAccount.jsonName] = alice.human(); tx1[sfSigners.jsonName][0U][sfSigner.jsonName][sfSigningPubKey.jsonName] = strHex(alice.pk()); @@ -1363,8 +1363,8 @@ class Batch_test : public beast::unit_test::Suite auto const ammCreate = [&alice](STAmount const& amount, STAmount const& amount2) { json::Value jv; jv[jss::Account] = alice.human(); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); - jv[jss::Amount2] = amount2.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); + jv[jss::Amount2] = amount2.getJson(JsonOptions::Values::None); jv[jss::TradingFee] = 0; jv[jss::TransactionType] = jss::AMMCreate; return jv; @@ -2346,7 +2346,7 @@ class Batch_test : public beast::unit_test::Suite // + has `tfInnerBatchTxn` flag { auto txn = batch::Inner(pay(alice, bob, XRP(1)), env.seq(alice)); - txn[sfSigners] = json::ArrayValue; + txn[sfSigners] = json::ValueType::Array; STParsedJSONObject parsed("test", txn.getTxn()); Serializer s; parsed.object->add(s); // NOLINT(bugprone-unchecked-optional-access) @@ -2401,7 +2401,7 @@ class Batch_test : public beast::unit_test::Suite obj.setFieldU32(sfLedgerSequence, seq); obj.setFieldU32(sfFlags, tfInnerBatchTxn); }); - auto txn = batch::Inner(amendTx.getJson(JsonOptions::KNone), env.seq(alice)); + auto txn = batch::Inner(amendTx.getJson(JsonOptions::Values::None), env.seq(alice)); STParsedJSONObject parsed("test", txn.getTxn()); Serializer s; parsed.object->add(s); // NOLINT(bugprone-unchecked-optional-access) @@ -3784,7 +3784,7 @@ class Batch_test : public beast::unit_test::Suite makeSmallQueueConfig({{"minimum_txn_in_ledger_standalone", "2"}}), features, nullptr, - beast::severities::KError}; + beast::Severity::Error}; auto alice = Account("alice"); auto bob = Account("bob"); @@ -3840,7 +3840,7 @@ class Batch_test : public beast::unit_test::Suite makeSmallQueueConfig({{"minimum_txn_in_ledger_standalone", "2"}}), features, nullptr, - beast::severities::KError}; + beast::Severity::Error}; auto alice = Account("alice"); auto bob = Account("bob"); @@ -3885,7 +3885,7 @@ class Batch_test : public beast::unit_test::Suite using namespace test::jtx; using namespace std::literals; - Env env(*this, envconfig(), features, nullptr, beast::severities::KDisabled); + Env env(*this, envconfig(), features, nullptr, beast::Severity::Disabled); auto alice = Account("alice"); auto bob = Account("bob"); diff --git a/src/test/app/CheckMPT_test.cpp b/src/test/app/CheckMPT_test.cpp index 6fb10807c2..b7269395b5 100644 --- a/src/test/app/CheckMPT_test.cpp +++ b/src/test/app/CheckMPT_test.cpp @@ -73,7 +73,8 @@ class CheckMPT_test : public beast::unit_test::Suite verifyDeliveredAmount(test::jtx::Env& env, STAmount const& amount) { // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; // Verify DeliveredAmount and delivered_amount metadata are correct. env.close(); @@ -85,8 +86,8 @@ class CheckMPT_test : public beast::unit_test::Suite // DeliveredAmount and delivered_amount should both be present and // equal amount. - BEAST_EXPECT(meta[sfDeliveredAmount.jsonName] == amount.getJson(JsonOptions::KNone)); - BEAST_EXPECT(meta[jss::delivered_amount] == amount.getJson(JsonOptions::KNone)); + BEAST_EXPECT(meta[sfDeliveredAmount.jsonName] == amount.getJson(JsonOptions::Values::None)); + BEAST_EXPECT(meta[jss::delivered_amount] == amount.getJson(JsonOptions::Values::None)); } void @@ -928,7 +929,7 @@ class CheckMPT_test : public beast::unit_test::Suite // Both Amount and DeliverMin present. { json::Value tx{check::cash(bob, chkId, amount)}; - tx[sfDeliverMin.jsonName] = amount.getJson(JsonOptions::KNone); + tx[sfDeliverMin.jsonName] = amount.getJson(JsonOptions::Values::None); env(tx, Ter(temMALFORMED)); env.close(); } diff --git a/src/test/app/Check_test.cpp b/src/test/app/Check_test.cpp index ad44ff5729..1d5861136c 100644 --- a/src/test/app/Check_test.cpp +++ b/src/test/app/Check_test.cpp @@ -77,7 +77,8 @@ class Check_test : public beast::unit_test::Suite verifyDeliveredAmount(test::jtx::Env& env, STAmount const& amount) { // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; // Verify DeliveredAmount and delivered_amount metadata are correct. env.close(); @@ -89,8 +90,8 @@ class Check_test : public beast::unit_test::Suite // DeliveredAmount and delivered_amount should both be present and // equal amount. - BEAST_EXPECT(meta[sfDeliveredAmount.jsonName] == amount.getJson(JsonOptions::KNone)); - BEAST_EXPECT(meta[jss::delivered_amount] == amount.getJson(JsonOptions::KNone)); + BEAST_EXPECT(meta[sfDeliveredAmount.jsonName] == amount.getJson(JsonOptions::Values::None)); + BEAST_EXPECT(meta[jss::delivered_amount] == amount.getJson(JsonOptions::Values::None)); } void @@ -1326,7 +1327,7 @@ class Check_test : public beast::unit_test::Suite // Both Amount and DeliverMin present. { json::Value tx{check::cash(bob, chkId, amount)}; - tx[sfDeliverMin.jsonName] = amount.getJson(JsonOptions::KNone); + tx[sfDeliverMin.jsonName] = amount.getJson(JsonOptions::Values::None); env(tx, Ter(temMALFORMED)); env.close(); } @@ -1727,7 +1728,8 @@ class Check_test : public beast::unit_test::Suite env(check::cash(bob, chkId, check::DeliverMin(XRP(100)))); // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; env.close(); json::Value const meta = env.rpc("tx", txHash)[jss::result][jss::meta]; diff --git a/src/test/app/Credentials_test.cpp b/src/test/app/Credentials_test.cpp index fa180d0603..ec0ea0beae 100644 --- a/src/test/app/Credentials_test.cpp +++ b/src/test/app/Credentials_test.cpp @@ -5,9 +5,12 @@ #include #include #include +#include #include #include #include +#include +#include #include #include #include @@ -24,11 +27,13 @@ #include #include #include +#include #include #include #include #include +#include #include #include @@ -137,7 +142,7 @@ struct Credentials_test : public beast::unit_test::Suite BEAST_EXPECT(sleCred->getAccountID(sfSubject) == issuer.id()); BEAST_EXPECT(sleCred->getAccountID(sfIssuer) == issuer.id()); - BEAST_EXPECT((sleCred->getFieldU32(sfFlags) & lsfAccepted)); + BEAST_EXPECT(sleCred->isFlag(lsfAccepted)); BEAST_EXPECT( sleCred->getFieldU64(sfIssuerNode) == sleCred->getFieldU64(sfSubjectNode)); BEAST_EXPECT(ownerCount(env, issuer) == 1); @@ -1028,6 +1033,121 @@ struct Credentials_test : public beast::unit_test::Suite } } + void + testRemoveExpiredCorruption(FeatureBitset features) + { + bool const fixEnabled = features[fixCleanup3_1_3]; + testcase( + "removeExpired ignores deleteSLE failure " + + (fixEnabled ? std::string(" after fix") : std::string(" before fix"))); + + using namespace test::jtx; + + char const credType[] = "abcde"; + Account const issuer{"issuer"}; + Account const subject{"subject"}; + Account const becky{"becky"}; + + Env env{*this, features}; + env.fund(XRP(10000), issuer, subject, becky); + env.close(); + + // Create credential with short expiration + auto jv = credentials::create(subject, issuer, credType); + uint32_t const expiration = + env.current()->header().parentCloseTime.time_since_epoch().count() + 40; + jv[sfExpiration.jsonName] = expiration; + env(jv); + env.close(); + + auto const credLE = credentials::ledgerEntry(env, subject, issuer, credType); + std::string const credIdx = credLE[jss::result][jss::index].asString(); + + // Subject accepts the credential + env(credentials::accept(subject, issuer, credType)); + env.close(); + + // Build the credential keylet + auto const credKeylet = + keylet::credential(subject.id(), issuer.id(), Slice(credType, std::strlen(credType))); + + // Verify credential exists and is accepted + { + auto const sleCred = env.current()->read(credKeylet); + BEAST_EXPECT(sleCred && sleCred->isFlag(lsfAccepted)); + } + + // Create DepositPreauth + env(deposit::authCredentials(becky, {{subject, credType}})); + env.close(); + // env(); + auto jtx = env.jt(pay(subject, becky, XRP(100)), credentials::Ids({credIdx})); + if (!BEAST_EXPECT(jtx.stx)) + return; + auto const stx = std::make_shared(*jtx.stx); + + // Create PermissionedDomain + env(pdomain::setTx(becky, {{issuer, credType}})); + env.close(); + auto const objects = pdomain::getObjects(becky, env); + if (!BEAST_EXPECT(!objects.empty())) + return; + auto const domain = objects.begin()->first; + + using namespace std::chrono_literals; + env.close(50s); + + // Verify time has advanced past expiration + { + auto const sleCred = env.current()->read(credKeylet); + BEAST_EXPECT( + sleCred && + xrpl::credentials::checkExpired(*sleCred, env.current()->header().parentCloseTime)); + } + + // Create an ApplyViewImpl on top of the current closed ledger + // and corrupt it by erasing the issuer's account SLE + auto const open = env.current(); + ApplyViewImpl av(&*open, TapNone); + + // Erase the issuer's account to simulate ledger corruption + auto sleIssuer = av.peek(keylet::account(issuer.id())); + if (!BEAST_EXPECT(sleIssuer)) + return; + av.erase(sleIssuer); + BEAST_EXPECT(!av.exists(keylet::account(issuer.id()))); + + // Credential still exists before removeExpired + BEAST_EXPECT(av.exists(credKeylet)); + + // Call removeExpired on the corrupted view + STVector256 credHashes; + credHashes.pushBack(credKeylet.key); + beast::Journal const j{beast::Journal::getNullSink()}; + + auto const dpTer = xrpl::verifyDepositPreauth(*stx, av, subject, becky, {}, j); + auto sleCredAfter = av.read(credKeylet); + BEAST_EXPECT(sleCredAfter && sleCredAfter->isFlag(lsfAccepted)); + + auto const domTer = xrpl::verifyValidDomain(av, subject.id(), domain, j); + sleCredAfter = av.read(credKeylet); + BEAST_EXPECT(sleCredAfter && sleCredAfter->isFlag(lsfAccepted)); + + if (fixEnabled) + { + // removeExpired returns error, cred wasn't deleted + BEAST_EXPECT(dpTer == tecINTERNAL); + BEAST_EXPECT(domTer == tecINTERNAL); + } + else + { + // removeExpired returns true (claims it found & deleted expired + // creds) + BEAST_EXPECT(dpTer == tecEXPIRED); + BEAST_EXPECT(isTesSuccess(domTer)); + } + } + void run() override { @@ -1043,6 +1163,9 @@ struct Credentials_test : public beast::unit_test::Suite testFlags(all - fixInvalidTxFlags); testFlags(all); testRPC(); + + testRemoveExpiredCorruption(all - fixCleanup3_1_3); + testRemoveExpiredCorruption(all | fixCleanup3_1_3); } }; diff --git a/src/test/app/Delegate_test.cpp b/src/test/app/Delegate_test.cpp index 6ec4c250f6..b31a296bc9 100644 --- a/src/test/app/Delegate_test.cpp +++ b/src/test/app/Delegate_test.cpp @@ -195,7 +195,7 @@ class Delegate_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::DelegateSet; jv[jss::Account] = gw.human(); jv[sfAuthorize.jsonName] = alice.human(); - json::Value permissionsJson(json::ArrayValue); + json::Value permissionsJson(json::ValueType::Array); json::Value permissionValue; permissionValue[sfPermissionValue.jsonName] = "Payment"; json::Value permissionObj; @@ -1898,7 +1898,7 @@ class Delegate_test : public beast::unit_test::Suite jv[jss::Account] = alice.human(); jv[sfAuthorize.jsonName] = bob.human(); - json::Value permissionsJson(json::ArrayValue); + json::Value permissionsJson(json::ValueType::Array); json::Value permissionValue; permissionValue[sfPermissionValue.jsonName] = value; json::Value permissionObj; diff --git a/src/test/app/DepositAuth_test.cpp b/src/test/app/DepositAuth_test.cpp index e0b48d8572..7b371b3c06 100644 --- a/src/test/app/DepositAuth_test.cpp +++ b/src/test/app/DepositAuth_test.cpp @@ -58,7 +58,7 @@ reserve(jtx::Env& env, std::uint32_t count) static bool hasDepositAuth(jtx::Env const& env, jtx::Account const& acct) { - return ((*env.le(acct))[sfFlags] & lsfDepositAuth) == lsfDepositAuth; + return env.le(acct)->isFlag(lsfDepositAuth); } struct DepositAuth_test : public beast::unit_test::Suite @@ -370,7 +370,7 @@ ledgerEntryDepositPreauth( json::Value jvParams; jvParams[jss::ledger_index] = jss::validated; jvParams[jss::deposit_preauth][jss::owner] = acc.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto& arr(jvParams[jss::deposit_preauth][jss::authorized_credentials]); for (auto const& o : auth) { @@ -795,7 +795,7 @@ struct DepositPreauth_test : public beast::unit_test::Suite // Alice can't pay - empty credentials array { auto jv = pay(alice, bob, XRP(100)); - jv[sfCredentialIDs.jsonName] = json::ArrayValue; + jv[sfCredentialIDs.jsonName] = json::ValueType::Array; env(jv, Ter(temMALFORMED)); env.close(); } @@ -929,7 +929,7 @@ struct DepositPreauth_test : public beast::unit_test::Suite { // both included [AuthorizeCredentials UnauthorizeCredentials] auto jv = deposit::authCredentials(bob, {{issuer, credType}}); - jv[sfUnauthorizeCredentials.jsonName] = json::ArrayValue; + jv[sfUnauthorizeCredentials.jsonName] = json::ValueType::Array; env(jv, Ter(temMALFORMED)); } @@ -971,7 +971,7 @@ struct DepositPreauth_test : public beast::unit_test::Suite // invalid issuer auto jv = deposit::authCredentials(bob, {}); auto& arr(jv[sfAuthorizeCredentials.jsonName]); - json::Value cred = json::ObjectValue; + json::Value cred = json::ValueType::Object; cred[jss::Issuer] = to_string(xrpAccount()); cred[sfCredentialType.jsonName] = strHex(std::string_view(credType)); json::Value credParent; diff --git a/src/test/app/Discrepancy_test.cpp b/src/test/app/Discrepancy_test.cpp index 0d3460dd2a..8d2038fe94 100644 --- a/src/test/app/Discrepancy_test.cpp +++ b/src/test/app/Discrepancy_test.cpp @@ -93,7 +93,7 @@ class Discrepancy_test : public beast::unit_test::Suite json::Value jrq2; jrq2[jss::binary] = false; - jrq2[jss::transaction] = env.tx()->getJson(JsonOptions::KNone)[jss::hash]; + jrq2[jss::transaction] = env.tx()->getJson(JsonOptions::Values::None)[jss::hash]; jrq2[jss::id] = 3; auto jrr = env.rpc("json", "tx", to_string(jrq2))[jss::result]; uint64_t const fee{jrr[jss::Fee].asUInt()}; diff --git a/src/test/app/Freeze_test.cpp b/src/test/app/Freeze_test.cpp index 26b7a1e70a..2b5ca831da 100644 --- a/src/test/app/Freeze_test.cpp +++ b/src/test/app/Freeze_test.cpp @@ -95,12 +95,14 @@ class Freeze_test : public beast::unit_test::Suite // Is created via a TrustSet with SetFreeze flag // test: sets LowFreeze | HighFreeze flags env(trust(g1, bob["USD"](0), tfSetFreeze)); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 2u))) return; auto ff = affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName]; BEAST_EXPECT( - ff[sfLowLimit.fieldName] == g1["USD"](0).value().getJson(JsonOptions::KNone)); + ff[sfLowLimit.fieldName] == + g1["USD"](0).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(ff[jss::Flags].asUInt() & lsfLowFreeze); BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighFreeze)); env.close(); @@ -110,14 +112,16 @@ class Freeze_test : public beast::unit_test::Suite // Account with line frozen by issuer // test: can buy more assets on that line env(offer(bob, g1["USD"](5), XRP(25))); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 5u))) return; auto ff = affected[3u][sfModifiedNode.fieldName][sfFinalFields.fieldName]; BEAST_EXPECT( - ff[sfHighLimit.fieldName] == bob["USD"](100).value().getJson(JsonOptions::KNone)); + ff[sfHighLimit.fieldName] == + bob["USD"](100).value().getJson(JsonOptions::Values::None)); auto amt = STAmount{Issue{toCurrency("USD"), noAccount()}, -15}.value().getJson( - JsonOptions::KNone); + JsonOptions::Values::None); BEAST_EXPECT(ff[sfBalance.fieldName] == amt); env.close(); } @@ -174,12 +178,14 @@ class Freeze_test : public beast::unit_test::Suite // Is cleared via a TrustSet with ClearFreeze flag // test: sets LowFreeze | HighFreeze flags env(trust(g1, bob["USD"](0), tfClearFreeze)); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 2u))) return; auto ff = affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName]; BEAST_EXPECT( - ff[sfLowLimit.fieldName] == g1["USD"](0).value().getJson(JsonOptions::KNone)); + ff[sfLowLimit.fieldName] == + g1["USD"](0).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfLowFreeze)); BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighFreeze)); env.close(); @@ -359,7 +365,8 @@ class Freeze_test : public beast::unit_test::Suite // trust line env(trust(g1, a1["USD"](0), tfSetFreeze | tfClearFreeze)); { - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; BEAST_EXPECT(checkArraySize(affected, 1u)); // means no trustline changes } } @@ -599,7 +606,8 @@ class Freeze_test : public beast::unit_test::Suite // test: previous functionality, checking there's no changes to a // trust line env(trust(g1, a1["USD"](0), tfSetFreeze)); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 1u))) return; @@ -665,7 +673,8 @@ class Freeze_test : public beast::unit_test::Suite if (!BEAST_EXPECT(checkArraySize(offers, 1u))) return; BEAST_EXPECT( - offers[0u][jss::taker_gets] == g1["USD"](999).value().getJson(JsonOptions::KNone)); + offers[0u][jss::taker_gets] == + g1["USD"](999).value().getJson(JsonOptions::Values::None)); // test: someone else creates an offer providing liquidity env(offer(a4, XRP(999), g1["USD"](999))); @@ -673,11 +682,12 @@ class Freeze_test : public beast::unit_test::Suite // test: owner of partially consumed offers line is frozen env(trust(g1, a3["USD"](0), tfSetFreeze)); - auto affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto affected = env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 2u))) return; auto ff = affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName]; - BEAST_EXPECT(ff[sfHighLimit.fieldName] == g1["USD"](0).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + ff[sfHighLimit.fieldName] == g1["USD"](0).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfLowFreeze)); BEAST_EXPECT(ff[jss::Flags].asUInt() & lsfHighFreeze); env.close(); @@ -699,18 +709,19 @@ class Freeze_test : public beast::unit_test::Suite // removal buy successful OfferCreate // test: freeze the new offer env(trust(g1, a4["USD"](0), tfSetFreeze)); - affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + affected = env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 2u))) return; ff = affected[0u][sfModifiedNode.fieldName][sfFinalFields.fieldName]; - BEAST_EXPECT(ff[sfLowLimit.fieldName] == g1["USD"](0).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + ff[sfLowLimit.fieldName] == g1["USD"](0).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(ff[jss::Flags].asUInt() & lsfLowFreeze); BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighFreeze)); env.close(); // test: can no longer create a crossing offer env(offer(a2, g1["USD"](999), XRP(999))); - affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + affected = env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, 8u))) return; auto created = affected[0u][sfCreatedNode.fieldName]; @@ -1914,7 +1925,8 @@ class Freeze_test : public beast::unit_test::Suite bool modified = true) { using namespace test::jtx; - auto const affected = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto const affected = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; if (!BEAST_EXPECT(checkArraySize(affected, expectedArraySize))) return 0; diff --git a/src/test/app/Invariants_test.cpp b/src/test/app/Invariants_test.cpp index 7303b8089b..0593d00838 100644 --- a/src/test/app/Invariants_test.cpp +++ b/src/test/app/Invariants_test.cpp @@ -94,7 +94,7 @@ class Invariants_test : public beast::unit_test::Suite static FeatureBitset defaultAmendments() { - return xrpl::test::jtx::testableAmendments() | featureInvariantsV1_1 | fixSecurity3_1_3; + return xrpl::test::jtx::testableAmendments() | fixCleanup3_1_3 | fixCleanup3_2_0; } /** Run a specific test case to put the ledger into a state that will be @@ -176,7 +176,7 @@ class Invariants_test : public beast::unit_test::Suite using namespace test::jtx; OpenView ov{*env.current()}; - test::StreamSink sink{beast::severities::KWarning}; + test::StreamSink sink{beast::Severity::Warning}; beast::Journal const jlog{sink}; ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog}; @@ -1291,8 +1291,8 @@ class Invariants_test : public beast::unit_test::Suite if (numCreds != 0u) { - // This array is sorted naturally, but if you willing to change this - // behavior don't forget to use credentials::makeSorted + // This array is sorted naturally, but if you are going to change + // this behavior, don't forget to use credentials::makeSorted STArray credentials(sfAcceptedCredentials, numCreds); for (std::size_t n = 0; n < numCreds; ++n) { @@ -1314,11 +1314,11 @@ class Invariants_test : public beast::unit_test::Suite { using namespace test::jtx; - bool const fixPDEnabled = features[fixPermissionedDomainInvariant]; + bool const fixEnabled = features[fixCleanup3_1_3]; std::initializer_list const badTers = {tecINVARIANT_FAILED, tecINVARIANT_FAILED}; std::initializer_list const failTers = {tecINVARIANT_FAILED, tefINVARIANT_FAILED}; - testcase << "PermissionedDomain" + std::string(fixPDEnabled ? " fix" : ""); + testcase << "PermissionedDomain" + std::string(fixEnabled ? " fix" : ""); doInvariantCheck( Env(*this, features), @@ -1328,7 +1328,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain 2"; @@ -1341,7 +1341,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain 3"; doInvariantCheck( @@ -1365,7 +1365,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain 4"; doInvariantCheck( @@ -1388,7 +1388,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain Set 1"; doInvariantCheck( @@ -1409,7 +1409,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain Set 2"; doInvariantCheck( @@ -1440,7 +1440,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain Set 3"; doInvariantCheck( @@ -1470,7 +1470,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain Set 4"; doInvariantCheck( @@ -1498,7 +1498,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); std::initializer_list const goodTers = {tesSUCCESS, tesSUCCESS}; @@ -1516,7 +1516,7 @@ class Invariants_test : public beast::unit_test::Suite testcase << "PermissionedDomain set 2 domains "; doInvariantCheck( Env(*this, features), - fixPDEnabled ? badMoreThan1 : emptyV, + fixEnabled ? badMoreThan1 : emptyV, [](Account const& a1, Account const& a2, ApplyContext& ac) { createPermissionedDomain(ac, a1, a2); createPermissionedDomain(ac, a1, a2, 2, 11); @@ -1524,7 +1524,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : goodTers); + fixEnabled ? failTers : goodTers); } { @@ -1545,7 +1545,7 @@ class Invariants_test : public beast::unit_test::Suite std::move(env1), a1, a2, - fixPDEnabled ? badMoreThan1 : emptyV, + fixEnabled ? badMoreThan1 : emptyV, [&pd1, &pd2](Account const&, Account const&, ApplyContext& ac) { auto sle1 = ac.view().peek({ltPERMISSIONED_DOMAIN, pd1}); auto sle2 = ac.view().peek({ltPERMISSIONED_DOMAIN, pd2}); @@ -1555,18 +1555,18 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_DELETE, [](STObject&) {}}, - fixPDEnabled ? failTers : goodTers); + fixEnabled ? failTers : goodTers); } { testcase << "PermissionedDomain set 0 domains "; doInvariantCheck( Env(*this, features), - fixPDEnabled ? badNoDomains : emptyV, + fixEnabled ? badNoDomains : emptyV, [](Account const&, Account const&, ApplyContext&) { return true; }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? badTers : goodTers); + fixEnabled ? badTers : goodTers); } { @@ -1587,11 +1587,11 @@ class Invariants_test : public beast::unit_test::Suite Env(*this, features), a1, a2, - fixPDEnabled ? badNoDomains : emptyV, + fixEnabled ? badNoDomains : emptyV, [](Account const&, Account const&, ApplyContext&) { return true; }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_DELETE, [](STObject&) {}}, - fixPDEnabled ? badTers : goodTers); + fixEnabled ? badTers : goodTers); } { @@ -1611,7 +1611,7 @@ class Invariants_test : public beast::unit_test::Suite std::move(env1), a1, a2, - fixPDEnabled ? badDeleted : emptyV, + fixEnabled ? badDeleted : emptyV, [&pd1](Account const&, Account const&, ApplyContext& ac) { auto sle1 = ac.view().peek({ltPERMISSIONED_DOMAIN, pd1}); ac.view().erase(sle1); @@ -1619,28 +1619,28 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : goodTers); + fixEnabled ? failTers : goodTers); } { testcase << "PermissionedDomain del, create domain "; doInvariantCheck( Env(*this, features), - fixPDEnabled ? badNotDeleted : emptyV, + fixEnabled ? badNotDeleted : emptyV, [](Account const& a1, Account const& a2, ApplyContext& ac) { createPermissionedDomain(ac, a1, a2); return true; }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_DELETE, [](STObject&) {}}, - fixPDEnabled ? failTers : goodTers); + fixEnabled ? failTers : goodTers); } { testcase << "PermissionedDomain invalid tx"; doInvariantCheck( - fixPDEnabled ? badTx : emptyV, + fixEnabled ? badTx : emptyV, [&](Account const& a1, Account const& a2, ApplyContext& ac) { createPermissionedDomain(ac, a1, a2); return true; @@ -1800,11 +1800,9 @@ class Invariants_test : public beast::unit_test::Suite { using namespace test::jtx; - bool const fixPDEnabled = features[fixPermissionedDomainInvariant]; - bool const fixS313Enabled = features[fixSecurity3_1_3]; + bool const fixEnabled = features[fixCleanup3_1_3]; - testcase << "PermissionedDEX" + std::string(fixPDEnabled ? " fixPD" : "") + - std::string(fixS313Enabled ? " fixS313" : ""); + testcase << "PermissionedDEX" + std::string(fixEnabled ? " fix" : ""); doInvariantCheck( Env(*this, features), @@ -1908,8 +1906,8 @@ class Invariants_test : public beast::unit_test::Suite std::move(env1), a1, a2, - fixS313Enabled ? std::vector{{"hybrid offer is malformed"}} - : std::vector{}, + fixEnabled ? std::vector{{"hybrid offer is malformed"}} + : std::vector{}, [&pd1](Account const& a1, Account const& a2, ApplyContext& ac) { Keylet const offerKey = keylet::offer(a2.id(), 10); auto sleOffer = std::make_shared(offerKey); @@ -1926,9 +1924,8 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttOFFER_CREATE, [&](STObject&) {}}, - fixS313Enabled - ? std::initializer_list{tecINVARIANT_FAILED, tecINVARIANT_FAILED} - : std::initializer_list{tesSUCCESS, tesSUCCESS}); + fixEnabled ? std::initializer_list{tecINVARIANT_FAILED, tecINVARIANT_FAILED} + : std::initializer_list{tesSUCCESS, tesSUCCESS}); } // hybrid offer missing sfAdditionalBooks @@ -2387,7 +2384,7 @@ class Invariants_test : public beast::unit_test::Suite } // Test: cover available greater than pseudo-account asset balance - // (requires fixSecurity3_1_3) + // (requires fixCleanup3_1_3) doInvariantCheck( {{"Loan Broker cover available is greater than pseudo-account asset balance"}}, [&](Account const&, Account const&, ApplyContext& ac) { @@ -3401,7 +3398,7 @@ class Invariants_test : public beast::unit_test::Suite sleShares->at(sfFlags) = 0; // Setting wrong pseudo account ID - sleShares->at(sfIssuer) = AccountID(uint160(42)); + sleShares->at(sfIssuer) = AccountID(42); sleShares->at(sfOutstandingAmount) = 0; sleShares->at(sfSequence) = sequence; @@ -4297,7 +4294,7 @@ class Invariants_test : public beast::unit_test::Suite testInvariantOverwrite(FeatureBitset features) { using namespace test::jtx; - bool const fixEnabled = features[fixSecurity3_1_3]; + bool const fixEnabled = features[fixCleanup3_1_3]; std::initializer_list const failTers = {tecINVARIANT_FAILED, tefINVARIANT_FAILED}; std::initializer_list const passTers = {tesSUCCESS, tesSUCCESS}; @@ -4561,21 +4558,17 @@ public: testNoZeroEscrow(); testValidNewAccountRoot(); testNFTokenPageInvariants(); - testPermissionedDomainInvariants(defaultAmendments() | fixPermissionedDomainInvariant); - testPermissionedDomainInvariants(defaultAmendments() - fixPermissionedDomainInvariant); - testPermissionedDEX(defaultAmendments() | fixPermissionedDomainInvariant); - testPermissionedDEX(defaultAmendments() - fixPermissionedDomainInvariant); - testPermissionedDEX( - (defaultAmendments() | fixPermissionedDomainInvariant) - fixSecurity3_1_3); - testPermissionedDEX( - defaultAmendments() - fixPermissionedDomainInvariant - fixSecurity3_1_3); + testPermissionedDomainInvariants(defaultAmendments() | fixCleanup3_1_3); + testPermissionedDomainInvariants(defaultAmendments() - fixCleanup3_1_3); + testPermissionedDEX(defaultAmendments() | fixCleanup3_1_3); + testPermissionedDEX(defaultAmendments() - fixCleanup3_1_3); testNoModifiedUnmodifiableFields(); testValidPseudoAccounts(); testValidLoanBroker(); testVault(); testMPT(); testInvariantOverwrite(defaultAmendments()); - testInvariantOverwrite(defaultAmendments() - fixSecurity3_1_3); + testInvariantOverwrite(defaultAmendments() - fixCleanup3_1_3); testVaultComputeCoarsestScale(); testAMM(); } diff --git a/src/test/app/LedgerLoad_test.cpp b/src/test/app/LedgerLoad_test.cpp index 3345f45aa6..fa2c8f9047 100644 --- a/src/test/app/LedgerLoad_test.cpp +++ b/src/test/app/LedgerLoad_test.cpp @@ -127,7 +127,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, sd.ledgerFile, StartUpType::LoadFile, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); auto jrb = env.rpc("ledger", "current", "full")[jss::result]; BEAST_EXPECT( sd.ledger[jss::ledger][jss::accountState].size() == @@ -147,7 +147,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, "", StartUpType::LoadFile, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); }); // file does not exist @@ -157,7 +157,7 @@ class LedgerLoad_test : public beast::unit_test::Suite envconfig( ledgerConfig, sd.dbPath, "badfile.json", StartUpType::LoadFile, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); }); // make a corrupted version of the ledger file (last 10 bytes removed). @@ -183,7 +183,7 @@ class LedgerLoad_test : public beast::unit_test::Suite StartUpType::LoadFile, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); }); } @@ -200,7 +200,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::Load, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); auto jrb = env.rpc("ledger", "current", "full")[jss::result]; BEAST_EXPECT(jrb[jss::ledger][jss::accountState].size() == 98); BEAST_EXPECT( @@ -221,7 +221,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::Replay, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); auto const jrb = env.rpc("ledger", "current", "full")[jss::result]; BEAST_EXPECT(jrb[jss::ledger][jss::accountState].size() == 97); // in replace mode do not automatically accept the ledger being replayed @@ -247,7 +247,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::Replay, sd.trapTxHash), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); auto const jrb = env.rpc("ledger", "current", "full")[jss::result]; BEAST_EXPECT(jrb[jss::ledger][jss::accountState].size() == 97); // in replace mode do not automatically accept the ledger being replayed @@ -277,7 +277,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::Replay, ~sd.trapTxHash), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); BEAST_EXPECT(false); } catch (std::runtime_error const&) @@ -301,7 +301,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, "latest", StartUpType::Load, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); auto jrb = env.rpc("ledger", "current", "full")[jss::result]; BEAST_EXPECT( sd.ledger[jss::ledger][jss::accountState].size() == @@ -319,7 +319,7 @@ class LedgerLoad_test : public beast::unit_test::Suite *this, envconfig(ledgerConfig, sd.dbPath, "43", StartUpType::Load, std::nullopt), nullptr, - beast::severities::KDisabled); + beast::Severity::Disabled); auto jrb = env.rpc("ledger", "current", "full")[jss::result]; BEAST_EXPECT( sd.ledger[jss::ledger][jss::accountState].size() == diff --git a/src/test/app/LedgerReplay_test.cpp b/src/test/app/LedgerReplay_test.cpp index a96fa2c499..fac798f14b 100644 --- a/src/test/app/LedgerReplay_test.cpp +++ b/src/test/app/LedgerReplay_test.cpp @@ -511,7 +511,7 @@ struct LedgerServer assert(param.initLedgers > 0); createAccounts(param.initAccounts); createLedgerHistory(); - app.getLogs().threshold(beast::severities::KWarning); + app.getLogs().threshold(beast::Severity::Warning); } /** @@ -611,7 +611,7 @@ public: PeerSetBehavior behavior = PeerSetBehavior::Good, InboundLedgersBehavior inboundBhvr = InboundLedgersBehavior::Good, PeerFeature peerFeature = PeerFeature::LedgerReplayEnabled) - : env(suite, jtx::envconfig(), nullptr, beast::severities::KDisabled) + : env(suite, jtx::envconfig(), nullptr, beast::Severity::Disabled) , app(env.app()) , ledgerMaster(env.app().getLedgerMaster()) , inboundLedgers(server.app.getLedgerMaster(), ledgerMaster, inboundBhvr) @@ -843,12 +843,9 @@ public: LedgerReplayer replayer; }; -using namespace beast::severities; +using beast::Severity; void -logAll( - LedgerServer& server, - LedgerReplayClient& client, - beast::severities::Severity level = Severity::KTrace) +logAll(LedgerServer& server, LedgerReplayClient& client, beast::Severity level = Severity::Trace) { server.app.getLogs().threshold(level); client.app.getLogs().threshold(level); diff --git a/src/test/app/LendingHelpers_test.cpp b/src/test/app/LendingHelpers_test.cpp index cbfd9da884..96d0722732 100644 --- a/src/test/app/LendingHelpers_test.cpp +++ b/src/test/app/LendingHelpers_test.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include @@ -17,63 +18,13 @@ namespace xrpl::test { class LendingHelpers_test : public beast::unit_test::Suite { - void - testComputeRaisedRate() - { - using namespace jtx; - using namespace xrpl::detail; - struct TestCase - { - std::string name; - Number periodicRate; - std::uint32_t paymentsRemaining; - Number expectedRaisedRate; - }; - - auto const testCases = std::vector{ - { - .name = "Zero payments remaining", - .periodicRate = Number{5, -2}, - .paymentsRemaining = 0, - .expectedRaisedRate = Number{1}, // (1 + r)^0 = 1 - }, - { - .name = "One payment remaining", - .periodicRate = Number{5, -2}, - .paymentsRemaining = 1, - .expectedRaisedRate = Number{105, -2}, - }, // 1.05^1 - { - .name = "Multiple payments remaining", - .periodicRate = Number{5, -2}, - .paymentsRemaining = 3, - .expectedRaisedRate = Number{1157625, -6}, - }, // 1.05^3 - { - .name = "Zero periodic rate", - .periodicRate = Number{0}, - .paymentsRemaining = 5, - .expectedRaisedRate = Number{1}, // (1 + 0)^5 = 1 - }}; - - for (auto const& tc : testCases) - { - testcase("computeRaisedRate: " + tc.name); - - auto const computedRaisedRate = - computeRaisedRate(tc.periodicRate, tc.paymentsRemaining); - BEAST_EXPECTS( - computedRaisedRate == tc.expectedRaisedRate, - "Raised rate mismatch: expected " + to_string(tc.expectedRaisedRate) + ", got " + - to_string(computedRaisedRate)); - } - } - void testComputePaymentFactor() { using namespace jtx; using namespace xrpl::detail; + Env const env{*this}; + auto const& rules = env.current()->rules(); struct TestCase { std::string name; @@ -114,7 +65,7 @@ class LendingHelpers_test : public beast::unit_test::Suite testcase("computePaymentFactor: " + tc.name); auto const computedPaymentFactor = - computePaymentFactor(tc.periodicRate, tc.paymentsRemaining); + computePaymentFactor(rules, tc.periodicRate, tc.paymentsRemaining); BEAST_EXPECTS( computedPaymentFactor == tc.expectedPaymentFactor, "Payment factor mismatch: expected " + to_string(tc.expectedPaymentFactor) + @@ -127,6 +78,8 @@ class LendingHelpers_test : public beast::unit_test::Suite { using namespace jtx; using namespace xrpl::detail; + Env const env{*this}; + auto const& rules = env.current()->rules(); struct TestCase { @@ -172,8 +125,8 @@ class LendingHelpers_test : public beast::unit_test::Suite { testcase("loanPeriodicPayment: " + tc.name); - auto const computedPeriodicPayment = - loanPeriodicPayment(tc.principalOutstanding, tc.periodicRate, tc.paymentsRemaining); + auto const computedPeriodicPayment = loanPeriodicPayment( + rules, tc.principalOutstanding, tc.periodicRate, tc.paymentsRemaining); BEAST_EXPECTS( computedPeriodicPayment == tc.expectedPeriodicPayment, "Periodic payment mismatch: expected " + to_string(tc.expectedPeriodicPayment) + @@ -186,6 +139,8 @@ class LendingHelpers_test : public beast::unit_test::Suite { using namespace jtx; using namespace xrpl::detail; + Env const env{*this}; + auto const& rules = env.current()->rules(); struct TestCase { @@ -232,7 +187,7 @@ class LendingHelpers_test : public beast::unit_test::Suite testcase("loanPrincipalFromPeriodicPayment: " + tc.name); auto const computedPrincipalOutstanding = loanPrincipalFromPeriodicPayment( - tc.periodicPayment, tc.periodicRate, tc.paymentsRemaining); + rules, tc.periodicPayment, tc.periodicRate, tc.paymentsRemaining); BEAST_EXPECTS( computedPrincipalOutstanding == tc.expectedPrincipalOutstanding, "Principal outstanding mismatch: expected " + @@ -241,6 +196,294 @@ class LendingHelpers_test : public beast::unit_test::Suite } } + void + testComputePowerMinusOne() + { + using namespace jtx; + using namespace xrpl::detail; + + // Edge cases. + { + testcase("computePowerMinusOne: zero rate returns zero"); + BEAST_EXPECT(computePowerMinusOne(0, 5) == 0); + } + { + testcase("computePowerMinusOne: zero paymentsRemaining returns zero"); + Number const fivePercent{5, -2}; + BEAST_EXPECT(computePowerMinusOne(fivePercent, 0) == 0); + } + // (1.05)^3 - 1 = 0.157625, computed independently by hand. + { + testcase("computePowerMinusOne: standard case (1.05)^3 - 1 = 0.157625"); + Number const r{5, -2}; + Number const expected{157625, -6}; + BEAST_EXPECT(computePowerMinusOne(r, 3) == expected); + } + // (1+1)^1 - 1 = 1. + { + testcase("computePowerMinusOne: r=1, n=1"); + BEAST_EXPECT(computePowerMinusOne(1, 1) == 1); + } + + // Property check at near-zero rate (the bug regime): for n=2 the + // mathematical identity is `(1+r)^2 - 1 = 2r + r^2`. We compute + // `2r + r^2` by direct multiplication in Number arithmetic — a + // path that doesn't share any code with the binomial loop — and + // assert the two paths agree. + { + testcase("computePowerMinusOne: near-zero rate matches independent 2r + r^2"); + // r = 1 TenthBips32 over 600s payment interval, computed + // independently below using xrpl::detail::loanPeriodicRate. + Number const r = loanPeriodicRate(TenthBips32{1}, 600); + Number const independentExpected = 2 * r + r * r; // (1+r)^2 - 1 + BEAST_EXPECT(computePowerMinusOne(r, 2) == independentExpected); + } + // Same property at n=3: (1+r)^3 - 1 = 3r + 3r^2 + r^3. + { + testcase("computePowerMinusOne: near-zero rate matches independent 3r + 3r^2 + r^3"); + Number const r = loanPeriodicRate(TenthBips32{1}, 600); + Number const independentExpected = 3 * r + 3 * r * r + r * r * r; + BEAST_EXPECT(computePowerMinusOne(r, 3) == independentExpected); + } + + // Larger-n stress test for the loop's early-termination logic. + // At very small r the binomial terms decrease by a factor of + // ~r*(n-k)/(k+1) per step, so even at n=1000 the loop should + // terminate in a small handful of iterations. Cross-check the + // result against the hybrid (which dispatches to this same + // binomial path when r*n < 1e-9). + { + testcase("computePowerMinusOne: large n, early termination matches hybrid output"); + // r*n = 1e-10 and 1e-12 — both clearly below the 1e-9 threshold. + Number const r1{1, -13}; + std::uint32_t const n1 = 1'000; + Number const r2{1, -15}; + std::uint32_t const n2 = 1'000; + BEAST_EXPECT(computePowerMinusOne(r1, n1) == computePowerMinusOneHybrid(r1, n1)); + BEAST_EXPECT(computePowerMinusOne(r2, n2) == computePowerMinusOneHybrid(r2, n2)); + BEAST_EXPECT(computePowerMinusOne(r1, n1) > 0); + BEAST_EXPECT(computePowerMinusOne(r2, n2) > 0); + } + } + + // Direct tests of `computePowerMinusOneHybrid`. Verifies the dispatcher + // picks the right branch and produces the right result on each side + // of the threshold. + void + testComputePowerMinusOneHybrid() + { + using namespace jtx; + using namespace xrpl::detail; + + // Above threshold (r * n >= 1e-9): hybrid must agree with the closed + // form `power(1+r, n) - 1` exactly (it is the closed form). + { + testcase("computePowerMinusOneHybrid: r*n >= 1e-9 uses closed form (bit-exact match)"); + + struct AboveThreshold + { + std::string name; + Number r; + std::uint32_t n; + }; + auto const cases = std::vector{ + {"r=5%, n=3", Number{5, -2}, 3}, + {"r=0.1%, n=1000", Number{1, -3}, 1'000}, + {"r=1e-7, n=100 (above threshold by 10x)", Number{1, -7}, 100}, + }; + for (auto const& tc : cases) + { + Number const closed = power(1 + tc.r, tc.n) - 1; + Number const hybrid = computePowerMinusOneHybrid(tc.r, tc.n); + BEAST_EXPECTS( + hybrid == closed, + tc.name + ": closed=" + to_string(closed) + ", hybrid=" + to_string(hybrid)); + } + } + + // Below threshold (r * n < 1e-9): hybrid must agree with + // `computePowerMinusOne` (the binomial expansion). At this regime + // the closed form is provably wrong (cancellation); we verify the + // dispatcher routes to the binomial path. + { + testcase( + "computePowerMinusOneHybrid: r*n < 1e-9 uses binomial expansion (bit-exact match)"); + + struct BelowThreshold + { + std::string name; + Number r; + std::uint32_t n; + }; + auto const cases = std::vector{ + // bug regime: r = 1 TenthBips32 over 600s payment interval + // → r ≈ 1.9e-10, r*n ≈ 3.8e-10 < 1e-9. + {"bug regime: r~1.9e-10, n=2", loanPeriodicRate(TenthBips32{1}, 600), 2}, + {"r=1e-12, n=100", Number{1, -12}, 100}, + }; + for (auto const& tc : cases) + { + Number const binom = computePowerMinusOne(tc.r, tc.n); + Number const hybrid = computePowerMinusOneHybrid(tc.r, tc.n); + BEAST_EXPECTS( + hybrid == binom, + tc.name + ": binom=" + to_string(binom) + ", hybrid=" + to_string(hybrid)); + } + } + + // Edge cases. + { + testcase("computePowerMinusOneHybrid: edge cases"); + Number const fivePercent{5, -2}; + BEAST_EXPECT(computePowerMinusOneHybrid(0, 100) == 0); + BEAST_EXPECT(computePowerMinusOneHybrid(fivePercent, 0) == 0); + BEAST_EXPECT(computePowerMinusOneHybrid(0, 0) == 0); + } + + // Threshold boundary: r*n = 1e-9 exactly. Hybrid uses `>=` against + // the threshold, so this case must take the closed-form branch. + // We also verify that the binomial path agrees with the closed + // form to high precision at this crossover — confirming the + // threshold is placed where both paths give "adequate" answers. + { + testcase("computePowerMinusOneHybrid: threshold boundary r*n = 1e-9"); + + // Construct exactly r*n = 1e-9 with two distinct (r, n) pairs. + struct Boundary + { + std::string name; + Number r; + std::uint32_t n; + }; + auto const cases = std::vector{ + {"r=1e-9, n=1", Number{1, -9}, 1}, + {"r=1e-12, n=1000", Number{1, -12}, 1'000}, + }; + + for (auto const& tc : cases) + { + Number const closed = power(1 + tc.r, tc.n) - 1; + Number const hybrid = computePowerMinusOneHybrid(tc.r, tc.n); + Number const binom = computePowerMinusOne(tc.r, tc.n); + + // At exact threshold, hybrid must take closed-form path: + // bit-exact match with closed. + BEAST_EXPECTS( + hybrid == closed, + tc.name + ": hybrid should equal closed at threshold; got hybrid=" + + to_string(hybrid) + ", closed=" + to_string(closed)); + + // Closed-form and binomial must agree at the threshold to + // within Number's post-subtraction precision (~10 sig + // digits of `r*n = 1e-9`, i.e. ~1e-19 absolute error). + Number const tolerance{1, -18}; + Number const diff = abs(closed - binom); + BEAST_EXPECTS( + diff < tolerance, + tc.name + ": closed and binomial diverge at threshold by " + to_string(diff)); + } + } + } + + // Regression: at near-zero rate, `loanPrincipalFromPeriodicPayment` + // must satisfy `principal <= periodicPayment * paymentsRemaining` for + // any non-negative rate. The naive closed-form path violated this + // bound due to catastrophic cancellation in `(1+r)^n - 1`. + void + testLoanPrincipalFromPeriodicPaymentNearZeroRate() + { + testcase("loanPrincipalFromPeriodicPayment: principal <= payment*n at near-zero rate"); + using namespace jtx; + using namespace xrpl::detail; + Env const env{*this}; + auto const& rules = env.current()->rules(); + + // Inputs from the bug reproduction in Loan_test.cpp: + // InterestRate = 1 TenthBips32 (0.001 % per year), + // PaymentInterval = 600 s, principal = 100, 3 payments. + // periodicRate is ~1.9e-10. + auto const periodicRate = loanPeriodicRate(TenthBips32{1}, 600); + auto const periodicPayment = loanPeriodicPayment(rules, 100, periodicRate, 3); + + for (auto const n : {3u, 2u, 1u}) + { + auto const computed = + loanPrincipalFromPeriodicPayment(rules, periodicPayment, periodicRate, n); + auto const upperBound = periodicPayment * Number{n}; + BEAST_EXPECTS( + computed <= upperBound, + "n=" + std::to_string(n) + ": payment*n=" + to_string(upperBound) + + ", principal=" + to_string(computed)); + } + } + + // Regression: `computeTheoreticalLoanState` must produce a non-negative + // `interestDue` for any non-negative rate. Pre-fix, near-zero rates + // produced a negative `interestDue` because `(1+r)^n - 1` lost most of + // its precision to cancellation. + void + testComputeTheoreticalLoanStateNearZeroRate() + { + testcase("computeTheoreticalLoanState: non-negative interestDue at near-zero rate"); + using namespace jtx; + using namespace xrpl::detail; + Env const env{*this}; + auto const& rules = env.current()->rules(); + + auto const periodicRate = loanPeriodicRate(TenthBips32{1}, 600); + auto const periodicPayment = loanPeriodicPayment(rules, 100, periodicRate, 3); + + auto const state = + computeTheoreticalLoanState(rules, periodicPayment, periodicRate, 2, TenthBips32{0}); + + BEAST_EXPECT(state.principalOutstanding <= state.valueOutstanding); + BEAST_EXPECT(state.interestDue >= 0); + BEAST_EXPECT(state.managementFeeDue == 0); + } + + // Direct gating proof: at near-zero rate, `computePaymentFactor` must + // return different values with `fixCleanup3_2_0` disabled vs enabled. + // The enabled path agrees with an independent polynomial reference; + // the disabled path diverges by a measurable amount due to the + // catastrophic cancellation in `(1+r)^n - 1`. + void + testComputePaymentFactorNearZeroRate() + { + testcase("computePaymentFactor: near-zero rate, amendment disabled vs enabled"); + using namespace jtx; + using namespace xrpl::detail; + + Number const r = loanPeriodicRate(TenthBips32{1}, 600); + std::uint32_t const n = 3; + + // Independent reference: expand F(r,3) = r*(1+r)^3/((1+r)^3-1) + // algebraically for n=3, dividing numerator and denominator by r: + // F(r,3) = (1 + 3r + 3r^2 + r^3) / (3 + 3r + r^2) + // No power(), no binomial series — pure polynomial arithmetic in + // Number. + Number const reference = (1 + 3 * r + 3 * r * r + r * r * r) / (3 + 3 * r + r * r); + + // Pre-fix: closed form power(1+r, n) - 1 suffers catastrophic + // cancellation when r*n ~ 5.7e-10. + Env const envBug{*this, testableAmendments() - fixCleanup3_2_0}; + Number const buggyFactor = computePaymentFactor(envBug.current()->rules(), r, n); + + // Post-fix: hybrid binomial path avoids cancellation. + Env const envFix{*this}; + Number const correctFactor = computePaymentFactor(envFix.current()->rules(), r, n); + + // The amendment must change the computed factor in this regime. + BEAST_EXPECT(buggyFactor != correctFactor); + + // The fixed factor must agree with the polynomial reference to + // within a few ULPs of Number's 19-digit precision. + BEAST_EXPECT(abs(correctFactor - reference) < Number(1, -15)); + + // The buggy factor must diverge from the reference by a measurable + // amount — empirically ~1e-10 in this regime. + BEAST_EXPECT(abs(buggyFactor - reference) > Number(1, -12)); + } + void testComputeOverpaymentComponents() { @@ -606,6 +849,7 @@ class LendingHelpers_test : public beast::unit_test::Suite asset, loanScale, overpaymentAmount, TenthBips32(0), TenthBips32(0), managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -615,6 +859,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -697,6 +942,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -706,6 +952,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -790,6 +1037,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -799,6 +1047,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -889,6 +1138,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -898,6 +1148,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -996,6 +1247,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -1005,6 +1257,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -1103,6 +1356,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -1112,6 +1366,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -1199,8 +1454,12 @@ public: testLoanLatePaymentInterest(); testLoanPeriodicPayment(); testLoanPrincipalFromPeriodicPayment(); - testComputeRaisedRate(); + testLoanPrincipalFromPeriodicPaymentNearZeroRate(); testComputePaymentFactor(); + testComputePowerMinusOne(); + testComputePowerMinusOneHybrid(); + testComputeTheoreticalLoanStateNearZeroRate(); + testComputePaymentFactorNearZeroRate(); testComputeOverpaymentComponents(); testComputeInterestAndFeeParts(); } diff --git a/src/test/app/LoanBroker_test.cpp b/src/test/app/LoanBroker_test.cpp index 58c925c043..29ae4b8d59 100644 --- a/src/test/app/LoanBroker_test.cpp +++ b/src/test/app/LoanBroker_test.cpp @@ -1249,7 +1249,7 @@ class LoanBroker_test : public beast::unit_test::Suite // Create a writable view cloned from the current ledger and remove the // vault SLE OpenView ov{*env.current()}; - test::StreamSink sink{beast::severities::KWarning}; + test::StreamSink sink{beast::Severity::Warning}; beast::Journal const jlog{sink}; ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog}; diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp index f189196a82..ede616bc7c 100644 --- a/src/test/app/Loan_test.cpp +++ b/src/test/app/Loan_test.cpp @@ -25,6 +25,8 @@ #include #include +#include + #include #include #include @@ -368,16 +370,11 @@ protected: env.balance(vaultPseudo, broker.asset).number()); if (ownerCount == 0) { - // Allow some slop for rounding IOUs - - // TODO: This needs to be an exact match once all the - // other rounding issues are worked out. + // The Vault must be perfectly balanced if there + // are no loans outstanding auto const total = vaultSle->at(sfAssetsTotal); auto const available = vaultSle->at(sfAssetsAvailable); - env.test.BEAST_EXPECT( - total == available || - (!broker.asset.integral() && available != 0 && - ((total - available) / available < Number(1, -6)))); + env.test.BEAST_EXPECT(total == available); env.test.BEAST_EXPECT(vaultSle->at(sfLossUnrealized) == 0); } } @@ -713,6 +710,7 @@ protected: auto const total = loanParams.payTotal.value_or(LoanSet::kDEFAULT_PAYMENT_TOTAL); auto const feeRate = brokerParams.managementFeeRate; auto const props = computeLoanProperties( + env.current()->rules(), asset, principal, interest, @@ -918,6 +916,7 @@ protected: state.totalValue, state.principalOutstanding, state.managementFeeOutstanding); { auto const raw = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -961,6 +960,7 @@ protected: std::size_t totalPaymentsMade = 0; xrpl::LoanState currentTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -990,6 +990,7 @@ protected: validateBorrowerBalance(); // Compute the expected principal amount auto const paymentComponents = xrpl::detail::computePaymentComponents( + env.current()->rules(), broker.asset.raw(), state.loanScale, state.totalValue, @@ -1010,6 +1011,7 @@ protected: paymentComponents.trackedManagementFeeDelta); xrpl::LoanState const nextTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining - 1, @@ -1407,6 +1409,7 @@ protected: auto state = getCurrentState(env, broker, keylet, verifyLoanStatus); auto const loanProperties = computeLoanProperties( + env.current()->rules(), broker.asset.raw(), state.principalOutstanding, state.interestRate, @@ -2143,7 +2146,7 @@ protected: Ter(tecNO_PERMISSION)); { - env.disableFeature(fixSecurity3_1_3); + env.disableFeature(fixCleanup3_1_3); env(pay(borrower, loanKeylet.key, STAmount{broker.asset, state.periodicPayment * Number{15, -1}}, @@ -2151,7 +2154,7 @@ protected: Fee(XRPAmount{ baseFee * (Number{15, -1} / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}), Ter(temINVALID_FLAG)); - env.enableFeature(fixSecurity3_1_3); + env.enableFeature(fixCleanup3_1_3); } } // Try to send a payment marked as multiple mutually exclusive @@ -2540,6 +2543,7 @@ protected: { auto const raw = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -2577,6 +2581,7 @@ protected: std::size_t totalPaymentsMade = 0; xrpl::LoanState currentTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -2586,6 +2591,7 @@ protected: { // Compute the expected principal amount auto const paymentComponents = xrpl::detail::computePaymentComponents( + env.current()->rules(), broker.asset.raw(), state.loanScale, state.totalValue, @@ -2603,6 +2609,7 @@ protected: ", periodic payment: " + to_string(roundedPeriodicPayment)); xrpl::LoanState const nextTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining - 1, @@ -2797,8 +2804,8 @@ protected: pseudoAcct, tfLoanOverpayment, [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) { - // Estimate optimal values for loanPaymentsPerFeeIncrement and - // loanMaximumPaymentsPerTransaction. + // Estimate optimal values for kLOAN_PAYMENTS_PER_FEE_INCREMENT and + // kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION. using namespace loan; auto const state = getCurrentState(env, broker, verifyLoanStatus.keylet); @@ -2816,7 +2823,8 @@ protected: // Make all but the final payment auto const numPayments = (state.paymentRemaining - 2); STAmount const bigPayment{broker.asset, totalDue * numPayments}; - XRPAmount const bigFee{baseFee * (numPayments / loanPaymentsPerFeeIncrement + 1)}; + XRPAmount const bigFee{ + baseFee * (numPayments / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; time("ten payments", [&]() { env(pay(borrower, loanKeylet.key, bigPayment), Fee(bigFee)); }); @@ -3579,7 +3587,7 @@ protected: // Adding an empty counterparty signature object also fails, but // at the RPC level. - createJson = env.json(createJson, Json(sfCounterpartySignature, json::ObjectValue)); + createJson = env.json(createJson, Json(sfCounterpartySignature, json::ValueType::Object)); env(createJson, Ter(telENV_RPC_FAILED)); if (auto const jt = env.jt(createJson); BEAST_EXPECT(jt.stx)) @@ -3597,7 +3605,7 @@ protected: } // Copy the transaction signature into the counterparty signature. - json::Value counterpartyJson{json::ObjectValue}; + json::Value counterpartyJson{json::ValueType::Object}; counterpartyJson[sfTxnSignature] = createJson[sfTxnSignature]; counterpartyJson[sfSigningPubKey] = createJson[sfSigningPubKey]; if (!BEAST_EXPECT(!createJson.isMember(jss::Signers))) @@ -3629,7 +3637,7 @@ protected: } } auto const loanID = [&]() { - json::Value params(json::ObjectValue); + json::Value params(json::ValueType::Object); params[jss::account] = lender.human(); params[jss::type] = "Loan"; auto const res = env.rpc("json", "account_objects", to_string(params)); @@ -3706,9 +3714,9 @@ protected: auto forgedLoanSet = set(borrower, broker.brokerID, principalRequest, 0); - json::Value randomData{json::ObjectValue}; + json::Value randomData{json::ValueType::Object}; randomData[jss::SigningPubKey] = json::StaticString{"2600"}; - json::Value sigObject{json::ObjectValue}; + json::Value sigObject{json::ValueType::Object}; sigObject[jss::SigningPubKey] = strHex(lender.pk().slice()); Serializer ss; ss.add32(HashPrefix::TxSign); @@ -3732,7 +3740,7 @@ protected: // ? Check that the loan was NOT created { - json::Value params(json::ObjectValue); + json::Value params(json::ValueType::Object); params[jss::account] = borrower.human(); params[jss::type] = "Loan"; auto const res = env.rpc("json", "account_objects", to_string(params)); @@ -3775,7 +3783,7 @@ protected: auto createJson = env.json(set(lender, broker.brokerID, principalRequest), Fee(loanSetFee)); - json::Value counterpartyJson{json::ObjectValue}; + json::Value counterpartyJson{json::ValueType::Object}; counterpartyJson[sfTxnSignature] = createJson[sfTxnSignature]; counterpartyJson[sfSigningPubKey] = createJson[sfSigningPubKey]; if (!BEAST_EXPECT(!createJson.isMember(jss::Signers))) @@ -3822,7 +3830,7 @@ protected: Fee(loanSetFee), kLOAN_SERVICE_FEE(serviceFee), kPAYMENT_TOTAL(numPayments), - Json(sfCounterpartySignature, json::ObjectValue)); + Json(sfCounterpartySignature, json::ValueType::Object)); createJson["CloseInterestRate"] = 55374; createJson["ClosePaymentFee"] = "3825205248"; @@ -3891,12 +3899,12 @@ protected: { testcase("RPC AccountSet"); - json::Value txJson{json::ObjectValue}; + json::Value txJson{json::ValueType::Object}; txJson[sfTransactionType] = "AccountSet"; txJson[sfAccount] = borrower.human(); auto const signParams = [&]() { - json::Value signParams{json::ObjectValue}; + json::Value signParams{json::ValueType::Object}; signParams[jss::passphrase] = borrowerPass; signParams[jss::key_type] = "ed25519"; signParams[jss::tx_json] = txJson; @@ -3925,12 +3933,12 @@ protected: { testcase("RPC LoanSet - illegal signature_target"); - json::Value txJson{json::ObjectValue}; + json::Value txJson{json::ValueType::Object}; txJson[sfTransactionType] = "AccountSet"; txJson[sfAccount] = borrower.human(); auto const borrowerSignParams = [&]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::passphrase] = borrowerPass; params[jss::key_type] = "ed25519"; params[jss::signature_target] = "Destination"; @@ -3948,7 +3956,7 @@ protected: { testcase("RPC LoanSet - sign and submit borrower initiated"); // 1. Borrower creates the transaction - json::Value txJson{json::ObjectValue}; + json::Value txJson{json::ValueType::Object}; txJson[sfTransactionType] = "LoanSet"; txJson[sfAccount] = borrower.human(); txJson[sfCounterparty] = lender.human(); @@ -3965,7 +3973,7 @@ protected: // 2. Borrower signs the transaction auto const borrowerSignParams = [&]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::passphrase] = borrowerPass; params[jss::key_type] = "ed25519"; params[jss::tx_json] = txJson; @@ -3997,7 +4005,7 @@ protected: // 3. Borrower sends the signed transaction to the lender // 4. Lender signs the transaction auto const lenderSignParams = [&]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::passphrase] = lenderPass; params[jss::key_type] = "ed25519"; params[jss::signature_target] = "CounterpartySignature"; @@ -4055,7 +4063,7 @@ protected: { testcase("RPC LoanSet - sign and submit lender initiated"); // 1. Lender creates the transaction - json::Value txJson{json::ObjectValue}; + json::Value txJson{json::ValueType::Object}; txJson[sfTransactionType] = "LoanSet"; txJson[sfAccount] = lender.human(); txJson[sfCounterparty] = borrower.human(); @@ -4072,7 +4080,7 @@ protected: // 2. Lender signs the transaction auto const lenderSignParams = [&]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::passphrase] = lenderPass; params[jss::key_type] = "ed25519"; params[jss::tx_json] = txJson; @@ -4103,7 +4111,7 @@ protected: // 3. Lender sends the signed transaction to the Borrower // 4. Borrower signs the transaction auto const borrowerSignParams = [&]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::passphrase] = borrowerPass; params[jss::key_type] = "ed25519"; params[jss::signature_target] = "CounterpartySignature"; @@ -4571,7 +4579,7 @@ protected: auto createJson = env.json( set(borrower, broker.brokerID, principalRequest), Fee(loanSetFee), - Json(sfCounterpartySignature, json::ObjectValue)); + Json(sfCounterpartySignature, json::ValueType::Object)); createJson["CloseInterestRate"] = 76671; createJson["ClosePaymentFee"] = "2061925410"; @@ -4635,7 +4643,7 @@ protected: auto createJson = env.json( set(borrower, broker.brokerID, principalRequest), Fee(loanSetFee), - Json(sfCounterpartySignature, json::ObjectValue)); + Json(sfCounterpartySignature, json::ValueType::Object)); createJson["ClosePaymentFee"] = "0"; createJson["GracePeriod"] = 60; @@ -4725,7 +4733,7 @@ protected: auto createJson = env.json( set(borrower, broker.brokerID, principalRequest), Fee(loanSetFee), - Json(sfCounterpartySignature, json::ObjectValue)); + Json(sfCounterpartySignature, json::ValueType::Object)); createJson["CloseInterestRate"] = 47299; createJson["ClosePaymentFee"] = "3985819770"; @@ -4753,15 +4761,17 @@ protected: } void - testDosLoanPay() + testDosLoanPay(FeatureBitset features) { + bool const feeCapped = features[fixCleanup3_1_3]; + // From FIND-005 - testcase << "DoS LoanPay"; + testcase << "DoS LoanPay: fee calculation " << (feeCapped ? "capped" : "uncapped"); using namespace jtx; using namespace std::chrono_literals; using namespace Lending; - Env env(*this, all_); + Env env(*this, features); Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -4770,6 +4780,8 @@ protected: env.fund(XRP(1'000'000), issuer, lender, borrower); env.close(); + BEAST_EXPECT(feeCapped == env.current()->rules().enabled(fixCleanup3_1_3)); + PrettyAsset const iouAsset = issuer[iouCurrency_]; env(trust(lender, iouAsset(100'000'000))); env(trust(borrower, iouAsset(100'000'000))); @@ -4782,52 +4794,117 @@ protected: using namespace loan; auto const loanSetFee = Fee(env.current()->fees().base * 2); - Number const principalRequest{1, 3}; + Number const principalRequest{3959'37, -2}; auto const baseFee = env.current()->fees().base; - auto createJson = env.json( + auto const createJson = env.json( set(borrower, broker.brokerID, principalRequest), Fee(loanSetFee), - Json(sfCounterpartySignature, json::ObjectValue)); - - createJson["ClosePaymentFee"] = "0"; - createJson["GracePeriod"] = 60; - createJson["InterestRate"] = 20930; - createJson["LateInterestRate"] = 77049; - createJson["LatePaymentFee"] = "0"; - createJson["LoanServiceFee"] = "0"; - createJson["OverpaymentFee"] = 7; - createJson["OverpaymentInterestRate"] = 66653; - createJson["PaymentInterval"] = 60; - createJson["PaymentTotal"] = 3239184; - createJson["PrincipalRequested"] = "3959.37"; + Json(sfCounterpartySignature, json::ValueType::Object), + kCLOSE_PAYMENT_FEE(0), + kGRACE_PERIOD(60), + kINTEREST_RATE(TenthBips32(20930)), + kLATE_INTEREST_RATE(TenthBips32(77049)), + kLATE_PAYMENT_FEE(0), + kLOAN_SERVICE_FEE(0), + kOVERPAYMENT_FEE(TenthBips32(7)), + kOVERPAYMENT_INTEREST_RATE(TenthBips32(66653)), + kPAYMENT_INTERVAL(60), + kPAYMENT_TOTAL(3239184)); + // There are enough payments due on this loan that it only needs to be + // created once, and can be paid on multiple times. Just don't create a + // gazillion test cases. auto const brokerStateBefore = env.le(keylet::loanbroker(broker.brokerID)); auto const loanSequence = brokerStateBefore->at(sfLoanSequence); auto const keylet = keylet::loan(broker.brokerID, loanSequence); - createJson = env.json(createJson, Sig(sfCounterpartySignature, lender)); - env(createJson, Ter(tesSUCCESS)); + env(createJson, Sig(sfCounterpartySignature, lender)); env.close(); - auto const stateBefore = getCurrentState(env, broker, keylet); - BEAST_EXPECT(stateBefore.paymentRemaining == 3239184); - BEAST_EXPECT(stateBefore.paymentRemaining > kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION); + auto const roundedPayment = [&]() { + auto const stateBefore = getCurrentState(env, broker, keylet); + BEAST_EXPECT(stateBefore.paymentRemaining == 3239184); + BEAST_EXPECT(stateBefore.paymentRemaining > kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION); - auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}})); - Number const amount{395937, -2}; - loanPayTx["Amount"]["value"] = to_string(amount); - XRPAmount const payFee{ - baseFee * - std::int64_t( - amount / stateBefore.periodicPayment / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; - env(loanPayTx, Ter(tesSUCCESS), Fee(payFee)); - env.close(); + return roundToAsset( + iouAsset, + stateBefore.periodicPayment, + stateBefore.loanScale, + Number::RoundingMode::Upward); + }(); - auto const stateAfter = getCurrentState(env, broker, keylet); - BEAST_EXPECT( - stateAfter.paymentRemaining == - stateBefore.paymentRemaining - kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION); + auto test = [&](int const payFactor, + int const feeFactor, + TER const expectedTer = tesSUCCESS) { + auto const stateBefore = getCurrentState(env, broker, keylet); + BEAST_EXPECT(stateBefore.paymentRemaining <= 3239184); + BEAST_EXPECT(stateBefore.paymentRemaining > kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION); + + Number const amount = roundedPayment * payFactor; + auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, amount})); + XRPAmount const payFee{baseFee * feeFactor}; + env(loanPayTx, Ter(expectedTer), Fee(payFee)); + env.close(); + auto const expectedChange = isTesSuccess(expectedTer) + ? std::min(kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION, payFactor) + : 0; + + auto const stateAfter = getCurrentState(env, broker, keylet); + BEAST_EXPECT( + stateAfter.paymentRemaining == stateBefore.paymentRemaining - expectedChange); + }; + + std::int64_t constexpr kMAX_FEE_INCREMENTS = + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION / kLOAN_PAYMENTS_PER_FEE_INCREMENT; + + TER const failWithoutFix = feeCapped ? (TER)tesSUCCESS : (TER)telINSUF_FEE_P; + + // * Amount well above threshold -> capped fee + // The original test case - way over the limit - more fee is always ok + test(1819878, 363976); + // The capped fee is only sufficient if the amendment is enabled. + test(1819878, kMAX_FEE_INCREMENTS, failWithoutFix); + + // * Amount exactly at threshold -> capped fee + test(kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION, kMAX_FEE_INCREMENTS); + // More fee is always ok + test(kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION, kMAX_FEE_INCREMENTS + 10); + + // * Amount below threshold -> normal calculation + test(1, 1); + test(kLOAN_PAYMENTS_PER_FEE_INCREMENT * 2, 2); + test(0, 0, temBAD_AMOUNT); + test(0, 1, temBAD_AMOUNT); + // Fee difference rounds evenly + test( + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - 10, + ((kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - 10) / kLOAN_PAYMENTS_PER_FEE_INCREMENT) - 1, + telINSUF_FEE_P); + test( + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - 10, + ((kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - 10) / kLOAN_PAYMENTS_PER_FEE_INCREMENT)); + // More fee is always ok + test( + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - 10, + ((kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - 10) / kLOAN_PAYMENTS_PER_FEE_INCREMENT) + 3); + // Fee rounds up + for (int under = 1; under < kLOAN_PAYMENTS_PER_FEE_INCREMENT; ++under) + { + test( + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - under, + kMAX_FEE_INCREMENTS - 1, + telINSUF_FEE_P); + test(kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - under, kMAX_FEE_INCREMENTS); + } + // Only when you get one less fee increment can you pay less + test( + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - kLOAN_PAYMENTS_PER_FEE_INCREMENT, + kMAX_FEE_INCREMENTS - 1); + // And again, more fee is always ok. + test( + kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION - kLOAN_PAYMENTS_PER_FEE_INCREMENT, + kMAX_FEE_INCREMENTS); } void @@ -4870,7 +4947,7 @@ protected: auto createJson = env.json( set(borrower, broker.brokerID, principalRequest), Fee(loanSetFee), - Json(sfCounterpartySignature, json::ObjectValue)); + Json(sfCounterpartySignature, json::ValueType::Object)); createJson["ClosePaymentFee"] = "0"; createJson["InterestRate"] = 24346; @@ -4976,7 +5053,7 @@ protected: auto createJson = env.json( set(borrower, broker.brokerID, principalRequest), Fee(loanSetFee), - Json(sfCounterpartySignature, json::ObjectValue)); + Json(sfCounterpartySignature, json::ValueType::Object)); createJson["ClosePaymentFee"] = "0"; createJson["InterestRate"] = 12833; @@ -5069,7 +5146,7 @@ protected: kLATE_INTEREST_RATE(TenthBips32(77048)), kLATE_PAYMENT_FEE(0), kLOAN_ORIGINATION_FEE(218), - Json(sfCounterpartySignature, json::ObjectValue)); + Json(sfCounterpartySignature, json::ValueType::Object)); createJson.removeMember(sfSequence.getJsonName()); @@ -5516,7 +5593,11 @@ protected: auto const periodicRate = loanPeriodicRate(interestRateValue, state.paymentInterval); auto const rawLoanState = computeTheoreticalLoanState( - state.periodicPayment, periodicRate, state.paymentRemaining, managementFeeRate); + env.current()->rules(), + state.periodicPayment, + periodicRate, + state.paymentRemaining, + managementFeeRate); auto const parentCloseTime = env.current()->parentCloseTime(); auto const startDateSeconds = @@ -5745,6 +5826,7 @@ protected: auto state = getCurrentState(env, broker, loanKeylet); Number const periodicRate = loanPeriodicRate(state.interestRate, state.paymentInterval); auto const components = xrpl::detail::computePaymentComponents( + env.current()->rules(), asset.raw(), state.loanScale, state.totalValue, @@ -5778,7 +5860,10 @@ protected: // schedule auto const fullPaymentInterest = computeFullPaymentInterest( xrpl::detail::loanPrincipalFromPeriodicPayment( - after.periodicPayment, periodicRate2, after.paymentRemaining), + env.current()->rules(), + after.periodicPayment, + periodicRate2, + after.paymentRemaining), periodicRate2, env.current()->parentCloseTime(), after.paymentInterval, @@ -5811,7 +5896,10 @@ protected: auto const prevClamped = std::min(after.previousPaymentDate, nowSecs); auto const fullPaymentInterestClamped = computeFullPaymentInterest( xrpl::detail::loanPrincipalFromPeriodicPayment( - after.periodicPayment, periodicRate2, after.paymentRemaining), + env.current()->rules(), + after.periodicPayment, + periodicRate2, + after.paymentRemaining), periodicRate2, env.current()->parentCloseTime(), after.paymentInterval, @@ -6548,7 +6636,7 @@ protected: auto const assetType = AssetType::XRP; - Env env(*this, makeConfig(), all_, nullptr, beast::severities::Severity::KWarning); + Env env(*this, makeConfig(), all_, nullptr, beast::Severity::Warning); auto loanResult = createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower); @@ -7084,6 +7172,144 @@ protected: BEAST_EXPECT(afterSecondCoverAvailable == 0); } + void + testYieldTheftRounding(std::uint32_t flags) + { + testcase("Rounding manipulation does not permit yield theft"); + using namespace jtx; + using namespace loan; + + // 1. Setup Environment + Env env(*this, all_); + Account const issuer{"issuer"}; + Account const lender{"lender"}; + Account const borrower{"borrower"}; + + env.fund(XRP(1000), issuer, lender, borrower); + env.close(); + + // 2. Asset Selection + PrettyAsset const iou = issuer["USD"]; + env(trust(lender, iou(100'000'000))); + env(trust(borrower, iou(100'000'000))); + env(pay(issuer, lender, iou(100'000'000))); + env(pay(issuer, borrower, iou(100'000'000))); + env.close(); + + // 3. Create Vault and Broker with High Debt Limit (100M) + auto const brokerInfo = createVaultAndBroker( + env, + iou, + lender, + { + .vaultDeposit = 5'000'000, + .debtMax = Number{100'000'000}, + .coverDeposit = 500'000, + }); + auto const [currentSeq, vaultKeylet] = [&]() { + auto const brokerSle = env.le(keylet::loanbroker(brokerInfo.brokerID)); + if (!BEAST_EXPECT(brokerSle)) + return std::make_tuple(0u, keylet::unchecked(beast::kZERO)); + auto const currentSeq = brokerSle->at(sfLoanSequence); + auto const vaultKeylet = keylet::vault(brokerSle->at(sfVaultID)); + return std::make_tuple(currentSeq, vaultKeylet); + }(); + + // 4. Loan Parameters (Attack Vector) + Number const principal = 1'000'000; + TenthBips32 const interestRate = TenthBips32{1}; // 0.001% + std::uint32_t const paymentInterval = 86400; + std::uint32_t const paymentTotal = 3650; + + auto const loanSetFee = Fee(env.current()->fees().base * 2); + env(set(borrower, brokerInfo.brokerID, iou(principal).value(), flags), + Sig(sfCounterpartySignature, lender), + loan::kINTEREST_RATE(interestRate), + loan::kPAYMENT_INTERVAL(paymentInterval), + loan::kPAYMENT_TOTAL(paymentTotal), + Fee(loanSetFee)); + env.close(); + + // --- RETRIEVE OBJECTS & SETUP ATTACK --- + + auto borrowerBalance = [&]() { return env.balance(borrower, iou); }; + auto const borrowerScale = static_cast(borrowerBalance()).exponent(); + + auto const loanKeylet = keylet::loan(brokerInfo.brokerID, currentSeq); + auto const maybePeriodicPayment = [&]() -> std::optional { + auto const loanSle = env.le(loanKeylet); + if (!BEAST_EXPECT(loanSle)) + return std::nullopt; + // Construct Payment + return STAmount{iou, loanSle->at(sfPeriodicPayment)}; + }(); + if (!maybePeriodicPayment) + return; + auto const periodicPayment = *maybePeriodicPayment; + auto const roundedPayment = + roundToScale(periodicPayment, borrowerScale, Number::RoundingMode::Upward); + + // ATTACK: Add dust buffer (1e-9) to force 'excess' logic execution + STAmount const paymentBuffer{iou, Number(1, -9)}; + STAmount const attackPayment = periodicPayment + paymentBuffer; + + auto const maybeInitialVaultAssets = [&]() -> std::optional { + auto const vault = env.le(vaultKeylet); + if (!BEAST_EXPECT(vault)) + return std::nullopt; + return vault->at(sfAssetsTotal); + }(); + if (!maybeInitialVaultAssets) + return; + auto const initialVaultAssets = *maybeInitialVaultAssets; + + // 5. Execution Loop + int yieldTheftCount = 0; + auto previousAssetsTotal = initialVaultAssets; + + for (int i = 0; i < 100; ++i) + { + auto const balanceBefore = borrowerBalance(); + env(pay(borrower, loanKeylet.key, attackPayment, flags)); + env.close(); + auto const borrowerDelta = balanceBefore - borrowerBalance(); + BEAST_EXPECT(borrowerDelta.signum() == roundedPayment.signum()); + + auto const loanSle = env.le(loanKeylet); + if (!BEAST_EXPECT(loanSle)) + break; + auto const updatedPayment = STAmount{iou, loanSle->at(sfPeriodicPayment)}; + BEAST_EXPECT( + (roundToScale(updatedPayment, borrowerScale, Number::RoundingMode::Upward) == + roundedPayment)); + BEAST_EXPECT( + (updatedPayment == periodicPayment) || + (flags == tfLoanOverpayment && i >= 2 && updatedPayment < periodicPayment)); + + auto const currentVaultSle = env.le(vaultKeylet); + if (!BEAST_EXPECT(currentVaultSle)) + break; + + auto const currentAssetsTotal = currentVaultSle->at(sfAssetsTotal); + auto const delta = currentAssetsTotal - previousAssetsTotal; + + BEAST_EXPECT( + (delta == beast::kZERO && borrowerDelta <= roundedPayment) || + (delta > beast::kZERO && borrowerDelta > roundedPayment)); + + // If tx succeeded but Assets Total didn't change, interest was + // stolen. + if (delta == beast::kZERO && borrowerDelta > roundedPayment) + { + yieldTheftCount++; + } + + previousAssetsTotal = currentAssetsTotal; + } + + BEAST_EXPECTS(yieldTheftCount == 0, std::to_string(yieldTheftCount)); + } + // Tests that vault withdrawals work correctly when the vault has unrealized // loss from an impaired loan, ensuring the invariant check properly // accounts for the loss. @@ -7214,6 +7440,188 @@ protected: attemptWithdrawShares(depositorB, sharesLpB, tesSUCCESS); } + // A near-zero interest rate on a 100 USD loan + // produces total interest of ~6 units at loanScale -9. Numerical error + // in the amortization formula pushes the theoretical principal above + // the theoretical value, producing a negative theoretical interest. + // The payment delta then exceeds the actual outstanding interest, + // violating XRPL_ASSERT_PARTS in computePaymentComponents. + void + testBugInterestDueDeltaCrash() + { + testcase("bug: LoanPay asserts 'interest due delta' on near-zero rate"); + + using namespace jtx; + using namespace std::chrono_literals; + Env env(*this, all_); + + Account const issuer{"issuer"}; + Account const lender{"lender"}; + Account const borrower{"borrower"}; + + env.fund(XRP(1'000'000), issuer, lender, borrower); + env.close(); + env(fset(issuer, asfDefaultRipple)); + env.close(); + + PrettyAsset const iouAsset = issuer["USD"]; + env(trust(lender, iouAsset(1'000'000'000))); + env(trust(borrower, iouAsset(1'000'000'000))); + env(pay(issuer, lender, iouAsset(5'000'000))); + env(pay(issuer, borrower, iouAsset(5'000'000))); + env.close(); + + BrokerParameters const brokerParams{ + .vaultDeposit = 1'000'000, + .debtMax = 1'000'000, + .coverRateMin = TenthBips32{0}, + .coverDeposit = 0, + .managementFeeRate = TenthBips16{0}, + .coverRateLiquidation = TenthBips32{0}}; + + BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender, brokerParams)}; + + using namespace loan; + + auto const loanSetFee = Fee(env.current()->fees().base * 2); + Number const principalRequest{100}; + + auto createJson = env.json( + set(borrower, broker.brokerID, principalRequest), + Fee(loanSetFee), + Json(sfCounterpartySignature, json::ValueType::Object)); + + createJson["InterestRate"] = 1; // minimum non-zero rate + createJson["PaymentTotal"] = 3; + createJson["PaymentInterval"] = 600; + + auto const brokerStateBefore = env.le(keylet::loanbroker(broker.brokerID)); + auto const loanSequence = brokerStateBefore->at(sfLoanSequence); + auto const keylet = keylet::loan(broker.brokerID, loanSequence); + + createJson = env.json(createJson, Sig(sfCounterpartySignature, lender)); + env(createJson, Ter(tesSUCCESS)); + env.close(); + + // For principal=100, n=3 the amortization schedule produces a + // periodic payment ≈ 33.33 USD. We pay 35 USD, which is more than + // one period's worth — enough for the LoanPay path to enter + // computePaymentComponents and reach the assertion that fires + // when the bug is present. With the fix, the tx applies cleanly. + env(pay(borrower, keylet.key, iouAsset(35)), Ter(tesSUCCESS)); + env.close(); + } + + // Integration test: full lifecycle of a $1B loan in the bug regime. + // Verifies that the vault collects the economically-correct interest + // income and that conservation holds at the trust-line level. + // + // Pre-fix (closed-form `power(1+r, n) - 1`): vault collected only + // ~$0.058 per $1B due to cancellation of `(1+r)^n - 1` at r*n ~ 5.7e-10. + // Post-fix (hybrid binomial path): vault collects ~$0.38 per $1B, + // matching the value computed independently with arbitrary-precision + // Decimal arithmetic. + void + testFullLifecycleVaultPnLNearZeroRate() + { + testcase("integration: full loan lifecycle, vault interest at near-zero rate"); + + using namespace jtx; + using namespace jtx::loan; + using namespace std::chrono_literals; + Env env(*this, all_); + + Account const issuer{"issuer"}; + Account const lender{"lender"}; + Account const borrower{"borrower"}; + + env.fund(XRP(1'000'000), issuer, lender, borrower); + env.close(); + env(fset(issuer, asfDefaultRipple)); + env.close(); + + PrettyAsset const iouAsset = issuer["USD"]; + STAmount const trustLimit{iouAsset.raw(), Number{1, 17}}; + env(trust(lender, trustLimit)); + env(trust(borrower, trustLimit)); + env.close(); + env(pay(issuer, lender, iouAsset(5'000'000'000LL))); + env(pay(issuer, borrower, iouAsset(5'000'000'000LL))); + env.close(); + + auto usdBalance = [&](Account const& a) { + return env.balance(a, iouAsset.raw().get()).value(); + }; + STAmount const borrowerStartBal = usdBalance(borrower); + + BrokerParameters const brokerParams{ + .vaultDeposit = Number{2, 9}, + .debtMax = Number{0}, + .coverRateMin = TenthBips32{0}, + .coverDeposit = 0, + .managementFeeRate = TenthBips16{0}, + .coverRateLiquidation = TenthBips32{0}}; + BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender, brokerParams)}; + + auto const vaultBefore = env.le(broker.vaultKeylet()); + BEAST_EXPECT(vaultBefore); + Number const vaultAvailableBefore = vaultBefore->at(sfAssetsAvailable); + + // Loan: $1B principal, 3 payments, 600s interval, rate=1 TenthBips32. + auto const loanSetFee = Fee(env.current()->fees().base * 2); + Number const principalRequest{1, 9}; + auto createJson = env.json( + set(borrower, broker.brokerID, principalRequest), + Fee(loanSetFee), + Json(sfCounterpartySignature, json::ValueType::Object)); + createJson["InterestRate"] = 1; + createJson["PaymentTotal"] = 3; + createJson["PaymentInterval"] = 600; + + auto const brokerStateBefore = env.le(keylet::loanbroker(broker.brokerID)); + auto const loanSequence = brokerStateBefore->at(sfLoanSequence); + auto const loanKeylet = keylet::loan(broker.brokerID, loanSequence); + createJson = env.json(createJson, Sig(sfCounterpartySignature, lender)); + env(createJson, Ter(tesSUCCESS)); + env.close(); + + auto const loanSle = env.le(loanKeylet); + BEAST_EXPECT(loanSle); + Number const expectedTotalInterest = + loanSle->at(sfTotalValueOutstanding) - loanSle->at(sfPrincipalOutstanding); + + env(pay(borrower, loanKeylet.key, iouAsset(1'500'000'000LL)), Ter(tesSUCCESS)); + env.close(); + + auto const vaultAfter = env.le(broker.vaultKeylet()); + Number const vaultAvailableAfter = vaultAfter->at(sfAssetsAvailable); + Number const vaultGain = vaultAvailableAfter - vaultAvailableBefore; + + STAmount const borrowerEndBal = usdBalance(borrower); + STAmount const borrowerNetOut = borrowerStartBal - borrowerEndBal; + + // Self-consistency: vault gained exactly the expected interest + // computed at LoanSet, and the borrower's outflow matches. + BEAST_EXPECT(vaultGain == expectedTotalInterest); + BEAST_EXPECT(Number(borrowerNetOut) == expectedTotalInterest); + + // Mathematical correctness: the total interest for this loan + // configuration is 0.38051750382930729983, calculated + // independently using 50-digit Decimal arithmetic (no + // cancellation possible at that precision). At Number's 19-digit + // mantissa this rounds to 0.38051750382930729 — the literal + // below. The vault's actual gain must agree to within + // sub-microcent precision. + Number const decimalReference{38051750382930729LL, -17}; + Number const tolerance{1, -6}; // 1e-6 USD = sub-microcent + Number const error = abs(vaultGain - decimalReference); + BEAST_EXPECTS( + error < tolerance, + "vault gain " + to_string(vaultGain) + " differs from Decimal reference " + + to_string(decimalReference) + " by " + to_string(error) + " — exceeds tolerance " + + to_string(tolerance)); + } + public: void run() override @@ -7222,6 +7630,14 @@ public: testLoanPayLateFullPaymentBypassesPenalties(); testLoanCoverMinimumRoundingExploit(); #endif + for (auto const flags : {0u, tfLoanOverpayment}) + { + testYieldTheftRounding(flags); + } + + testBugInterestDueDeltaCrash(); + testFullLifecycleVaultPnLNearZeroRate(); + testWithdrawReflectsUnrealizedLoss(); testInvalidLoanSet(); @@ -7248,7 +7664,8 @@ public: testLoanPayDebtDecreaseInvariant(); testWrongMaxDebtBehavior(); testLoanPayComputePeriodicPaymentValidTotalInterestInvariant(); - testDosLoanPay(); + testDosLoanPay(all | fixCleanup3_1_3); + testDosLoanPay(all - fixCleanup3_1_3); testLoanPayComputePeriodicPaymentValidTotalPrincipalPaidInvariant(); testLoanPayComputePeriodicPaymentValidTotalInterestPaidInvariant(); testLoanNextPaymentDueDateOverflow(); diff --git a/src/test/app/MPToken_test.cpp b/src/test/app/MPToken_test.cpp index 94c51222cc..783527f4e1 100644 --- a/src/test/app/MPToken_test.cpp +++ b/src/test/app/MPToken_test.cpp @@ -217,7 +217,8 @@ class MPToken_test : public beast::unit_test::Suite tfMPTCanTransfer | tfMPTCanClawback}); // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; json::Value const result = env.rpc("tx", txHash)[jss::result]; BEAST_EXPECT(result[sfMaximumAmount.getJsonName()] == "9223372036854775807"); @@ -237,7 +238,7 @@ class MPToken_test : public beast::unit_test::Suite env(pdomain::setTx(credIssuer1, credentials1)); auto const domainId1 = [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); @@ -255,7 +256,7 @@ class MPToken_test : public beast::unit_test::Suite // Get the hash for the most recent transaction. std::string const txHash{ - env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; json::Value const result = env.rpc("tx", txHash)[jss::result]; BEAST_EXPECT(result[sfMaximumAmount.getJsonName()] == "9223372036854775807"); @@ -819,7 +820,7 @@ class MPToken_test : public beast::unit_test::Suite env(pdomain::setTx(credIssuer1, credentials1)); return [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); }(); @@ -833,7 +834,7 @@ class MPToken_test : public beast::unit_test::Suite env(pdomain::setTx(credIssuer2, credentials2)); return [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); }(); @@ -1096,7 +1097,7 @@ class MPToken_test : public beast::unit_test::Suite env(pdomain::setTx(credIssuer1, credentials1)); return [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); }(); @@ -1138,7 +1139,7 @@ class MPToken_test : public beast::unit_test::Suite env(pdomain::setTx(credIssuer1, credentials1)); return [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); }(); @@ -1195,7 +1196,7 @@ class MPToken_test : public beast::unit_test::Suite env(pdomain::setTx(credIssuer1, credentials)); return [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); }(); @@ -1207,7 +1208,7 @@ class MPToken_test : public beast::unit_test::Suite env(pdomain::setTx(credIssuer2, credentials)); return [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); }(); @@ -1562,7 +1563,8 @@ class MPToken_test : public beast::unit_test::Suite // payment between the holders env(pay(bob, carol, mpt(10'000)), Sendmax(mpt(10'000)), Txflags(tfPartialPayment)); // Verify the metadata - auto const meta = env.meta()->getJson(JsonOptions::KNone)[sfAffectedNodes.fieldName]; + auto const meta = + env.meta()->getJson(JsonOptions::Values::None)[sfAffectedNodes.fieldName]; // Issuer got 10 in the transfer fees BEAST_EXPECT( meta[0u][sfModifiedNode.fieldName][sfFinalFields.fieldName] @@ -1912,7 +1914,7 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::Asset] = toJson(xrpIssue()); jv[jss::Asset2] = toJson(usd.issue()); if (withAmount) - jv[field.fieldName] = usd(10).value().getJson(JsonOptions::KNone); + jv[field.fieldName] = usd(10).value().getJson(JsonOptions::Values::None); if (field == sfAsset) { jv[jss::Asset] = toJson(mpt.get()); @@ -1923,7 +1925,7 @@ class MPToken_test : public beast::unit_test::Suite } else { - jv[field.fieldName] = mpt.getJson(JsonOptions::KNone); + jv[field.fieldName] = mpt.getJson(JsonOptions::Values::None); } }; // All transactions with sfAmount, which don't support MPT. @@ -1970,7 +1972,7 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::Destination] = carol.human(); jv[jss::SettleDelay] = 1; jv[sfPublicKey.fieldName] = strHex(alice.pk().slice()); - jv[jss::Amount] = mpt.getJson(JsonOptions::KNone); + jv[jss::Amount] = mpt.getJson(JsonOptions::Values::None); test(jv, jss::Amount.cStr()); } // PaymentChannelFund @@ -1979,7 +1981,7 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::PaymentChannelFund; jv[jss::Account] = alice.human(); jv[sfChannel.fieldName] = to_string(uint256{1}); - jv[jss::Amount] = mpt.getJson(JsonOptions::KNone); + jv[jss::Amount] = mpt.getJson(JsonOptions::Values::None); test(jv, jss::Amount.cStr()); } // PaymentChannelClaim @@ -1988,7 +1990,7 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::PaymentChannelClaim; jv[jss::Account] = alice.human(); jv[sfChannel.fieldName] = to_string(uint256{1}); - jv[jss::Amount] = mpt.getJson(JsonOptions::KNone); + jv[jss::Amount] = mpt.getJson(JsonOptions::Values::None); test(jv, jss::Amount.cStr()); } // NFTokenCreateOffer @@ -1997,7 +1999,7 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::NFTokenCreateOffer; jv[jss::Account] = alice.human(); jv[sfNFTokenID.fieldName] = to_string(uint256{1}); - jv[jss::Amount] = mpt.getJson(JsonOptions::KNone); + jv[jss::Amount] = mpt.getJson(JsonOptions::Values::None); test(jv, jss::Amount.cStr()); } // NFTokenAcceptOffer @@ -2005,7 +2007,7 @@ class MPToken_test : public beast::unit_test::Suite json::Value jv; jv[jss::TransactionType] = jss::NFTokenAcceptOffer; jv[jss::Account] = alice.human(); - jv[sfNFTokenBrokerFee.fieldName] = mpt.getJson(JsonOptions::KNone); + jv[sfNFTokenBrokerFee.fieldName] = mpt.getJson(JsonOptions::Values::None); test(jv, sfNFTokenBrokerFee.fieldName); } // NFTokenMint @@ -2014,7 +2016,7 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::NFTokenMint; jv[jss::Account] = alice.human(); jv[sfNFTokenTaxon.fieldName] = 1; - jv[jss::Amount] = mpt.getJson(JsonOptions::KNone); + jv[jss::Amount] = mpt.getJson(JsonOptions::Values::None); test(jv, jss::Amount.cStr()); } // TrustSet @@ -2023,7 +2025,7 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::TrustSet; jv[jss::Account] = alice.human(); jv[jss::Flags] = 0; - jv[field.fieldName] = mpt.getJson(JsonOptions::KNone); + jv[field.fieldName] = mpt.getJson(JsonOptions::Values::None); test(jv, field.fieldName); }; trustSet(sfLimitAmount); @@ -2055,7 +2057,7 @@ class MPToken_test : public beast::unit_test::Suite alice, jvb, alice, mpt, XRP(10), alice, false, 1, alice, Signer(alice)); for (auto const& field : {sfAmount.fieldName, sfSignatureReward.fieldName}) { - jv[field] = mpt.getJson(JsonOptions::KNone); + jv[field] = mpt.getJson(JsonOptions::Values::None); test(jv, field); } } @@ -2064,7 +2066,7 @@ class MPToken_test : public beast::unit_test::Suite json::Value jv = sidechainXchainAccountCreate(alice, jvb, alice, mpt, XRP(10)); for (auto const& field : {sfAmount.fieldName, sfSignatureReward.fieldName}) { - jv[field] = mpt.getJson(JsonOptions::KNone); + jv[field] = mpt.getJson(JsonOptions::Values::None); test(jv, field); } } @@ -2077,9 +2079,9 @@ class MPToken_test : public beast::unit_test::Suite jv[jss::TransactionType] = tt; jv[jss::Account] = alice.human(); jv[sfXChainBridge.fieldName] = jvb; - jv[sfSignatureReward.fieldName] = rewardAmount.getJson(JsonOptions::KNone); + jv[sfSignatureReward.fieldName] = rewardAmount.getJson(JsonOptions::Values::None); jv[sfMinAccountCreateAmount.fieldName] = - minAccountAmount.getJson(JsonOptions::KNone); + minAccountAmount.getJson(JsonOptions::Values::None); test(jv, field); }; auto reward = STAmount{sfSignatureReward, mpt}; @@ -2113,7 +2115,8 @@ class MPToken_test : public beast::unit_test::Suite mptAlice.create(); - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; BEAST_EXPECTS( txHash == "E11F0E0CA14219922B7881F060B9CEE67CFBC87E4049A441ED2AE348FF8FAC" @@ -3308,7 +3311,7 @@ class MPToken_test : public beast::unit_test::Suite testMultiSendMaximumAmount(FeatureBitset features) { // Verify that directSendNoLimitMultiMPT correctly enforces MaximumAmount - // when the issuer sends to multiple receivers. Pre-fixSecurity3_1_3, + // when the issuer sends to multiple receivers. Pre-fixCleanup3_1_3, // a stale view.read() snapshot caused per-iteration checks to miss // aggregate overflows. Post-fix, a running total is used instead. testcase("Multi-send MaximumAmount enforcement"); @@ -3410,14 +3413,14 @@ class MPToken_test : public beast::unit_test::Suite // individual send (100 <= 150) even though the aggregate (200) // exceeds MaximumAmount. Preserved for ledger replay. { - // KNOWN BUG (pre-fixSecurity3_1_3): preserved for ledger replay only - env.disableFeature(fixSecurity3_1_3); + // KNOWN BUG (pre-fixCleanup3_1_3): preserved for ledger replay only + env.disableFeature(fixCleanup3_1_3); runTest( R{{alice.id(), 100}, {bob.id(), 100}}, tesSUCCESS, 250, "pre-amendment allows over-send"); - env.enableFeature(fixSecurity3_1_3); + env.enableFeature(fixCleanup3_1_3); } } diff --git a/src/test/app/MultiSign_test.cpp b/src/test/app/MultiSign_test.cpp index 55e1b73158..7588a6f272 100644 --- a/src/test/app/MultiSign_test.cpp +++ b/src/test/app/MultiSign_test.cpp @@ -692,7 +692,7 @@ public: { aliceSeq = env.seq(alice); json::Value jv = setupTx(); - jv[jss::tx_json][sfSigners.fieldName] = json::Value{json::ArrayValue}; + jv[jss::tx_json][sfSigners.fieldName] = json::Value{json::ValueType::Array}; beckySign(jv); auto jrr = env.rpc("json", "submit_multisigned", to_string(jv))[jss::result]; BEAST_EXPECT(jrr[jss::status] == "error"); @@ -1420,8 +1420,8 @@ public: uint8_t tag2[] = "hello world some ascii 32b long"; // including 1 byte for NUL - uint256 bogieTag = xrpl::BaseUint<256>::fromVoid(tag1); - uint256 demonTag = xrpl::BaseUint<256>::fromVoid(tag2); + uint256 bogieTag = xrpl::BaseUInt<256>::fromVoid(tag1); + uint256 demonTag = xrpl::BaseUInt<256>::fromVoid(tag2); // Attach phantom signers to alice and use them for a transaction. env(signers(alice, 1, {{bogie_, 1, bogieTag}, {demon_, 1, demonTag}})); diff --git a/src/test/app/NFTokenBurn_test.cpp b/src/test/app/NFTokenBurn_test.cpp index 56bb6b75d7..1e1910866d 100644 --- a/src/test/app/NFTokenBurn_test.cpp +++ b/src/test/app/NFTokenBurn_test.cpp @@ -771,7 +771,7 @@ class NFTokenBurn_test : public beast::unit_test::Suite // checks. These variables must outlive the ApplyContext. OpenView ov{*env.current()}; STTx const tx{ttACCOUNT_SET, [](STObject&) {}}; - test::StreamSink sink{beast::severities::KWarning}; + test::StreamSink sink{beast::Severity::Warning}; beast::Journal const jlog{sink}; ApplyContext ac{ env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog}; @@ -804,7 +804,7 @@ class NFTokenBurn_test : public beast::unit_test::Suite // checks. These variables must outlive the ApplyContext. OpenView ov{*env.current()}; STTx const tx{ttACCOUNT_SET, [](STObject&) {}}; - test::StreamSink sink{beast::severities::KWarning}; + test::StreamSink sink{beast::Severity::Warning}; beast::Journal const jlog{sink}; ApplyContext ac{ env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog}; diff --git a/src/test/app/NFTokenDir_test.cpp b/src/test/app/NFTokenDir_test.cpp index fbae51406b..f52992c468 100644 --- a/src/test/app/NFTokenDir_test.cpp +++ b/src/test/app/NFTokenDir_test.cpp @@ -381,7 +381,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // Lambda that exercises the split. auto exercise = [this, &features](std::initializer_list seeds) { - Env env{*this, envconfig(), features, nullptr, beast::severities::KDisabled}; + Env env{*this, envconfig(), features, nullptr, beast::Severity::Disabled}; // Eventually all of the NFTokens will be owned by buyer. Account const buyer{"buyer"}; @@ -892,7 +892,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // See what the account_objects command does with "nft_offer". { - json::Value ownedNftOffers(json::ArrayValue); + json::Value ownedNftOffers(json::ValueType::Array); std::string marker; do { @@ -965,7 +965,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // Verify that the ledger reports all of the NFTs owned by buyer. // Use the account_nfts rpc call to get the values. - json::Value ownedNFTs(json::ArrayValue); + json::Value ownedNFTs(json::ValueType::Array); std::string marker; do { diff --git a/src/test/app/NFToken_test.cpp b/src/test/app/NFToken_test.cpp index 3f4260e1b1..5be33fc4e5 100644 --- a/src/test/app/NFToken_test.cpp +++ b/src/test/app/NFToken_test.cpp @@ -886,7 +886,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // Empty list of tokens to delete. { json::Value jv = token::cancelOffer(buyer); - jv[sfNFTokenOffers.jsonName] = json::ArrayValue; + jv[sfNFTokenOffers.jsonName] = json::ValueType::Array; env(jv, Ter(temMALFORMED)); env.close(); BEAST_EXPECT(ownerCount(env, buyer) == 1); @@ -1058,7 +1058,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // A buy offer may not contain a sfNFTokenBrokerFee field. { json::Value jv = token::acceptBuyOffer(buyer, noXferOfferIndex); - jv[sfNFTokenBrokerFee.jsonName] = STAmount(500000).getJson(JsonOptions::KNone); + jv[sfNFTokenBrokerFee.jsonName] = STAmount(500000).getJson(JsonOptions::Values::None); env(jv, Ter(temMALFORMED)); env.close(); BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); @@ -1067,7 +1067,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // A sell offer may not contain a sfNFTokenBrokerFee field. { json::Value jv = token::acceptSellOffer(buyer, noXferOfferIndex); - jv[sfNFTokenBrokerFee.jsonName] = STAmount(500000).getJson(JsonOptions::KNone); + jv[sfNFTokenBrokerFee.jsonName] = STAmount(500000).getJson(JsonOptions::Values::None); env(jv, Ter(temMALFORMED)); env.close(); BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); @@ -1095,10 +1095,10 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); // The buy offer must not have expired. - // NOTE: this is only a preclaim check with the fixSecurity3_1_3 amendment disabled. + // NOTE: this is only a preclaim check with the fixCleanup3_1_3 amendment disabled. env(token::acceptBuyOffer(alice, buyerExpOfferIndex), Ter(tecEXPIRED)); env.close(); - if (features[fixSecurity3_1_3]) + if (features[fixCleanup3_1_3]) { buyerCount--; } @@ -1115,13 +1115,13 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); // The sell offer must not have expired. - // NOTE: this is only a preclaim check with the fixSecurity3_1_3 amendment disabled. + // NOTE: this is only a preclaim check with the fixCleanup3_1_3 amendment disabled. env(token::acceptSellOffer(buyer, aliceExpOfferIndex), Ter(tecEXPIRED)); env.close(); // Alice's count is decremented by one when the expired offer is // removed. - if (features[fixSecurity3_1_3]) + if (features[fixCleanup3_1_3]) { aliceCount--; } @@ -3101,10 +3101,10 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // No one can accept an expired sell offer. env(token::acceptSellOffer(buyer, offer1), Ter(tecEXPIRED)); - // With fixSecurity3_1_3 amendment, the first accept + // With fixCleanup3_1_3 amendment, the first accept // attempt deletes the expired offer. Without the amendment, // the offer remains and we can try to accept it again. - if (features[fixSecurity3_1_3]) + if (features[fixCleanup3_1_3]) { // After amendment: offer was deleted by first accept attempt minterCount--; @@ -3123,7 +3123,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite BEAST_EXPECT(ownerCount(env, minter) == minterCount); BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); - if (!features[fixSecurity3_1_3]) + if (!features[fixCleanup3_1_3]) { // Before amendment: expired offer still exists and needs to be // cancelled @@ -3189,10 +3189,10 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // An expired buy offer cannot be accepted. env(token::acceptBuyOffer(minter, offer1), Ter(tecEXPIRED)); - // With fixSecurity3_1_3 amendment, the first accept + // With fixCleanup3_1_3 amendment, the first accept // attempt deletes the expired offer. Without the amendment, // the offer remains and we can try to accept it again. - if (features[fixSecurity3_1_3]) + if (features[fixCleanup3_1_3]) { // After amendment: offer was deleted by first accept attempt buyerCount--; @@ -3211,7 +3211,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite BEAST_EXPECT(ownerCount(env, minter) == minterCount); BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); - if (!features[fixSecurity3_1_3]) + if (!features[fixCleanup3_1_3]) { // Before amendment: expired offer still exists and can be // cancelled @@ -3288,7 +3288,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite env(token::brokerOffers(issuer, buyOffer1, sellOffer1), Ter(tecEXPIRED)); env.close(); - if (features[fixSecurity3_1_3]) + if (features[fixCleanup3_1_3]) { // With amendment: expired offers are deleted minterCount--; @@ -3298,7 +3298,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite BEAST_EXPECT(ownerCount(env, minter) == minterCount); BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); - if (features[fixSecurity3_1_3]) + if (features[fixCleanup3_1_3]) { // The buy offer was deleted, so no need to cancel it // The sell offer still exists, so we can cancel it @@ -3377,7 +3377,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite env.close(); BEAST_EXPECT(ownerCount(env, issuer) == 0); - if (features[fixSecurity3_1_3]) + if (features[fixCleanup3_1_3]) { // After amendment: expired offers were deleted during broker // attempt @@ -3463,7 +3463,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // The expired offers are still in the ledger. BEAST_EXPECT(ownerCount(env, issuer) == 0); - if (!features[fixSecurity3_1_3]) + if (!features[fixCleanup3_1_3]) { // Before amendment: expired offers still exist in ledger BEAST_EXPECT(ownerCount(env, minter) == 2); @@ -4489,7 +4489,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite int expectMarkerCount, int line) { int markerCount = 0; - json::Value allOffers(json::ArrayValue); + json::Value allOffers(json::ValueType::Array); std::string marker; // The do/while collects results until no marker is returned. @@ -6101,7 +6101,8 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // transaction auto verifyNFTokenID = [&](uint256 const& actualNftID) { // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; env.close(); json::Value const meta = env.rpc("tx", txHash)[jss::result][jss::meta]; @@ -6121,7 +6122,8 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // changed in the most recent NFTokenCancelOffer transaction auto verifyNFTokenIDsInCancelOffer = [&](std::vector actualNftIDs) { // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; env.close(); json::Value const meta = env.rpc("tx", txHash)[jss::result][jss::meta]; @@ -6159,7 +6161,8 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // changed in the most recent NFTokenCreateOffer tx auto verifyNFTokenOfferID = [&](uint256 const& offerID) { // Get the hash for the most recent transaction. - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; env.close(); json::Value const meta = env.rpc("tx", txHash)[jss::result][jss::meta]; @@ -7190,7 +7193,7 @@ public: { testWithFeats( allFeatures_ - fixNFTokenReserve - featureNFTokenMintOffer - featureDynamicNFT - - fixSecurity3_1_3); + fixCleanup3_1_3); } }; @@ -7227,7 +7230,7 @@ class NfTokenWoExpiredOfferRemovalTest : public NFTokenBaseUtil_test void run() override { - testWithFeats(allFeatures_ - fixSecurity3_1_3); + testWithFeats(allFeatures_ - fixCleanup3_1_3); } }; diff --git a/src/test/app/NetworkOPs_test.cpp b/src/test/app/NetworkOPs_test.cpp index 02667ce275..d0a692b894 100644 --- a/src/test/app/NetworkOPs_test.cpp +++ b/src/test/app/NetworkOPs_test.cpp @@ -38,8 +38,7 @@ public: { using namespace jtx; auto const alice = Account{"alice"}; - Env env{ - *this, envconfig(), std::make_unique(&logs), beast::severities::KAll}; + Env env{*this, envconfig(), std::make_unique(&logs), beast::Severity::All}; env.memoize(env.master); env.memoize(alice); diff --git a/src/test/app/OfferMPT_test.cpp b/src/test/app/OfferMPT_test.cpp index 53796bf89a..7e196e4c5c 100644 --- a/src/test/app/OfferMPT_test.cpp +++ b/src/test/app/OfferMPT_test.cpp @@ -1443,7 +1443,7 @@ public: auto jro = ledgerEntryOffer(env, bob, bobOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(500).value().getText()); BEAST_EXPECT( - jro[jss::node][jss::TakerPays] == usd(100).value().getJson(JsonOptions::KNone)); + jro[jss::node][jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None)); env(pay(alice, alice, XRP(500)), Sendmax(usd(100))); @@ -1523,7 +1523,8 @@ public: // The previous payment reduced the remaining offer amount by 200 XRP auto jro = ledgerEntryOffer(env, bob, bobOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(300).value().getText()); - BEAST_EXPECT(jro[jss::node][jss::TakerPays] == usd(60).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jro[jss::node][jss::TakerPays] == usd(60).value().getJson(JsonOptions::Values::None)); // the balance between alice and gw is 160 USD..200 less the 40 taken // by the offer @@ -1601,7 +1602,8 @@ public: BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] == "475"); auto jro = ledgerEntryOffer(env, carol, carolOfferSeq); - BEAST_EXPECT(jro[jss::node][jss::TakerGets] == usd(25).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jro[jss::node][jss::TakerGets] == usd(25).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jro[jss::node][jss::TakerPays] == XRP(250).value().getText()); } @@ -1643,7 +1645,8 @@ public: auto jro = ledgerEntryOffer(env, carol, carolOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(250).value().getText()); - BEAST_EXPECT(jro[jss::node][jss::TakerPays] == usd(25).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jro[jss::node][jss::TakerPays] == usd(25).value().getJson(JsonOptions::Values::None)); } void @@ -1678,7 +1681,7 @@ public: auto const danOfferSeq = env.seq(dan); env(offer(dan, XRP(500), eur(50))); - json::Value jtp{json::ArrayValue}; + json::Value jtp{json::ValueType::Array}; jtp[0u][0u][jss::currency] = "XRP"; env(pay(alice, bob, eur(30)), Json(jss::Paths, jtp), Sendmax(usd(333))); @@ -1690,11 +1693,13 @@ public: auto jro = ledgerEntryOffer(env, carol, carolOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(200).value().getText()); BEAST_EXPECT( - jro[jss::node][jss::TakerPays] == usd(20).value().getJson(JsonOptions::KNone)); + jro[jss::node][jss::TakerPays] == + usd(20).value().getJson(JsonOptions::Values::None)); jro = ledgerEntryOffer(env, dan, danOfferSeq); BEAST_EXPECT( - jro[jss::node][jss::TakerGets] == eur(20).value().getJson(JsonOptions::KNone)); + jro[jss::node][jss::TakerGets] == + eur(20).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jro[jss::node][jss::TakerPays] == XRP(200).value().getText()); }; testHelper2TokensMix(test); @@ -1970,7 +1975,8 @@ public: payment[jss::tx_json][jss::Sequence] = env.current()->read(keylet::account(bob.id()))->getFieldU32(sfSequence); payment[jss::tx_json][jss::Fee] = to_string(env.current()->fees().base); - payment[jss::tx_json][jss::SendMax] = xts(15).value().getJson(JsonOptions::KNone); + payment[jss::tx_json][jss::SendMax] = + xts(15).value().getJson(JsonOptions::Values::None); auto jrr = wsc->invoke("submit", payment); BEAST_EXPECT(jrr[jss::status] == "success"); BEAST_EXPECT(jrr[jss::result][jss::engine_result] == "tesSUCCESS"); diff --git a/src/test/app/Offer_test.cpp b/src/test/app/Offer_test.cpp index 5d5f16981c..7d6bab60c0 100644 --- a/src/test/app/Offer_test.cpp +++ b/src/test/app/Offer_test.cpp @@ -1572,7 +1572,7 @@ public: auto jro = ledgerEntryOffer(env, bob, bobOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(500).value().getText()); BEAST_EXPECT( - jro[jss::node][jss::TakerPays] == usd(100).value().getJson(JsonOptions::KNone)); + jro[jss::node][jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None)); env(pay(alice, alice, XRP(500)), Sendmax(usd(100))); @@ -1651,7 +1651,8 @@ public: // The previous payment reduced the remaining offer amount by 200 XRP auto jro = ledgerEntryOffer(env, bob, bobOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(300).value().getText()); - BEAST_EXPECT(jro[jss::node][jss::TakerPays] == usd(60).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jro[jss::node][jss::TakerPays] == usd(60).value().getJson(JsonOptions::Values::None)); // the balance between alice and gw is 160 USD..200 less the 40 taken // by the offer @@ -1732,7 +1733,8 @@ public: BEAST_EXPECT(jrr[jss::node][sfBalance.fieldName][jss::value] == "-475"); auto jro = ledgerEntryOffer(env, carol, carolOfferSeq); - BEAST_EXPECT(jro[jss::node][jss::TakerGets] == usd(25).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jro[jss::node][jss::TakerGets] == usd(25).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jro[jss::node][jss::TakerPays] == XRP(250).value().getText()); } @@ -1777,7 +1779,8 @@ public: auto jro = ledgerEntryOffer(env, carol, carolOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(250).value().getText()); - BEAST_EXPECT(jro[jss::node][jss::TakerPays] == usd(25).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jro[jss::node][jss::TakerPays] == usd(25).value().getJson(JsonOptions::Values::None)); } void @@ -1815,7 +1818,7 @@ public: auto const danOfferSeq = env.seq(dan); env(offer(dan, XRP(500), eur(50))); - json::Value jtp{json::ArrayValue}; + json::Value jtp{json::ValueType::Array}; jtp[0u][0u][jss::currency] = "XRP"; env(pay(alice, bob, eur(30)), Json(jss::Paths, jtp), Sendmax(usd(333))); @@ -1833,11 +1836,13 @@ public: auto jro = ledgerEntryOffer(env, carol, carolOfferSeq); BEAST_EXPECT(jro[jss::node][jss::TakerGets] == XRP(200).value().getText()); - BEAST_EXPECT(jro[jss::node][jss::TakerPays] == usd(20).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jro[jss::node][jss::TakerPays] == usd(20).value().getJson(JsonOptions::Values::None)); jro = ledgerEntryOffer(env, dan, danOfferSeq); BEAST_EXPECT( - jro[jss::node][jss::TakerGets] == gw2["EUR"](20).value().getJson(JsonOptions::KNone)); + jro[jss::node][jss::TakerGets] == + gw2["EUR"](20).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jro[jss::node][jss::TakerPays] == XRP(200).value().getText()); } @@ -2149,7 +2154,8 @@ public: payment[jss::tx_json][jss::Sequence] = env.current()->read(keylet::account(bob.id()))->getFieldU32(sfSequence); payment[jss::tx_json][jss::Fee] = to_string(env.current()->fees().base); - payment[jss::tx_json][jss::SendMax] = bob["XTS"](1.5).value().getJson(JsonOptions::KNone); + payment[jss::tx_json][jss::SendMax] = + bob["XTS"](1.5).value().getJson(JsonOptions::Values::None); auto jrr = wsc->invoke("submit", payment); BEAST_EXPECT(jrr[jss::status] == "success"); BEAST_EXPECT(jrr[jss::result][jss::engine_result] == "tesSUCCESS"); diff --git a/src/test/app/PathMPT_test.cpp b/src/test/app/PathMPT_test.cpp index ef8aa587f8..c09bc83be8 100644 --- a/src/test/app/PathMPT_test.cpp +++ b/src/test/app/PathMPT_test.cpp @@ -48,14 +48,14 @@ rpf(jtx::Account const& src, xrpl::test::jtx::MPT const& usd, std::vector const& numSrc) { - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::command] = "ripple_path_find"; jv[jss::source_account] = toBase58(src); if (!numSrc.empty()) { - auto& sc = (jv[jss::source_currencies] = json::ArrayValue); - json::Value j = json::ObjectValue; + auto& sc = (jv[jss::source_currencies] = json::ValueType::Array); + json::Value j = json::ValueType::Object; for (auto const& id : numSrc) { j[jss::mpt_issuance_id] = to_string(id); @@ -66,7 +66,7 @@ rpf(jtx::Account const& src, auto const d = toBase58(dst); jv[jss::destination_account] = d; - json::Value& j = (jv[jss::destination_amount] = json::ObjectValue); + json::Value& j = (jv[jss::destination_amount] = json::ValueType::Object); j[jss::mpt_issuance_id] = to_string(usd.mpt()); j[jss::value] = "1"; diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp index 9424bc05bf..cfdc954578 100644 --- a/src/test/app/Path_test.cpp +++ b/src/test/app/Path_test.cpp @@ -63,14 +63,14 @@ namespace xrpl::test { json::Value rpf(jtx::Account const& src, jtx::Account const& dst, std::uint32_t numSrc) { - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::command] = "ripple_path_find"; jv[jss::source_account] = toBase58(src); if (numSrc > 0) { - auto& sc = (jv[jss::source_currencies] = json::ArrayValue); - json::Value j = json::ObjectValue; + auto& sc = (jv[jss::source_currencies] = json::ValueType::Array); + json::Value j = json::ValueType::Object; while ((numSrc--) != 0u) { j[jss::currency] = std::to_string(numSrc + 100); @@ -81,7 +81,7 @@ rpf(jtx::Account const& src, jtx::Account const& dst, std::uint32_t numSrc) auto const d = toBase58(dst); jv[jss::destination_account] = d; - json::Value& j = (jv[jss::destination_amount] = json::ObjectValue); + json::Value& j = (jv[jss::destination_amount] = json::ValueType::Object); j[jss::currency] = "USD"; j[jss::value] = "0.01"; j[jss::issuer] = d; @@ -168,17 +168,17 @@ public: {}, {}}; - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::command] = "ripple_path_find"; params[jss::source_account] = toBase58(src); params[jss::destination_account] = toBase58(dst); - params[jss::destination_amount] = saDstAmount.getJson(JsonOptions::KNone); + params[jss::destination_amount] = saDstAmount.getJson(JsonOptions::Values::None); if (saSendMax) - params[jss::send_max] = saSendMax->getJson(JsonOptions::KNone); + params[jss::send_max] = saSendMax->getJson(JsonOptions::Values::None); if (saSrcCurrency) { - auto& sc = params[jss::source_currencies] = json::ArrayValue; - json::Value j = json::ObjectValue; + auto& sc = params[jss::source_currencies] = json::ValueType::Array; + json::Value j = json::ValueType::Object; j[jss::currency] = to_string(saSrcCurrency.value()); sc.append(j); } @@ -881,7 +881,7 @@ public: jv); auto const jvL = env.le(keylet::line(Account("bob").id(), Account("alice")["USD"])) - ->getJson(JsonOptions::KNone); + ->getJson(JsonOptions::Values::None); for (auto it = jv.begin(); it != jv.end(); ++it) BEAST_EXPECT(*it == jvL[it.memberName()]); } @@ -923,7 +923,7 @@ public: jv); auto const jvL = env.le(keylet::line(Account("bob").id(), Account("alice")["USD"])) - ->getJson(JsonOptions::KNone); + ->getJson(JsonOptions::Values::None); for (auto it = jv.begin(); it != jv.end(); ++it) BEAST_EXPECT(*it == jvL[it.memberName()]); @@ -973,7 +973,7 @@ public: jv); auto const jvL = env.le(keylet::line(Account("alice").id(), Account("bob")["USD"])) - ->getJson(JsonOptions::KNone); + ->getJson(JsonOptions::Values::None); for (auto it = jv.begin(); it != jv.end(); ++it) BEAST_EXPECT(*it == jvL[it.memberName()]); diff --git a/src/test/app/PayChan_test.cpp b/src/test/app/PayChan_test.cpp index c775dd2b6a..2deecefef6 100644 --- a/src/test/app/PayChan_test.cpp +++ b/src/test/app/PayChan_test.cpp @@ -1029,9 +1029,9 @@ struct PayChan_test : public beast::unit_test::Suite testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } { // test destination_account non-string @@ -1048,9 +1048,9 @@ struct PayChan_test : public beast::unit_test::Suite testInvalidDestAccountParam(1); testInvalidDestAccountParam(1.1); testInvalidDestAccountParam(true); - testInvalidDestAccountParam(json::Value(json::NullValue)); - testInvalidDestAccountParam(json::Value(json::ObjectValue)); - testInvalidDestAccountParam(json::Value(json::ArrayValue)); + testInvalidDestAccountParam(json::Value(json::ValueType::Null)); + testInvalidDestAccountParam(json::Value(json::ValueType::Object)); + testInvalidDestAccountParam(json::Value(json::ValueType::Array)); } { auto const r = env.rpc("account_channels", alice.human(), bob.human()); @@ -1127,7 +1127,7 @@ struct PayChan_test : public beast::unit_test::Suite auto testLimit = [](test::jtx::Env& env, test::jtx::Account const& src, std::optional limit = std::nullopt, - json::Value const& marker = json::NullValue, + json::Value const& marker = json::ValueType::Null, std::optional const& dst = std::nullopt) { json::Value jvc; jvc[jss::account] = src.human(); @@ -1161,7 +1161,7 @@ struct PayChan_test : public beast::unit_test::Suite auto const numFull = bobs.size() / limit; auto const numNonFull = ((bobs.size() % limit) != 0u) ? 1 : 0; - json::Value marker = json::NullValue; + json::Value marker = json::ValueType::Null; auto const testIt = [&](bool expectMarker, int expectedBatchSize) { auto const r = testLimit(env, alice, limit, marker); @@ -1251,7 +1251,7 @@ struct PayChan_test : public beast::unit_test::Suite env(create(alice, bob, channelFunds, settleDelay, pk)); env.close(); - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::channel_id] = chan1Str; args[jss::key_type] = "ed255191"; args[jss::seed] = "snHq1rzQoN2qiUkC3XF5RyxBzUtN"; @@ -1482,7 +1482,7 @@ struct PayChan_test : public beast::unit_test::Suite BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed"); { // Missing channel_id - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::amount] = "2000"; args[jss::key_type] = "secp256k1"; args[jss::passphrase] = "passphrase_can_be_anything"; @@ -1491,7 +1491,7 @@ struct PayChan_test : public beast::unit_test::Suite } { // Missing amount - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::channel_id] = chan1Str; args[jss::key_type] = "secp256k1"; args[jss::passphrase] = "passphrase_can_be_anything"; @@ -1500,7 +1500,7 @@ struct PayChan_test : public beast::unit_test::Suite } { // Missing key_type and no secret. - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::amount] = "2000"; args[jss::channel_id] = chan1Str; args[jss::passphrase] = "passphrase_can_be_anything"; @@ -1509,7 +1509,7 @@ struct PayChan_test : public beast::unit_test::Suite } { // Both passphrase and seed specified. - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::amount] = "2000"; args[jss::channel_id] = chan1Str; args[jss::key_type] = "secp256k1"; @@ -1520,7 +1520,7 @@ struct PayChan_test : public beast::unit_test::Suite } { // channel_id is not exact hex. - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::amount] = "2000"; args[jss::channel_id] = chan1Str + "1"; args[jss::key_type] = "secp256k1"; @@ -1530,7 +1530,7 @@ struct PayChan_test : public beast::unit_test::Suite } { // amount is not a string - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::amount] = 2000; args[jss::channel_id] = chan1Str; args[jss::key_type] = "secp256k1"; @@ -1540,7 +1540,7 @@ struct PayChan_test : public beast::unit_test::Suite } { // Amount is not a decimal string. - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::amount] = "TwoThousand"; args[jss::channel_id] = chan1Str; args[jss::key_type] = "secp256k1"; diff --git a/src/test/app/PermissionedDEX_test.cpp b/src/test/app/PermissionedDEX_test.cpp index a0b16aa557..45b4a58901 100644 --- a/src/test/app/PermissionedDEX_test.cpp +++ b/src/test/app/PermissionedDEX_test.cpp @@ -1392,13 +1392,12 @@ class PermissionedDEX_test : public beast::unit_test::Suite void testHybridMalformedOffer(FeatureBitset features) { - bool const fixS313Enabled = features[fixSecurity3_1_3]; + bool const fixEnabled = features[fixCleanup3_1_3]; testcase << "Hybrid offer with empty AdditionalBooks" - << (fixS313Enabled ? " (fixSecurity3_1_3 enabled)" - : " (fixSecurity3_1_3 disabled)"); + << (fixEnabled ? " (fixCleanup3_1_3 enabled)" : " (fixCleanup3_1_3 disabled)"); - // offerInDomain has two code paths gated by fixSecurity3_1_3: + // offerInDomain has two code paths gated by fixCleanup3_1_3: // // pre-fix: only rejects a hybrid offer when sfAdditionalBooks is // entirely absent — an empty array (size 0) passes through. @@ -1425,7 +1424,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite // Directly manipulate the offer SLE in the open ledger so that // sfAdditionalBooks is present but empty (size 0). This is the - // malformed state that fixSecurity3_1_3 is designed to catch. + // malformed state that fixCleanup3_1_3 is designed to catch. auto const offerKey = keylet::offer(bob.id(), bobOfferSeq); env.app().getOpenLedger().modify([&offerKey](OpenView& view, beast::Journal) { auto const sle = view.read(offerKey); @@ -1437,9 +1436,9 @@ class PermissionedDEX_test : public beast::unit_test::Suite return true; }); - if (fixS313Enabled) + if (fixEnabled) { - // post-fixSecurity3_1_3: offerInDomain rejects the malformed + // post-fixCleanup3_1_3: offerInDomain rejects the malformed // offer (size == 0), so no valid domain offer is found. env(pay(alice, carol, USD(10)), Path(~USD), @@ -1449,7 +1448,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite } else { - // pre-fixSecurity3_1_3: offerInDomain only checks for a missing + // pre-fixCleanup3_1_3: offerInDomain only checks for a missing // sfAdditionalBooks field; size == 0 passes through, so the // malformed offer is crossed and the payment succeeds. env(pay(alice, carol, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID)); @@ -1478,7 +1477,7 @@ public: testHybridInvalidOffer(all); testHybridOfferDirectories(all); testHybridMalformedOffer(all); - testHybridMalformedOffer(all - fixSecurity3_1_3); + testHybridMalformedOffer(all - fixCleanup3_1_3); } }; diff --git a/src/test/app/PermissionedDomains_test.cpp b/src/test/app/PermissionedDomains_test.cpp index a49f913861..0593b06eaa 100644 --- a/src/test/app/PermissionedDomains_test.cpp +++ b/src/test/app/PermissionedDomains_test.cpp @@ -49,14 +49,10 @@ exceptionExpected(Env& env, json::Value const& jv) class PermissionedDomains_test : public beast::unit_test::Suite { - FeatureBitset withoutFeature_{testableAmendments() - featurePermissionedDomains}; FeatureBitset withFeature_{ - testableAmendments() // - | featurePermissionedDomains | featureCredentials}; - + (testableAmendments() | featurePermissionedDomains | featureCredentials) - fixCleanup3_1_3}; FeatureBitset withFix_{ - testableAmendments() // - | featurePermissionedDomains | featureCredentials}; + testableAmendments() | featurePermissionedDomains | featureCredentials | fixCleanup3_1_3}; // Verify that each tx type can execute if the feature is enabled. void @@ -98,7 +94,7 @@ class PermissionedDomains_test : public beast::unit_test::Suite { testcase("Disabled"); Account const alice("alice"); - Env env(*this, withoutFeature_); + Env env(*this, testableAmendments() - featurePermissionedDomains); env.fund(XRP(1000), alice); pdomain::Credentials const credentials{{alice, "first credential"}}; env(pdomain::setTx(alice, credentials), Ter(temDISABLED)); @@ -298,7 +294,7 @@ class PermissionedDomains_test : public beast::unit_test::Suite { env(pdomain::setTx(alice[0], credentials1)); BEAST_EXPECT(env.ownerCount(alice[0]) == 1); - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); BEAST_EXPECT(tx[jss::TransactionType] == "PermissionedDomainSet"); BEAST_EXPECT(tx["Account"] == alice[0].human()); auto objects = pdomain::getObjects(alice[0], env); @@ -325,7 +321,7 @@ class PermissionedDomains_test : public beast::unit_test::Suite // One account can create multiple domains BEAST_EXPECT(env.ownerCount(alice[0]) == 2); - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); BEAST_EXPECT(tx[jss::TransactionType] == "PermissionedDomainSet"); BEAST_EXPECT(tx["Account"] == alice[0].human()); @@ -365,7 +361,7 @@ class PermissionedDomains_test : public beast::unit_test::Suite BEAST_EXPECT(credentials10.size() == kMAX_PERMISSIONED_DOMAIN_CREDENTIALS_ARRAY_SIZE); BEAST_EXPECT(credentials10 != pdomain::sortCredentials(credentials10)); env(pdomain::setTx(alice[0], credentials10)); - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); domain2 = pdomain::getNewDomain(env.meta()); auto objects = pdomain::getObjects(alice[0], env); auto object = objects[domain2]; @@ -470,7 +466,7 @@ class PermissionedDomains_test : public beast::unit_test::Suite // Delete domain that belongs to user. env(pdomain::deleteTx(alice, domain)); - auto const tx = env.tx()->getJson(JsonOptions::KNone); + auto const tx = env.tx()->getJson(JsonOptions::Values::None); BEAST_EXPECT(tx[jss::TransactionType] == "PermissionedDomainDelete"); // Make sure the owner count goes back to 0. diff --git a/src/test/app/Regression_test.cpp b/src/test/app/Regression_test.cpp index d7c92f1748..fdcf03e53c 100644 --- a/src/test/app/Regression_test.cpp +++ b/src/test/app/Regression_test.cpp @@ -202,7 +202,7 @@ struct Regression_test : public beast::unit_test::Suite auto const alice = Account("alice"); env.fund(XRP(100000), alice); - auto params = json::Value(json::ObjectValue); + auto params = json::Value(json::ValueType::Object); // Max fee = 50k drops params[jss::fee_mult_max] = 5000; std::vector const expectedFees({10, 10, 8889, 13889, 20000}); @@ -299,7 +299,7 @@ struct Regression_test : public beast::unit_test::Suite SHAMapHash digest; if (!state.peekItem(bobIndex, digest)) return std::nullopt; - return digest.asUint256(); + return digest.asUInt256(); }(); auto const mapCounts = [&](CountedObjects::List const& list) { diff --git a/src/test/app/SetAuth_test.cpp b/src/test/app/SetAuth_test.cpp index f2e6aa29cc..df0c6fe5d0 100644 --- a/src/test/app/SetAuth_test.cpp +++ b/src/test/app/SetAuth_test.cpp @@ -32,7 +32,7 @@ struct SetAuth_test : public beast::unit_test::Suite json::Value jv; jv[jss::Account] = account.human(); jv[jss::LimitAmount] = - STAmount(Issue{toCurrency(currency), dest}).getJson(JsonOptions::KNone); + STAmount(Issue{toCurrency(currency), dest}).getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::TrustSet; jv[jss::Flags] = tfSetfAuth; return jv; diff --git a/src/test/app/SetRegularKey_test.cpp b/src/test/app/SetRegularKey_test.cpp index 00b1fe3f84..b9cba43011 100644 --- a/src/test/app/SetRegularKey_test.cpp +++ b/src/test/app/SetRegularKey_test.cpp @@ -84,15 +84,12 @@ public: env.fund(XRP(10000), alice, bob); auto ar = env.le(alice); - BEAST_EXPECT( - ar->isFieldPresent(sfFlags) && ((ar->getFieldU32(sfFlags) & lsfPasswordSpent) == 0)); + BEAST_EXPECT(ar->isFieldPresent(sfFlags) && !ar->isFlag(lsfPasswordSpent)); env(regkey(alice, bob), Sig(alice), Fee(0)); ar = env.le(alice); - BEAST_EXPECT( - ar->isFieldPresent(sfFlags) && - ((ar->getFieldU32(sfFlags) & lsfPasswordSpent) == lsfPasswordSpent)); + BEAST_EXPECT(ar->isFieldPresent(sfFlags) && ar->isFlag(lsfPasswordSpent)); // The second SetRegularKey transaction with Fee=0 should fail. env(regkey(alice, bob), Sig(alice), Fee(0), Ter(telINSUF_FEE_P)); @@ -100,8 +97,7 @@ public: env.trust(bob["USD"](1), alice); env(pay(bob, alice, bob["USD"](1))); ar = env.le(alice); - BEAST_EXPECT( - ar->isFieldPresent(sfFlags) && ((ar->getFieldU32(sfFlags) & lsfPasswordSpent) == 0)); + BEAST_EXPECT(ar->isFieldPresent(sfFlags) && !ar->isFlag(lsfPasswordSpent)); } void diff --git a/src/test/app/Ticket_test.cpp b/src/test/app/Ticket_test.cpp index d266ec12d2..83bcc8676e 100644 --- a/src/test/app/Ticket_test.cpp +++ b/src/test/app/Ticket_test.cpp @@ -55,7 +55,7 @@ class Ticket_test : public beast::unit_test::Suite { using namespace std::string_literals; - json::Value const& tx{env.tx()->getJson(JsonOptions::KNone)}; + json::Value const& tx{env.tx()->getJson(JsonOptions::Values::None)}; { std::string const txType = tx[sfTransactionType.jsonName].asString(); @@ -71,7 +71,7 @@ class Ticket_test : public beast::unit_test::Suite std::uint32_t const txSeq = {tx[sfSequence.jsonName].asUInt()}; std::string const account = tx[sfAccount.jsonName].asString(); - json::Value const& metadata = env.meta()->getJson(JsonOptions::KNone); + json::Value const& metadata = env.meta()->getJson(JsonOptions::Values::None); if (!BEAST_EXPECTS( metadata.isMember(sfTransactionResult.jsonName) && metadata[sfTransactionResult.jsonName].asString() == "tesSUCCESS", @@ -241,7 +241,7 @@ class Ticket_test : public beast::unit_test::Suite void checkTicketConsumeMeta(test::jtx::Env& env) { - json::Value const& tx{env.tx()->getJson(JsonOptions::KNone)}; + json::Value const& tx{env.tx()->getJson(JsonOptions::Values::None)}; // Verify that the transaction includes a TicketSequence. @@ -274,7 +274,7 @@ class Ticket_test : public beast::unit_test::Suite std::uint32_t const ticketSeq{tx[sfTicketSequence.jsonName].asUInt()}; - json::Value const& metadata{env.meta()->getJson(JsonOptions::KNone)}; + json::Value const& metadata{env.meta()->getJson(JsonOptions::Values::None)}; if (!BEAST_EXPECTS( metadata.isMember(sfTransactionResult.jsonName), "Metadata is missing TransactionResult.")) @@ -783,7 +783,7 @@ class Ticket_test : public beast::unit_test::Suite // Create a noop transaction using a TicketSequence but don't fill // in the Sequence field. - json::Value tx = json::ObjectValue; + json::Value tx = json::ValueType::Object; tx[jss::tx_json] = noop(alice); tx[jss::tx_json][sfTicketSequence.jsonName] = ticketSeq; tx[jss::secret] = toBase58(generateSeed("alice")); @@ -816,7 +816,7 @@ class Ticket_test : public beast::unit_test::Suite // Create a noop transaction using a TicketSequence but don't fill // in the Sequence field. - json::Value tx = json::ObjectValue; + json::Value tx = json::ValueType::Object; tx[jss::tx_json] = noop(alice); tx[jss::tx_json][sfTicketSequence.jsonName] = ticketSeq + 1; tx[jss::secret] = toBase58(generateSeed("alice")); diff --git a/src/test/app/TrustAndBalance_test.cpp b/src/test/app/TrustAndBalance_test.cpp index fe3d442f73..78670bf6fb 100644 --- a/src/test/app/TrustAndBalance_test.cpp +++ b/src/test/app/TrustAndBalance_test.cpp @@ -215,9 +215,9 @@ class TrustAndBalance_test : public beast::unit_test::Suite if (subscribe) { json::Value jvs; - jvs[jss::accounts] = json::ArrayValue; + jvs[jss::accounts] = json::ValueType::Array; jvs[jss::accounts].append(gw.human()); - jvs[jss::streams] = json::ArrayValue; + jvs[jss::streams] = json::ValueType::Array; jvs[jss::streams].append("transactions"); jvs[jss::streams].append("ledger"); auto jv = wsc->invoke("subscribe", jvs); @@ -400,9 +400,9 @@ class TrustAndBalance_test : public beast::unit_test::Suite env.close(); json::Value jvs; - jvs[jss::accounts] = json::ArrayValue; + jvs[jss::accounts] = json::ValueType::Array; jvs[jss::accounts].append(env.master.human()); - jvs[jss::streams] = json::ArrayValue; + jvs[jss::streams] = json::ValueType::Array; jvs[jss::streams].append("transactions"); BEAST_EXPECT(wsc->invoke("subscribe", jvs)[jss::status] == "success"); diff --git a/src/test/app/TrustSet_test.cpp b/src/test/app/TrustSet_test.cpp index 31b7e97ee7..e9f0553840 100644 --- a/src/test/app/TrustSet_test.cpp +++ b/src/test/app/TrustSet_test.cpp @@ -284,7 +284,7 @@ public: { json::Value jv; jv[jss::Account] = a.human(); - jv[jss::LimitAmount] = amt.getJson(JsonOptions::KNone); + jv[jss::LimitAmount] = amt.getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::TrustSet; jv[jss::Flags] = 0; return jv; diff --git a/src/test/app/TxQ_test.cpp b/src/test/app/TxQ_test.cpp index 52781ee9e3..c950739078 100644 --- a/src/test/app/TxQ_test.cpp +++ b/src/test/app/TxQ_test.cpp @@ -1023,16 +1023,21 @@ public: checkMetrics(*this, env, 0, std::nullopt, 0, 3); // ledgers in queue is 2 because of makeConfig - auto const initQueueMax = initFee(env, 3, 2, 10, 200, 50); + initFee(env, 3, 2, 10, 200, 50); + // Close an empty ledger to shrink queue from the flag-ledger + // size to 2*3=6, independent of amendment count. + env.close(); + constexpr std::size_t kINIT_QUEUE_MAX = 6; + checkMetrics(*this, env, 0, kINIT_QUEUE_MAX, 0, 3); // Create several accounts while the fee is cheap so they all apply. env.fund(drops(2000), noripple(alice)); env.fund(XRP(500000), noripple(bob, charlie, daria)); - checkMetrics(*this, env, 0, initQueueMax, 4, 3); + checkMetrics(*this, env, 0, kINIT_QUEUE_MAX, 4, 3); // Alice - price starts exploding: held env(noop(alice), Fee(11), queued); - checkMetrics(*this, env, 1, initQueueMax, 4, 3); + checkMetrics(*this, env, 1, kINIT_QUEUE_MAX, 4, 3); auto aliceSeq = env.seq(alice); auto bobSeq = env.seq(bob); @@ -1040,28 +1045,28 @@ public: // Alice - try to queue a second transaction, but leave a gap env(noop(alice), Seq(aliceSeq + 2), Fee(100), Ter(telCAN_NOT_QUEUE)); - checkMetrics(*this, env, 1, initQueueMax, 4, 3); + checkMetrics(*this, env, 1, kINIT_QUEUE_MAX, 4, 3); // Alice - queue a second transaction. Yay! env(noop(alice), Seq(aliceSeq + 1), Fee(13), queued); - checkMetrics(*this, env, 2, initQueueMax, 4, 3); + checkMetrics(*this, env, 2, kINIT_QUEUE_MAX, 4, 3); // Alice - queue a third transaction. Yay. env(noop(alice), Seq(aliceSeq + 2), Fee(17), queued); - checkMetrics(*this, env, 3, initQueueMax, 4, 3); + checkMetrics(*this, env, 3, kINIT_QUEUE_MAX, 4, 3); // Bob - queue a transaction env(noop(bob), queued); - checkMetrics(*this, env, 4, initQueueMax, 4, 3); + checkMetrics(*this, env, 4, kINIT_QUEUE_MAX, 4, 3); // Bob - queue a second transaction env(noop(bob), Seq(bobSeq + 1), Fee(50), queued); - checkMetrics(*this, env, 5, initQueueMax, 4, 3); + checkMetrics(*this, env, 5, kINIT_QUEUE_MAX, 4, 3); // Charlie - queue a transaction, with a higher fee // than default env(noop(charlie), Fee(15), queued); - checkMetrics(*this, env, 6, initQueueMax, 4, 3, 257); + checkMetrics(*this, env, 6, kINIT_QUEUE_MAX, 4, 3, 257); BEAST_EXPECT(env.seq(alice) == aliceSeq); BEAST_EXPECT(env.seq(bob) == bobSeq); @@ -2789,7 +2794,7 @@ public: auto const aliceSeq = env.seq(alice); auto const lastLedgerSeq = env.current()->header().seq + 2; - auto submitParams = json::Value(json::ObjectValue); + auto submitParams = json::Value(json::ValueType::Object); for (int i = 0; i < 5; ++i) { if (i == 2) @@ -2974,7 +2979,7 @@ public: BEAST_EXPECT(!queueData.isMember(jss::transactions)); } - auto submitParams = json::Value(json::ObjectValue); + auto submitParams = json::Value(json::ValueType::Object); envs(noop(alice), Fee(baseFee * 10), Seq(kNONE), Ter(terQUEUED))(submitParams); envs(noop(alice), Fee(baseFee * 10), Seq(kNONE), Ter(terQUEUED))(submitParams); envs(noop(alice), Fee(baseFee * 10), Seq(kNONE), Ter(terQUEUED))(submitParams); @@ -3220,7 +3225,7 @@ public: checkMetrics(*this, env, 0, 6, 4, 3); auto aliceSeq = env.seq(alice); - auto submitParams = json::Value(json::ObjectValue); + auto submitParams = json::Value(json::ValueType::Object); for (auto i = 0; i < 4; ++i) envs(noop(alice), Fee(baseFee * 10), Seq(aliceSeq + i), Ter(terQUEUED))(submitParams); checkMetrics(*this, env, 4, 6, 4, 3); @@ -3407,7 +3412,7 @@ public: auto const baseFee = env.current()->fees().base.drops(); json::Value stream; - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("server"); auto wsc = makeWSClient(env.app().config()); { diff --git a/src/test/app/ValidatorKeys_test.cpp b/src/test/app/ValidatorKeys_test.cpp index fa8ec7ea3d..83267bf0a7 100644 --- a/src/test/app/ValidatorKeys_test.cpp +++ b/src/test/app/ValidatorKeys_test.cpp @@ -66,7 +66,7 @@ public: { // We're only using Env for its Journal. That Journal gives better // coverage in unit tests. - test::jtx::Env env{*this, test::jtx::envconfig(), nullptr, beast::severities::KDisabled}; + test::jtx::Env env{*this, test::jtx::envconfig(), nullptr, beast::Severity::Disabled}; beast::Journal const journal{env.app().getJournal("ValidatorKeys_test")}; // Keys/ID when using [validation_seed] diff --git a/src/test/app/ValidatorList_test.cpp b/src/test/app/ValidatorList_test.cpp index 52ab2e69aa..5cde63fdc3 100644 --- a/src/test/app/ValidatorList_test.cpp +++ b/src/test/app/ValidatorList_test.cpp @@ -220,7 +220,7 @@ private: { testcase("Config Load"); - jtx::Env env(*this, jtx::envconfig(), nullptr, beast::severities::KDisabled); + jtx::Env env(*this, jtx::envconfig(), nullptr, beast::Severity::Disabled); auto& app = env.app(); std::vector const emptyCfgKeys; std::vector const emptyCfgPublishers; diff --git a/src/test/app/ValidatorSite_test.cpp b/src/test/app/ValidatorSite_test.cpp index 4145b4f8b1..ff0da77fa1 100644 --- a/src/test/app/ValidatorSite_test.cpp +++ b/src/test/app/ValidatorSite_test.cpp @@ -62,7 +62,7 @@ private: using namespace jtx; - Env env(*this, envconfig(), nullptr, beast::severities::KDisabled); + Env env(*this, envconfig(), nullptr, beast::Severity::Disabled); auto trustedSites = std::make_unique(env.app(), env.journal); // load should accept empty sites list diff --git a/src/test/app/Vault_test.cpp b/src/test/app/Vault_test.cpp index b0b93e0b3f..2f32cf605a 100644 --- a/src/test/app/Vault_test.cpp +++ b/src/test/app/Vault_test.cpp @@ -206,7 +206,7 @@ class Vault_test : public beast::unit_test::Suite { testcase(prefix + " fail to set domain on public vault"); auto tx = vault.set({.owner = owner, .id = keylet.key}); - tx[sfDomainID] = to_string(BaseUint<256>(42ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(42ul)); env(tx, Ter{tecNO_PERMISSION}); env.close(); } @@ -678,14 +678,14 @@ class Vault_test : public beast::unit_test::Suite env(tx); tx[sfFlags] = tx[sfFlags].asUInt() | tfVaultPrivate; - tx[sfDomainID] = to_string(BaseUint<256>(42ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(42ul)); env(tx, Ter{temDISABLED}); { auto tx = vault.set({.owner = owner, .id = keylet.key}); env(tx, kDATA("Test")); - tx[sfDomainID] = to_string(BaseUint<256>(13ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(13ul)); env(tx, Ter{temDISABLED}); } }, @@ -786,12 +786,12 @@ class Vault_test : public beast::unit_test::Suite testcase("disabled permissioned domain"); auto [tx, keylet] = vault.create({.owner = owner, .asset = xrpIssue()}); - tx[sfDomainID] = to_string(BaseUint<256>(42ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(42ul)); env(tx, Ter{temDISABLED}); { auto tx = vault.set({.owner = owner, .id = keylet.key}); - tx[sfDomainID] = to_string(BaseUint<256>(42ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(42ul)); env(tx, Ter{temDISABLED}); } @@ -1079,7 +1079,7 @@ class Vault_test : public beast::unit_test::Suite { auto tx = tx1; - tx[sfDomainID] = to_string(BaseUint<256>(42ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(42ul)); env(tx, Ter{temMALFORMED}); } @@ -1238,7 +1238,7 @@ class Vault_test : public beast::unit_test::Suite Vault& vault) { auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); tx[sfFlags] = tfVaultPrivate; - tx[sfDomainID] = to_string(BaseUint<256>(42ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(42ul)); testcase("non-existing domain"); env(tx, Ter{tecOBJECT_NOT_FOUND}); }); @@ -2400,7 +2400,7 @@ class Vault_test : public beast::unit_test::Suite jv[jss::Account] = issuer.human(); { auto& ja = jv[jss::LimitAmount] = - foo(0).value().getJson(JsonOptions::KNone); + foo(0).value().getJson(JsonOptions::Values::None); ja[jss::issuer] = toBase58(account); } jv[jss::TransactionType] = jss::TrustSet; @@ -2453,7 +2453,8 @@ class Vault_test : public beast::unit_test::Suite json::Value jv; jv[jss::Account] = issuer.human(); { - auto& ja = jv[jss::LimitAmount] = asset(0).value().getJson(JsonOptions::KNone); + auto& ja = jv[jss::LimitAmount] = + asset(0).value().getJson(JsonOptions::Values::None); ja[jss::issuer] = toBase58(account); } jv[jss::TransactionType] = jss::TrustSet; @@ -2735,7 +2736,7 @@ class Vault_test : public beast::unit_test::Suite { // Create MPToken for shares held by Charlie - json::Value tx{json::ObjectValue}; + json::Value tx{json::ValueType::Object}; tx[sfAccount] = charlie.human(); tx[sfMPTokenIssuanceID] = to_string(shares.raw().get().getMptID()); @@ -3065,7 +3066,7 @@ class Vault_test : public beast::unit_test::Suite { testcase("private vault cannot set non-existing domain"); auto tx = vault.set({.owner = owner, .id = keylet.key}); - tx[sfDomainID] = to_string(BaseUint<256>(42ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(42ul)); env(tx, Ter{tecOBJECT_NOT_FOUND}); } @@ -3078,7 +3079,7 @@ class Vault_test : public beast::unit_test::Suite env(pdomain::setTx(pdOwner, credentials1)); auto const domainId1 = [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); @@ -3099,7 +3100,7 @@ class Vault_test : public beast::unit_test::Suite env(pdomain::setTx(pdOwner, credentials)); auto const domainId = [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); @@ -3316,7 +3317,7 @@ class Vault_test : public beast::unit_test::Suite env(pdomain::setTx(owner, credentials)); auto const domainId = [&]() { - auto tx = env.tx()->getJson(JsonOptions::KNone); + auto tx = env.tx()->getJson(JsonOptions::Values::None); return pdomain::getNewDomain(env.meta()); }(); @@ -4276,7 +4277,7 @@ class Vault_test : public beast::unit_test::Suite auto const check = [&, keylet = keylet, sle = sleVault, this]( json::Value const& vault, - json::Value const& issuance = json::NullValue) { + json::Value const& issuance = json::ValueType::Null) { BEAST_EXPECT(vault.isObject()); constexpr auto kCHECK_STRING = @@ -4654,7 +4655,7 @@ class Vault_test : public beast::unit_test::Suite using namespace test::jtx; using namespace loanBroker; using namespace loan; - Env env(*this, beast::severities::KWarning); + Env env(*this, beast::Severity::Warning); auto const vaultAssetBalance = [&](Keylet const& vaultKeylet) { auto const sleVault = env.le(vaultKeylet); @@ -4915,7 +4916,7 @@ class Vault_test : public beast::unit_test::Suite using namespace loanBroker; using namespace loan; Env env(*this); - env.enableFeature(fixSecurity3_1_3); + env.enableFeature(fixCleanup3_1_3); auto const setupVault = [&](PrettyAsset const& asset, Account const& owner, @@ -5402,14 +5403,14 @@ class Vault_test : public beast::unit_test::Suite env.close(); testCase(mpt, "MPT", owner, depositor, issuer); - // Test pre-fixSecurity3_1_3 legacy path: zero-amount clawback + // Test pre-fixCleanup3_1_3 legacy path: zero-amount clawback // returns early without clamping to assetsAvailable. { testcase( - "VaultClawback (asset) - IOU pre-fixSecurity3_1_3" + "VaultClawback (asset) - IOU pre-fixCleanup3_1_3" " zero-amount clawback unclamped with outstanding loan"); - env.disableFeature(fixSecurity3_1_3); + env.disableFeature(fixCleanup3_1_3); auto [vault, vaultKeylet] = setupVault(iou, owner, depositor, issuer); @@ -5467,7 +5468,7 @@ class Vault_test : public beast::unit_test::Suite BEAST_EXPECT(sharesAfter == sharesBefore); } - env.enableFeature(fixSecurity3_1_3); + env.enableFeature(fixCleanup3_1_3); } } @@ -5866,7 +5867,7 @@ class Vault_test : public beast::unit_test::Suite { testcase("Vault clawback only recovers unlocked shares"); - Env env{*this, testableAmendments() | fixSecurity3_1_3}; + Env env{*this, testableAmendments() | fixCleanup3_1_3}; auto const baseFee = env.current()->fees().base; Account const owner{"owner"}; Account const depositor{"depositor"}; @@ -5956,9 +5957,9 @@ class Vault_test : public beast::unit_test::Suite auto const allAmendments = testableAmendments() | featureSingleAssetVault; - for (auto const& features : {allAmendments, allAmendments - fixSecurity3_1_3}) + for (auto const& features : {allAmendments, allAmendments - fixCleanup3_1_3}) { - bool const withFix = features[fixSecurity3_1_3]; + bool const withFix = features[fixCleanup3_1_3]; Env env{*this, features}; Account const owner{"owner"}; @@ -6116,7 +6117,7 @@ class Vault_test : public beast::unit_test::Suite env.close(); auto const sleMptAfter = env.le(keylet::mptoken(shareMptID, depositor)); - if (!f[fixSecurity3_1_3]) + if (!f[fixCleanup3_1_3]) { // Without the fix, removeEmptyHolding deletes the MPToken // even though sfLockedAmount > 0, leaving the escrow's locked @@ -6136,7 +6137,7 @@ class Vault_test : public beast::unit_test::Suite } }; - runTest(amendments - fixSecurity3_1_3); + runTest(amendments - fixCleanup3_1_3); runTest(amendments); } diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp index a8899e4e43..07e840a08f 100644 --- a/src/test/app/XChain_test.cpp +++ b/src/test/app/XChain_test.cpp @@ -69,7 +69,7 @@ struct SEnv std::unique_ptr config, FeatureBitset features, std::unique_ptr logs = nullptr, - beast::severities::Severity thresh = beast::severities::KError) + beast::Severity thresh = beast::Severity::Error) : env(s, std::move(config), features, std::move(logs), thresh) { } @@ -2333,7 +2333,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj .minAccountCreate = XRP(20), // minAccountCreate .quorum = 4, // quorum .signers = signers, - .jvb = json::NullValue}; + .jvb = json::ValueType::Null}; xrpB.initBridge(mcEnv, scEnv); @@ -4514,7 +4514,7 @@ public: .minAccountCreate = XRP(20), .quorum = quorum, .signers = signers, - .jvb = json::NullValue}; + .jvb = json::ValueType::Null}; initBridge(xrpB); @@ -4529,7 +4529,7 @@ public: .minAccountCreate = XRP(20), .quorum = quorum, .signers = signers, - .jvb = json::NullValue}; + .jvb = json::ValueType::Null}; initBridge(usdB); diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp index 738990aac2..f789e2dfe1 100644 --- a/src/test/basics/IOUAmount_test.cpp +++ b/src/test/basics/IOUAmount_test.cpp @@ -185,62 +185,62 @@ public: /* The range for the exponent when normalized */ constexpr int kMIN_EXPONENT = -96; constexpr int kMAX_EXPONENT = 80; - constexpr auto kMAX_U_INT = std::numeric_limits::max(); + constexpr auto kMAX_UINT = std::numeric_limits::max(); { // multiply by a number that would overflow the mantissa, then // divide by the same number, and check we didn't lose any value IOUAmount const bigMan(kMAX_MANTISSA, 0); - BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_U_INT, kMAX_U_INT, true)); + BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_UINT, kMAX_UINT, true)); // rounding mode shouldn't matter as the result is exact - BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_U_INT, kMAX_U_INT, false)); + BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_UINT, kMAX_UINT, false)); } { // Similar test as above, but for negative values IOUAmount const bigMan(-kMAX_MANTISSA, 0); - BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_U_INT, kMAX_U_INT, true)); + BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_UINT, kMAX_UINT, true)); // rounding mode shouldn't matter as the result is exact - BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_U_INT, kMAX_U_INT, false)); + BEAST_EXPECT(bigMan == mulRatio(bigMan, kMAX_UINT, kMAX_UINT, false)); } { // small amounts IOUAmount const tiny(kMIN_MANTISSA, kMIN_EXPONENT); // Round up should give the smallest allowable number - BEAST_EXPECT(tiny == mulRatio(tiny, 1, kMAX_U_INT, true)); - BEAST_EXPECT(tiny == mulRatio(tiny, kMAX_U_INT - 1, kMAX_U_INT, true)); + BEAST_EXPECT(tiny == mulRatio(tiny, 1, kMAX_UINT, true)); + BEAST_EXPECT(tiny == mulRatio(tiny, kMAX_UINT - 1, kMAX_UINT, true)); // rounding down should be zero - BEAST_EXPECT(beast::kZERO == mulRatio(tiny, 1, kMAX_U_INT, false)); - BEAST_EXPECT(beast::kZERO == mulRatio(tiny, kMAX_U_INT - 1, kMAX_U_INT, false)); + BEAST_EXPECT(beast::kZERO == mulRatio(tiny, 1, kMAX_UINT, false)); + BEAST_EXPECT(beast::kZERO == mulRatio(tiny, kMAX_UINT - 1, kMAX_UINT, false)); // tiny negative numbers IOUAmount const tinyNeg(-kMIN_MANTISSA, kMIN_EXPONENT); // Round up should give zero - BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, 1, kMAX_U_INT, true)); - BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, kMAX_U_INT - 1, kMAX_U_INT, true)); + BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, 1, kMAX_UINT, true)); + BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, kMAX_UINT - 1, kMAX_UINT, true)); // rounding down should be tiny - BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, 1, kMAX_U_INT, false)); - BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMAX_U_INT - 1, kMAX_U_INT, false)); + BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, 1, kMAX_UINT, false)); + BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMAX_UINT - 1, kMAX_UINT, false)); } { // rounding { IOUAmount const one(1, 0); - auto const rup = mulRatio(one, kMAX_U_INT - 1, kMAX_U_INT, true); - auto const rdown = mulRatio(one, kMAX_U_INT - 1, kMAX_U_INT, false); + auto const rup = mulRatio(one, kMAX_UINT - 1, kMAX_UINT, true); + auto const rdown = mulRatio(one, kMAX_UINT - 1, kMAX_UINT, false); BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1); } { IOUAmount const big(kMAX_MANTISSA, kMAX_EXPONENT); - auto const rup = mulRatio(big, kMAX_U_INT - 1, kMAX_U_INT, true); - auto const rdown = mulRatio(big, kMAX_U_INT - 1, kMAX_U_INT, false); + auto const rup = mulRatio(big, kMAX_UINT - 1, kMAX_UINT, true); + auto const rdown = mulRatio(big, kMAX_UINT - 1, kMAX_UINT, false); BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1); } { IOUAmount const negOne(-1, 0); - auto const rup = mulRatio(negOne, kMAX_U_INT - 1, kMAX_U_INT, true); - auto const rdown = mulRatio(negOne, kMAX_U_INT - 1, kMAX_U_INT, false); + auto const rup = mulRatio(negOne, kMAX_UINT - 1, kMAX_UINT, true); + auto const rdown = mulRatio(negOne, kMAX_UINT - 1, kMAX_UINT, false); BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1); } } diff --git a/src/test/basics/PerfLog_test.cpp b/src/test/basics/PerfLog_test.cpp index 00b2f90c65..c370c241c5 100644 --- a/src/test/basics/PerfLog_test.cpp +++ b/src/test/basics/PerfLog_test.cpp @@ -47,7 +47,7 @@ class PerfLog_test : public beast::unit_test::Suite // We're only using Env for its Journal. That Journal gives better // coverage in unit tests. - test::jtx::Env env_{*this, test::jtx::envconfig(), nullptr, beast::severities::KDisabled}; + test::jtx::Env env_{*this, test::jtx::envconfig(), nullptr, beast::Severity::Disabled}; beast::Journal j_{env_.app().getJournal("PerfLog_test")}; struct Fixture @@ -154,9 +154,9 @@ class PerfLog_test : public beast::unit_test::Suite // Return a uint64 from a JSON string. static std::uint64_t - jsonToUint64(json::Value const& jsonUintAsString) + jsonToUInt64(json::Value const& jsonUIntAsString) { - return std::stoull(jsonUintAsString.asString()); + return std::stoull(jsonUIntAsString.asString()); } // The PerfLog's current state is easier to sort by duration if the @@ -183,7 +183,7 @@ class PerfLog_test : public beast::unit_test::Suite for (json::Value const& cur : currentJson) { currents.emplace_back( - jsonToUint64(cur[jss::duration_us]), + jsonToUInt64(cur[jss::duration_us]), cur.isMember(jss::job) ? cur[jss::job].asString() : cur[jss::method].asString()); } @@ -358,7 +358,7 @@ public: BEAST_EXPECT(total[jss::duration_us] == "0"); BEAST_EXPECT(total[jss::errored] == "0"); BEAST_EXPECT(total[jss::finished] == "0"); - BEAST_EXPECT(jsonToUint64(total[jss::started]) == ids.size()); + BEAST_EXPECT(jsonToUInt64(total[jss::started]) == ids.size()); } { // Verify that every entry in labels appears twice in currents. @@ -416,7 +416,7 @@ public: for (int i = 1; i < labels.size(); ++i) { json::Value const& counter{rpc[labels[i]]}; - std::uint64_t const dur{jsonToUint64(counter[jss::duration_us])}; + std::uint64_t const dur{jsonToUInt64(counter[jss::duration_us])}; BEAST_EXPECT(dur != 0 && dur < prevDur); prevDur = dur; BEAST_EXPECT(counter[jss::errored] == "1"); @@ -427,9 +427,9 @@ public: // Check "total" json::Value const& total{rpc[jss::total]}; BEAST_EXPECT(total[jss::duration_us] != "0"); - BEAST_EXPECT(jsonToUint64(total[jss::errored]) == labels.size() - 1); - BEAST_EXPECT(jsonToUint64(total[jss::finished]) == labels.size()); - BEAST_EXPECT(jsonToUint64(total[jss::started]) == labels.size() * 2); + BEAST_EXPECT(jsonToUInt64(total[jss::errored]) == labels.size() - 1); + BEAST_EXPECT(jsonToUInt64(total[jss::finished]) == labels.size()); + BEAST_EXPECT(jsonToUInt64(total[jss::started]) == labels.size() * 2); }; auto validateFinalCurrent = [this, &labels](json::Value const& currentJson) { @@ -553,7 +553,7 @@ public: // Verify jss::total is present and has expected values. json::Value const& total{jqCounters[jss::total]}; BEAST_EXPECT(total.size() == 5); - BEAST_EXPECT(jsonToUint64(total[jss::queued]) == i + 1); + BEAST_EXPECT(jsonToUInt64(total[jss::queued]) == i + 1); BEAST_EXPECT(total[jss::started] == "0"); BEAST_EXPECT(total[jss::finished] == "0"); BEAST_EXPECT(total[jss::queued_duration_us] == "0"); @@ -589,7 +589,7 @@ public: for (int j = 0; j < jobs.size(); ++j) { json::Value const& counter{jqCounters[jobs[j].typeName]}; - std::uint64_t const queuedDurUs{jsonToUint64(counter[jss::queued_duration_us])}; + std::uint64_t const queuedDurUs{jsonToUInt64(counter[jss::queued_duration_us])}; if (j < i) { BEAST_EXPECT(counter[jss::started] == "2"); @@ -613,13 +613,13 @@ public: { // Verify values in jss::total are what we expect. json::Value const& total{jqCounters[jss::total]}; - BEAST_EXPECT(jsonToUint64(total[jss::queued]) == jobs.size()); - BEAST_EXPECT(jsonToUint64(total[jss::started]) == (i * 2) + 1); + BEAST_EXPECT(jsonToUInt64(total[jss::queued]) == jobs.size()); + BEAST_EXPECT(jsonToUInt64(total[jss::started]) == (i * 2) + 1); BEAST_EXPECT(total[jss::finished] == "0"); // Total queued duration is triangle number of (i + 1). BEAST_EXPECT( - jsonToUint64(total[jss::queued_duration_us]) == (((i * i) + 3 * i + 2) / 2)); + jsonToUInt64(total[jss::queued_duration_us]) == (((i * i) + 3 * i + 2) / 2)); BEAST_EXPECT(total[jss::running_duration_us] == "0"); } @@ -658,7 +658,7 @@ public: for (int j = 0; j < jobs.size(); ++j) { json::Value const& counter{jqCounters[jobs[j].typeName]}; - std::uint64_t const runningDurUs{jsonToUint64(counter[jss::running_duration_us])}; + std::uint64_t const runningDurUs{jsonToUInt64(counter[jss::running_duration_us])}; if (j < i) { BEAST_EXPECT(counter[jss::finished] == "0"); @@ -675,7 +675,7 @@ public: BEAST_EXPECT(runningDurUs == ((jobs.size() - j) * 4) - 1); } - std::uint64_t const queuedDurUs{jsonToUint64(counter[jss::queued_duration_us])}; + std::uint64_t const queuedDurUs{jsonToUInt64(counter[jss::queued_duration_us])}; BEAST_EXPECT(queuedDurUs == j + 1); BEAST_EXPECT(counter[jss::queued] == "1"); BEAST_EXPECT(counter[jss::started] == "2"); @@ -683,18 +683,18 @@ public: { // Verify values in jss::total are what we expect. json::Value const& total{jqCounters[jss::total]}; - BEAST_EXPECT(jsonToUint64(total[jss::queued]) == jobs.size()); - BEAST_EXPECT(jsonToUint64(total[jss::started]) == jobs.size() * 2); - BEAST_EXPECT(jsonToUint64(total[jss::finished]) == finished); + BEAST_EXPECT(jsonToUInt64(total[jss::queued]) == jobs.size()); + BEAST_EXPECT(jsonToUInt64(total[jss::started]) == jobs.size() * 2); + BEAST_EXPECT(jsonToUInt64(total[jss::finished]) == finished); // Total queued duration should be triangle number of // jobs.size(). int const queuedDur = ((jobs.size() * (jobs.size() + 1)) / 2); - BEAST_EXPECT(jsonToUint64(total[jss::queued_duration_us]) == queuedDur); + BEAST_EXPECT(jsonToUInt64(total[jss::queued_duration_us]) == queuedDur); // Total running duration should be triangle number of finished. int const runningDur = ((finished * (finished + 1)) / 2); - BEAST_EXPECT(jsonToUint64(total[jss::running_duration_us]) == runningDur); + BEAST_EXPECT(jsonToUInt64(total[jss::running_duration_us]) == runningDur); } perfLog->jobFinish(jobs[i].type, microseconds(finished + 1), (i * 2)); @@ -730,10 +730,10 @@ public: for (int i = jobs.size() - 1; i >= 0; --i) { json::Value const& counter{jobQueue[jobs[i].typeName]}; - std::uint64_t const runningDurUs{jsonToUint64(counter[jss::running_duration_us])}; + std::uint64_t const runningDurUs{jsonToUInt64(counter[jss::running_duration_us])}; BEAST_EXPECT(runningDurUs == ((jobs.size() - i) * 4) - 1); - std::uint64_t const queuedDurUs{jsonToUint64(counter[jss::queued_duration_us])}; + std::uint64_t const queuedDurUs{jsonToUInt64(counter[jss::queued_duration_us])}; BEAST_EXPECT(queuedDurUs == i + 1); BEAST_EXPECT(counter[jss::queued] == "1"); @@ -744,18 +744,18 @@ public: // Verify values in jss::total are what we expect. json::Value const& total{jobQueue[jss::total]}; int const finished = jobs.size() * 2; - BEAST_EXPECT(jsonToUint64(total[jss::queued]) == jobs.size()); - BEAST_EXPECT(jsonToUint64(total[jss::started]) == finished); - BEAST_EXPECT(jsonToUint64(total[jss::finished]) == finished); + BEAST_EXPECT(jsonToUInt64(total[jss::queued]) == jobs.size()); + BEAST_EXPECT(jsonToUInt64(total[jss::started]) == finished); + BEAST_EXPECT(jsonToUInt64(total[jss::finished]) == finished); // Total queued duration should be triangle number of // jobs.size(). int const queuedDur = ((jobs.size() * (jobs.size() + 1)) / 2); - BEAST_EXPECT(jsonToUint64(total[jss::queued_duration_us]) == queuedDur); + BEAST_EXPECT(jsonToUInt64(total[jss::queued_duration_us]) == queuedDur); // Total running duration should be triangle number of finished. int const runningDur = ((finished * (finished + 1)) / 2); - BEAST_EXPECT(jsonToUint64(total[jss::running_duration_us]) == runningDur); + BEAST_EXPECT(jsonToUInt64(total[jss::running_duration_us]) == runningDur); }; auto validateFinalCurrent = [this](json::Value const& currentJson) { @@ -867,12 +867,12 @@ public: json::Value const& job{countersJson[jss::job_queue][jobTypeName]}; BEAST_EXPECT(job.isObject()); - BEAST_EXPECT(jsonToUint64(job[jss::queued]) == 0); - BEAST_EXPECT(jsonToUint64(job[jss::started]) == started); - BEAST_EXPECT(jsonToUint64(job[jss::finished]) == finished); + BEAST_EXPECT(jsonToUInt64(job[jss::queued]) == 0); + BEAST_EXPECT(jsonToUInt64(job[jss::started]) == started); + BEAST_EXPECT(jsonToUInt64(job[jss::finished]) == finished); - BEAST_EXPECT(jsonToUint64(job[jss::queued_duration_us]) == queuedUs); - BEAST_EXPECT(jsonToUint64(job[jss::running_duration_us]) == runningUs); + BEAST_EXPECT(jsonToUInt64(job[jss::queued_duration_us]) == queuedUs); + BEAST_EXPECT(jsonToUInt64(job[jss::running_duration_us]) == runningUs); } }; diff --git a/src/test/basics/TaggedCache_test.cpp b/src/test/basics/TaggedCache_test.cpp index c728536e08..77cd25e543 100644 --- a/src/test/basics/TaggedCache_test.cpp +++ b/src/test/basics/TaggedCache_test.cpp @@ -4,6 +4,7 @@ #include // IWYU pragma: keep #include #include +#include #include #include @@ -27,7 +28,7 @@ public: run() override { using namespace std::chrono_literals; - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("TaggedCache_test", *this); TestStopwatch clock; diff --git a/src/test/basics/Units_test.cpp b/src/test/basics/Units_test.cpp index 4a224a2708..6e04a6e8e0 100644 --- a/src/test/basics/Units_test.cpp +++ b/src/test/basics/Units_test.cpp @@ -96,56 +96,56 @@ private: { FeeLevel32 const x{std::numeric_limits::max()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::UintValue); + BEAST_EXPECT(y.type() == json::ValueType::UInt); BEAST_EXPECT(y == json::Value{x.fee()}); } { FeeLevel32 const x{std::numeric_limits::min()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::UintValue); + BEAST_EXPECT(y.type() == json::ValueType::UInt); BEAST_EXPECT(y == json::Value{x.fee()}); } { FeeLevel64 const x{std::numeric_limits::max()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::UintValue); + BEAST_EXPECT(y.type() == json::ValueType::UInt); BEAST_EXPECT(y == json::Value{std::numeric_limits::max()}); } { FeeLevel64 const x{std::numeric_limits::min()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::UintValue); + BEAST_EXPECT(y.type() == json::ValueType::UInt); BEAST_EXPECT(y == json::Value{0}); } { FeeLevelDouble const x{std::numeric_limits::max()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::RealValue); + BEAST_EXPECT(y.type() == json::ValueType::Real); BEAST_EXPECT(y == json::Value{std::numeric_limits::max()}); } { FeeLevelDouble const x{std::numeric_limits::min()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::RealValue); + BEAST_EXPECT(y.type() == json::ValueType::Real); BEAST_EXPECT(y == json::Value{std::numeric_limits::min()}); } { XRPAmount const x{std::numeric_limits::max()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::IntValue); + BEAST_EXPECT(y.type() == json::ValueType::Int); BEAST_EXPECT(y == json::Value{std::numeric_limits::max()}); } { XRPAmount const x{std::numeric_limits::min()}; auto y = x.jsonClipped(); - BEAST_EXPECT(y.type() == json::IntValue); + BEAST_EXPECT(y.type() == json::ValueType::Int); BEAST_EXPECT(y == json::Value{std::numeric_limits::min()}); } } diff --git a/src/test/basics/XRPAmount_test.cpp b/src/test/basics/XRPAmount_test.cpp index 50cd17b3bc..4a28ac586e 100644 --- a/src/test/basics/XRPAmount_test.cpp +++ b/src/test/basics/XRPAmount_test.cpp @@ -212,7 +212,7 @@ public: { testcase("mulRatio"); - constexpr auto kMAX_U_INT32 = std::numeric_limits::max(); + constexpr auto kMAX_UINT32 = std::numeric_limits::max(); constexpr auto kMAX_XRP = std::numeric_limits::max(); constexpr auto kMIN_XRP = std::numeric_limits::min(); @@ -220,9 +220,9 @@ public: // multiply by a number that would overflow then divide by the same // number, and check we didn't lose any value XRPAmount big(kMAX_XRP); - BEAST_EXPECT(big == mulRatio(big, kMAX_U_INT32, kMAX_U_INT32, true)); + BEAST_EXPECT(big == mulRatio(big, kMAX_UINT32, kMAX_UINT32, true)); // rounding mode shouldn't matter as the result is exact - BEAST_EXPECT(big == mulRatio(big, kMAX_U_INT32, kMAX_U_INT32, false)); + BEAST_EXPECT(big == mulRatio(big, kMAX_UINT32, kMAX_UINT32, false)); // multiply and divide by values that would overflow if done // naively, and check that it gives the correct answer @@ -235,9 +235,9 @@ public: { // Similar test as above, but for negative values XRPAmount big(kMIN_XRP); // NOLINT TODO - BEAST_EXPECT(big == mulRatio(big, kMAX_U_INT32, kMAX_U_INT32, true)); + BEAST_EXPECT(big == mulRatio(big, kMAX_UINT32, kMAX_UINT32, true)); // rounding mode shouldn't matter as the result is exact - BEAST_EXPECT(big == mulRatio(big, kMAX_U_INT32, kMAX_U_INT32, false)); + BEAST_EXPECT(big == mulRatio(big, kMAX_UINT32, kMAX_UINT32, false)); // multiply and divide by values that would overflow if done // naively, and check that it gives the correct answer @@ -250,39 +250,39 @@ public: // small amounts XRPAmount const tiny(1); // Round up should give the smallest allowable number - BEAST_EXPECT(tiny == mulRatio(tiny, 1, kMAX_U_INT32, true)); + BEAST_EXPECT(tiny == mulRatio(tiny, 1, kMAX_UINT32, true)); // rounding down should be zero - BEAST_EXPECT(beast::kZERO == mulRatio(tiny, 1, kMAX_U_INT32, false)); - BEAST_EXPECT(beast::kZERO == mulRatio(tiny, kMAX_U_INT32 - 1, kMAX_U_INT32, false)); + BEAST_EXPECT(beast::kZERO == mulRatio(tiny, 1, kMAX_UINT32, false)); + BEAST_EXPECT(beast::kZERO == mulRatio(tiny, kMAX_UINT32 - 1, kMAX_UINT32, false)); // tiny negative numbers XRPAmount const tinyNeg(-1); // Round up should give zero - BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, 1, kMAX_U_INT32, true)); - BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, kMAX_U_INT32 - 1, kMAX_U_INT32, true)); + BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, 1, kMAX_UINT32, true)); + BEAST_EXPECT(beast::kZERO == mulRatio(tinyNeg, kMAX_UINT32 - 1, kMAX_UINT32, true)); // rounding down should be tiny - BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMAX_U_INT32 - 1, kMAX_U_INT32, false)); + BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMAX_UINT32 - 1, kMAX_UINT32, false)); } { // rounding { XRPAmount const one(1); - auto const rup = mulRatio(one, kMAX_U_INT32 - 1, kMAX_U_INT32, true); - auto const rdown = mulRatio(one, kMAX_U_INT32 - 1, kMAX_U_INT32, false); + auto const rup = mulRatio(one, kMAX_UINT32 - 1, kMAX_UINT32, true); + auto const rdown = mulRatio(one, kMAX_UINT32 - 1, kMAX_UINT32, false); BEAST_EXPECT(rup.drops() - rdown.drops() == 1); } { XRPAmount const big(kMAX_XRP); - auto const rup = mulRatio(big, kMAX_U_INT32 - 1, kMAX_U_INT32, true); - auto const rdown = mulRatio(big, kMAX_U_INT32 - 1, kMAX_U_INT32, false); + auto const rup = mulRatio(big, kMAX_UINT32 - 1, kMAX_UINT32, true); + auto const rdown = mulRatio(big, kMAX_UINT32 - 1, kMAX_UINT32, false); BEAST_EXPECT(rup.drops() - rdown.drops() == 1); } { XRPAmount const negOne(-1); - auto const rup = mulRatio(negOne, kMAX_U_INT32 - 1, kMAX_U_INT32, true); - auto const rdown = mulRatio(negOne, kMAX_U_INT32 - 1, kMAX_U_INT32, false); + auto const rup = mulRatio(negOne, kMAX_UINT32 - 1, kMAX_UINT32, true); + auto const rdown = mulRatio(negOne, kMAX_UINT32 - 1, kMAX_UINT32, false); BEAST_EXPECT(rup.drops() - rdown.drops() == 1); } } diff --git a/src/test/basics/base_uint_test.cpp b/src/test/basics/base_uint_test.cpp index cf5ece6240..603536bbe0 100644 --- a/src/test/basics/base_uint_test.cpp +++ b/src/test/basics/base_uint_test.cpp @@ -49,7 +49,7 @@ struct Nonhash struct base_uint_test : beast::unit_test::Suite { - using test96 = BaseUint<96>; + using test96 = BaseUInt<96>; static_assert(std::is_copy_constructible_v); static_assert(std::is_copy_assignable_v); @@ -68,7 +68,7 @@ struct base_uint_test : beast::unit_test::Suite for (auto const& arg : kTEST_ARGS) { - xrpl::BaseUint<64> const u{arg.first}, v{arg.second}; + xrpl::BaseUInt<64> const u{arg.first}, v{arg.second}; BEAST_EXPECT(u < v); BEAST_EXPECT(u <= v); BEAST_EXPECT(u != v); @@ -99,7 +99,7 @@ struct base_uint_test : beast::unit_test::Suite for (auto const& arg : kTEST_ARGS) { - xrpl::BaseUint<96> const u{arg.first}, v{arg.second}; + xrpl::BaseUInt<96> const u{arg.first}, v{arg.second}; BEAST_EXPECT(u < v); BEAST_EXPECT(u <= v); BEAST_EXPECT(u != v); @@ -134,7 +134,7 @@ struct base_uint_test : beast::unit_test::Suite Blob const raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; BEAST_EXPECT(test96::kBYTES == raw.size()); - test96 u{raw}; + test96 u = test96::fromRaw(raw); uset.insert(u); BEAST_EXPECT(raw.size() == u.size()); BEAST_EXPECT(to_string(u) == "0102030405060708090A0B0C"); @@ -155,7 +155,7 @@ struct base_uint_test : beast::unit_test::Suite // back into another base_uint (w) for comparison with the original Nonhash<96> h{}; hash_append(h, u); - test96 const w{std::vector(h.data.begin(), h.data.end())}; + test96 const w = test96::fromRaw(std::vector(h.data.begin(), h.data.end())); BEAST_EXPECT(w == u); test96 v{~u}; @@ -327,16 +327,16 @@ struct base_uint_test : beast::unit_test::Suite // Verify that constexpr base_uints interpret a string the same // way parseHex() does. - struct StrBaseUint + struct StrBaseUInt { char const* const str; test96 tst; - constexpr StrBaseUint(char const* s) : str(s), tst(s) + constexpr StrBaseUInt(char const* s) : str(s), tst(s) { } }; - constexpr StrBaseUint kTEST_CASES[] = { + constexpr StrBaseUInt kTEST_CASES[] = { "000000000000000000000000", "000000000000000000000001", "fedcba9876543210ABCDEF91", @@ -344,7 +344,7 @@ struct base_uint_test : beast::unit_test::Suite "800000000000000000000000", "fFfFfFfFfFfFfFfFfFfFfFfF"}; - for (StrBaseUint const& t : kTEST_CASES) + for (StrBaseUInt const& t : kTEST_CASES) { test96 t96; BEAST_EXPECT(t96.parseHex(t.str)); diff --git a/src/test/beast/beast_Journal_test.cpp b/src/test/beast/beast_Journal_test.cpp index 4b58ed29a8..f2d4359f72 100644 --- a/src/test/beast/beast_Journal_test.cpp +++ b/src/test/beast/beast_Journal_test.cpp @@ -14,7 +14,7 @@ public: int count_{0}; public: - TestSink() : Sink(severities::KWarning, false) + TestSink() : Sink(Severity::Warning, false) { } @@ -31,14 +31,14 @@ public: } void - write(severities::Severity level, std::string const&) override + write(Severity level, std::string const&) override { if (level >= threshold()) ++count_; } void - writeAlways(severities::Severity level, std::string const&) override + writeAlways(Severity level, std::string const&) override { ++count_; } @@ -49,8 +49,7 @@ public: { TestSink sink; - using namespace beast::severities; - sink.threshold(KInfo); + sink.threshold(Severity::Info); Journal const j(sink); @@ -69,7 +68,7 @@ public: sink.reset(); - sink.threshold(KDebug); + sink.threshold(Severity::Debug); j.trace() << " "; BEAST_EXPECT(sink.count() == 0); diff --git a/src/test/beast/beast_io_latency_probe_test.cpp b/src/test/beast/beast_io_latency_probe_test.cpp index a884256986..5f183ef091 100644 --- a/src/test/beast/beast_io_latency_probe_test.cpp +++ b/src/test/beast/beast_io_latency_probe_test.cpp @@ -112,7 +112,7 @@ class io_latency_probe_test : public beast::unit_test::Suite, public beast::test struct TestSampler { - beast::IoLatencyProbe probe; + beast::IOLatencyProbe probe; std::vector durations; TestSampler(std::chrono::milliseconds interval, boost::asio::io_context& ios) diff --git a/src/test/consensus/Consensus_test.cpp b/src/test/consensus/Consensus_test.cpp index 51d99367e7..b284e3dd38 100644 --- a/src/test/consensus/Consensus_test.cpp +++ b/src/test/consensus/Consensus_test.cpp @@ -1039,7 +1039,7 @@ public: #if 0 // Have all beast::journal output printed to stdout for (Peer* p : network) - p->sink.threshold(beast::severities::kAll); + p->sink.threshold(beast::Severity::All); // Print ledger accept and fully validated events to stdout StreamCollector sc{std::cout}; @@ -1086,7 +1086,7 @@ public: ConsensusParms const p; std::size_t peersUnchanged = 0; - auto logs = std::make_unique(beast::severities::KError); + auto logs = std::make_unique(beast::Severity::Error); auto j = logs->journal("Test"); auto clog = std::make_unique(); diff --git a/src/test/core/ClosureCounter_test.cpp b/src/test/core/ClosureCounter_test.cpp index d859c71520..d5d98cf440 100644 --- a/src/test/core/ClosureCounter_test.cpp +++ b/src/test/core/ClosureCounter_test.cpp @@ -18,7 +18,7 @@ class ClosureCounter_test : public beast::unit_test::Suite { // We're only using Env for its Journal. That Journal gives better // coverage in unit tests. - test::jtx::Env env_{*this, jtx::envconfig(), nullptr, beast::severities::KDisabled}; + test::jtx::Env env_{*this, jtx::envconfig(), nullptr, beast::Severity::Disabled}; beast::Journal j_{env_.app().getJournal("ClosureCounter_test")}; void diff --git a/src/test/core/SociDB_test.cpp b/src/test/core/SociDB_test.cpp index 29aeca7ce5..f4c6fb04f1 100644 --- a/src/test/core/SociDB_test.cpp +++ b/src/test/core/SociDB_test.cpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include // IWYU pragma: keep #include #include diff --git a/src/test/csf/Sim.h b/src/test/csf/Sim.h index 0b1b3473d6..89e6b95fe6 100644 --- a/src/test/csf/Sim.h +++ b/src/test/csf/Sim.h @@ -22,12 +22,12 @@ class BasicSink : public beast::Journal::Sink public: BasicSink(Scheduler::clock_type const& clock) - : Sink(beast::severities::KDisabled, false), clock_{clock} + : Sink(beast::Severity::Disabled, false), clock_{clock} { } void - write(beast::severities::Severity level, std::string const& text) override + write(beast::Severity level, std::string const& text) override { if (level < threshold()) return; @@ -36,7 +36,7 @@ public: } void - writeAlways(beast::severities::Severity level, std::string const& text) override + writeAlways(beast::Severity level, std::string const& text) override { std::cout << clock_.now().time_since_epoch().count() << " " << text << std::endl; } diff --git a/src/test/csf/impl/ledgers.cpp b/src/test/csf/impl/ledgers.cpp index 0e3764d5ab..fd7ea35faa 100644 --- a/src/test/csf/impl/ledgers.cpp +++ b/src/test/csf/impl/ledgers.cpp @@ -20,7 +20,7 @@ Ledger::Instance const Ledger::kGENESIS; json::Value Ledger::getJson() const { - json::Value res(json::ObjectValue); + json::Value res(json::ValueType::Object); res["id"] = static_cast(id()); res["seq"] = static_cast(seq()); return res; diff --git a/src/test/jtx/CaptureLogs.h b/src/test/jtx/CaptureLogs.h index 7effa30074..b5fe302629 100644 --- a/src/test/jtx/CaptureLogs.h +++ b/src/test/jtx/CaptureLogs.h @@ -25,23 +25,20 @@ class CaptureLogs : public Logs std::stringstream& strm_; public: - CaptureSink( - beast::severities::Severity threshold, - std::mutex& mutex, - std::stringstream& strm) + CaptureSink(beast::Severity threshold, std::mutex& mutex, std::stringstream& strm) : beast::Journal::Sink(threshold, false), strmMutex_(mutex), strm_(strm) { } void - write(beast::severities::Severity level, std::string const& text) override + write(beast::Severity level, std::string const& text) override { std::scoped_lock const lock(strmMutex_); strm_ << text; } void - writeAlways(beast::severities::Severity level, std::string const& text) override + writeAlways(beast::Severity level, std::string const& text) override { std::scoped_lock const lock(strmMutex_); strm_ << text; @@ -49,7 +46,7 @@ class CaptureLogs : public Logs }; public: - explicit CaptureLogs(std::string* pResult) : Logs(beast::severities::KInfo), pResult_(pResult) + explicit CaptureLogs(std::string* pResult) : Logs(beast::Severity::Info), pResult_(pResult) { } @@ -59,7 +56,7 @@ public: } std::unique_ptr - makeSink(std::string const& partition, beast::severities::Severity threshold) override + makeSink(std::string const& partition, beast::Severity threshold) override { return std::make_unique(threshold, strmMutex_, strm_); } diff --git a/src/test/jtx/CheckMessageLogs.h b/src/test/jtx/CheckMessageLogs.h index 34e776e871..2cc8c661eb 100644 --- a/src/test/jtx/CheckMessageLogs.h +++ b/src/test/jtx/CheckMessageLogs.h @@ -16,20 +16,20 @@ class CheckMessageLogs : public Logs CheckMessageLogs& owner_; public: - CheckMessageSink(beast::severities::Severity threshold, CheckMessageLogs& owner) + CheckMessageSink(beast::Severity threshold, CheckMessageLogs& owner) : beast::Journal::Sink(threshold, false), owner_(owner) { } void - write(beast::severities::Severity level, std::string const& text) override + write(beast::Severity level, std::string const& text) override { if (text.find(owner_.msg_) != std::string::npos) *owner_.pFound_ = true; } void - writeAlways(beast::severities::Severity level, std::string const& text) override + writeAlways(beast::Severity level, std::string const& text) override { write(level, text); } @@ -43,12 +43,12 @@ public: found */ CheckMessageLogs(std::string msg, bool* pFound) - : Logs{beast::severities::KDebug}, msg_{std::move(msg)}, pFound_{pFound} + : Logs{beast::Severity::Debug}, msg_{std::move(msg)}, pFound_{pFound} { } std::unique_ptr - makeSink(std::string const& partition, beast::severities::Severity threshold) override + makeSink(std::string const& partition, beast::Severity threshold) override { return std::make_unique(threshold, *this); } diff --git a/src/test/jtx/Env.h b/src/test/jtx/Env.h index 45c42da2e2..1ed9feb906 100644 --- a/src/test/jtx/Env.h +++ b/src/test/jtx/Env.h @@ -103,15 +103,14 @@ class SuiteLogs : public Logs beast::unit_test::Suite& suite_; public: - explicit SuiteLogs(beast::unit_test::Suite& suite) - : Logs(beast::severities::KError), suite_(suite) + explicit SuiteLogs(beast::unit_test::Suite& suite) : Logs(beast::Severity::Error), suite_(suite) { } ~SuiteLogs() override = default; std::unique_ptr - makeSink(std::string const& partition, beast::severities::Severity threshold) override + makeSink(std::string const& partition, beast::Severity threshold) override { return std::make_unique(partition, threshold, suite_); } @@ -155,7 +154,7 @@ private: beast::unit_test::Suite& suite, std::unique_ptr config, std::unique_ptr logs, - beast::severities::Severity thresh); + beast::Severity thresh); ~AppBundle(); }; @@ -188,7 +187,7 @@ public: std::unique_ptr config, FeatureBitset features, std::unique_ptr logs = nullptr, - beast::severities::Severity thresh = beast::severities::KError) + beast::Severity thresh = beast::Severity::Error) : test(suite) , bundle_(suite, std::move(config), std::move(logs), thresh) , journal{bundle_.app->getJournal("Env")} @@ -235,7 +234,7 @@ public: Env(beast::unit_test::Suite& suite, std::unique_ptr config, std::unique_ptr logs = nullptr, - beast::severities::Severity thresh = beast::severities::KError) + beast::Severity thresh = beast::Severity::Error) : Env(suite, std::move(config), testableAmendments(), std::move(logs), thresh) { } @@ -249,8 +248,7 @@ public: * * @param suite the current unit_test::suite */ - Env(beast::unit_test::Suite& suite, - beast::severities::Severity thresh = beast::severities::KError) + Env(beast::unit_test::Suite& suite, beast::Severity thresh = beast::Severity::Error) : Env(suite, envconfig(), nullptr, thresh) { } @@ -606,7 +604,7 @@ public: void signAndSubmit( JTx const& jt, - json::Value params = json::NullValue, + json::Value params = json::ValueType::Null, std::source_location const& loc = std::source_location::current()); /** Check expected postconditions diff --git a/src/test/jtx/Env_ss.h b/src/test/jtx/Env_ss.h index a49cf96bb6..ca0825eac7 100644 --- a/src/test/jtx/Env_ss.h +++ b/src/test/jtx/Env_ss.h @@ -27,7 +27,7 @@ private: } void - operator()(json::Value const& params = json::NullValue) + operator()(json::Value const& params = json::ValueType::Null) { env_.signAndSubmit(jt_, params, loc_); } diff --git a/src/test/jtx/Env_test.cpp b/src/test/jtx/Env_test.cpp index 6a28a564b7..bdc9497235 100644 --- a/src/test/jtx/Env_test.cpp +++ b/src/test/jtx/Env_test.cpp @@ -397,7 +397,7 @@ public: Serializer s; jt.stx->add(s); - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::tx_blob] = strHex(s.slice()); args[jss::fail_hard] = true; @@ -715,7 +715,7 @@ public: } { - auto params = json::Value(json::NullValue); + auto params = json::Value(json::ValueType::Null); envs(noop(alice), Fee(kNONE), Seq(kNONE))(params); // Make sure we get the right account back. @@ -728,7 +728,7 @@ public: } { - auto params = json::Value(json::ObjectValue); + auto params = json::Value(json::ValueType::Object); // Force the factor low enough to fail params[jss::fee_mult_max] = 1; params[jss::fee_div_max] = 2; @@ -867,7 +867,7 @@ public: return cfg; }), nullptr, - beast::severities::KDisabled}; + beast::Severity::Disabled}; }); pass(); } diff --git a/src/test/jtx/PathSet.h b/src/test/jtx/PathSet.h index 9b5f893d5a..26da4eb215 100644 --- a/src/test/jtx/PathSet.h +++ b/src/test/jtx/PathSet.h @@ -145,7 +145,7 @@ TestPath::addHelper(First&& first, Rest&&... rest) inline json::Value TestPath::json() const { - return path.getJson(JsonOptions::KNone); + return path.getJson(JsonOptions::Values::None); } class PathSet @@ -170,7 +170,7 @@ public: json() const { json::Value v; - v["Paths"] = paths.getJson(JsonOptions::KNone); + v["Paths"] = paths.getJson(JsonOptions::Values::None); return v; } diff --git a/src/test/jtx/TestHelpers.h b/src/test/jtx/TestHelpers.h index de0017bfa9..3362d08645 100644 --- a/src/test/jtx/TestHelpers.h +++ b/src/test/jtx/TestHelpers.h @@ -101,7 +101,7 @@ public: } }; -struct Uint256Field : public JTxField +struct UInt256Field : public JTxField { using SF = SF_UINT256; using SV = uint256; @@ -112,7 +112,7 @@ protected: using base::value_; public: - explicit Uint256Field(SF const& sfield, SV const& value) : JTxField(sfield, value) + explicit UInt256Field(SF const& sfield, SV const& value) : JTxField(sfield, value) { } @@ -163,7 +163,7 @@ public: [[nodiscard]] OV value() const override { - return value_.getJson(JsonOptions::KNone); + return value_.getJson(JsonOptions::Values::None); } }; @@ -714,7 +714,7 @@ create(A const& account, A const& dest, STAmount const& sendMax) { json::Value jv; jv[sfAccount.jsonName] = to_string(account); - jv[sfSendMax.jsonName] = sendMax.getJson(JsonOptions::KNone); + jv[sfSendMax.jsonName] = sendMax.getJson(JsonOptions::Values::None); jv[sfDestination.jsonName] = to_string(dest); jv[sfTransactionType.jsonName] = jss::CheckCreate; return jv; @@ -856,7 +856,7 @@ coverWithdraw( json::Value coverClawback(AccountID const& account, std::uint32_t flags = 0); -auto const kLOAN_BROKER_ID = JTxFieldWrapper(sfLoanBrokerID); +auto const kLOAN_BROKER_ID = JTxFieldWrapper(sfLoanBrokerID); auto const kMANAGEMENT_FEE_RATE = valueUnitWrapper(sfManagementFeeRate); diff --git a/src/test/jtx/WSClient_test.cpp b/src/test/jtx/WSClient_test.cpp index 25d922d48e..d77e0f948b 100644 --- a/src/test/jtx/WSClient_test.cpp +++ b/src/test/jtx/WSClient_test.cpp @@ -20,7 +20,7 @@ public: auto wsc = makeWSClient(env.app().config()); { json::Value jv; - jv["streams"] = json::ArrayValue; + jv["streams"] = json::ValueType::Array; jv["streams"].append("ledger"); } env.fund(XRP(10000), "alice"); diff --git a/src/test/jtx/credentials.h b/src/test/jtx/credentials.h index e441232825..c2719bf897 100644 --- a/src/test/jtx/credentials.h +++ b/src/test/jtx/credentials.h @@ -47,7 +47,7 @@ public: void operator()(jtx::Env&, jtx::JTx& jtx) const { - auto& arr(jtx.jv[sfCredentialIDs.jsonName] = json::ArrayValue); + auto& arr(jtx.jv[sfCredentialIDs.jsonName] = json::ValueType::Array); for (auto const& hash : credentials_) arr.append(hash); } diff --git a/src/test/jtx/impl/AMM.cpp b/src/test/jtx/impl/AMM.cpp index 5193034826..145a342e97 100644 --- a/src/test/jtx/impl/AMM.cpp +++ b/src/test/jtx/impl/AMM.cpp @@ -141,8 +141,8 @@ AMM::createJv( { json::Value jv; jv[jss::Account] = to_string(account); - jv[jss::Amount] = asset1.getJson(JsonOptions::KNone); - jv[jss::Amount2] = asset2.getJson(JsonOptions::KNone); + jv[jss::Amount] = asset1.getJson(JsonOptions::Values::None); + jv[jss::Amount2] = asset2.getJson(JsonOptions::Values::None); jv[jss::TradingFee] = tfee; jv[jss::TransactionType] = jss::AMMCreate; @@ -199,14 +199,14 @@ AMM::ammRpcInfo( if (asset1 || asset2) { if (asset1) - jv[jss::asset] = STIssue(sfAsset, *asset1).getJson(JsonOptions::KNone); + jv[jss::asset] = STIssue(sfAsset, *asset1).getJson(JsonOptions::Values::None); if (asset2) - jv[jss::asset2] = STIssue(sfAsset2, *asset2).getJson(JsonOptions::KNone); + jv[jss::asset2] = STIssue(sfAsset2, *asset2).getJson(JsonOptions::Values::None); } else if (!ammAccount) { - jv[jss::asset] = STIssue(sfAsset, asset1_.asset()).getJson(JsonOptions::KNone); - jv[jss::asset2] = STIssue(sfAsset2, asset2_.asset()).getJson(JsonOptions::KNone); + jv[jss::asset] = STIssue(sfAsset, asset1_.asset()).getJson(JsonOptions::Values::None); + jv[jss::asset2] = STIssue(sfAsset2, asset2_.asset()).getJson(JsonOptions::Values::None); } if (ammAccount) jv[jss::amm_account] = to_string(*ammAccount); @@ -217,7 +217,7 @@ AMM::ammRpcInfo( : env_.rpc(apiVersion, "json", "amm_info", to_string(jv))); if (jr.isObject() && jr.isMember(jss::result) && jr[jss::result].isMember(jss::status)) return jr[jss::result]; - return json::NullValue; + return json::ValueType::Null; } std::tuple @@ -374,13 +374,13 @@ AMM::setTokens(json::Value& jv, std::optional> const& as { if (assets) { - jv[jss::Asset] = STIssue(sfAsset, assets->first).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, assets->second).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, assets->first).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, assets->second).getJson(JsonOptions::Values::None); } else { - jv[jss::Asset] = STIssue(sfAsset, asset1_.asset()).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, asset2_.asset()).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, asset1_.asset()).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, asset2_.asset()).getJson(JsonOptions::Values::None); } } @@ -392,8 +392,8 @@ AMM::depositJv(DepositArg const& arg) Throw("AMM::depositJv: account or assets not set"); jv[jss::Account] = arg.account->human(); - jv[jss::Asset] = STIssue(sfAsset, arg.assets->first).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, arg.assets->second).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, arg.assets->first).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, arg.assets->second).getJson(JsonOptions::Values::None); if (arg.tokens) arg.tokens->tokens().setJson(jv[jss::LPTokenOut]); if (arg.asset1In) @@ -538,8 +538,8 @@ AMM::withdrawJv(WithdrawArg const& arg) if (!arg.account || !arg.assets) Throw("AMM::withdrawJv: account or assets not set"); jv[jss::Account] = arg.account->human(); - jv[jss::Asset] = STIssue(sfAsset, arg.assets->first).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, arg.assets->second).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, arg.assets->first).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, arg.assets->second).getJson(JsonOptions::Values::None); if (arg.tokens) arg.tokens->tokens().setJson(jv[jss::LPTokenIn]); if (arg.asset1Out) @@ -674,8 +674,8 @@ AMM::voteJv(VoteArg const& arg) if (!arg.account || !arg.assets) Throw("AMM::withdrawJv: account or assets not set"); jv[jss::Account] = arg.account->human(); - jv[jss::Asset] = STIssue(sfAsset, arg.assets->first).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, arg.assets->second).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, arg.assets->first).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, arg.assets->second).getJson(JsonOptions::Values::None); jv[jss::TradingFee] = arg.tfee; if (arg.flags) jv[jss::Flags] = *arg.flags; @@ -758,7 +758,7 @@ AMM::bid(BidArg const& arg) } if (!arg.authAccounts.empty()) { - json::Value accounts(json::ArrayValue); + json::Value accounts(json::ValueType::Array); for (auto const& account : arg.authAccounts) { json::Value acct; @@ -875,8 +875,8 @@ AMM::deleteJv(AccountID const& account, Asset const& asset1, Asset const& asset2 { json::Value jv; jv[jss::Account] = to_string(account); - jv[jss::Asset] = STIssue(sfAsset, asset1).getJson(JsonOptions::KNone); - jv[jss::Asset2] = STIssue(sfAsset, asset2).getJson(JsonOptions::KNone); + jv[jss::Asset] = STIssue(sfAsset, asset1).getJson(JsonOptions::Values::None); + jv[jss::Asset2] = STIssue(sfAsset, asset2).getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::AMMDelete; @@ -909,7 +909,7 @@ ammClawback( jv[jss::Asset] = toJson(asset); jv[jss::Asset2] = toJson(asset2); if (amount) - jv[jss::Amount] = amount->getJson(JsonOptions::KNone); + jv[jss::Amount] = amount->getJson(JsonOptions::Values::None); return jv; } diff --git a/src/test/jtx/impl/Env.cpp b/src/test/jtx/impl/Env.cpp index cc3db4f1e1..7e723dd123 100644 --- a/src/test/jtx/impl/Env.cpp +++ b/src/test/jtx/impl/Env.cpp @@ -73,19 +73,19 @@ Env::AppBundle::AppBundle( beast::unit_test::Suite& suite, std::unique_ptr config, std::unique_ptr logs, - beast::severities::Severity thresh) + beast::Severity thresh) : AppBundle() { - using namespace beast::severities; + using beast::Severity; if (logs) { - setDebugLogSink(logs->makeSink("Debug", KFatal)); + setDebugLogSink(logs->makeSink("Debug", Severity::Fatal)); } else { logs = std::make_unique(suite); // Use kFatal threshold to reduce noise from STObject. - setDebugLogSink(std::make_unique("Debug", KFatal, suite)); + setDebugLogSink(std::make_unique("Debug", Severity::Fatal, suite)); } auto tk = std::make_unique(); timeKeeper = tk.get(); diff --git a/src/test/jtx/impl/JSONRPCClient.cpp b/src/test/jtx/impl/JSONRPCClient.cpp index 01b8b5863a..c8e6326ed2 100644 --- a/src/test/jtx/impl/JSONRPCClient.cpp +++ b/src/test/jtx/impl/JSONRPCClient.cpp @@ -124,7 +124,7 @@ public: } if (params) { - json::Value& ja = jr[jss::params] = json::ArrayValue; + json::Value& ja = jr[jss::params] = json::ValueType::Array; ja.append(params); } req.body() = to_string(jr); diff --git a/src/test/jtx/impl/Oracle.cpp b/src/test/jtx/impl/Oracle.cpp index 051e1f4470..c59b4da8f8 100644 --- a/src/test/jtx/impl/Oracle.cpp +++ b/src/test/jtx/impl/Oracle.cpp @@ -167,7 +167,7 @@ Oracle::aggregatePrice( std::optional const& timeThreshold) { json::Value jv; - json::Value jvOracles(json::ArrayValue); + json::Value jvOracles(json::ValueType::Array); if (oracles) { for (auto const& id : *oracles) @@ -205,7 +205,7 @@ Oracle::aggregatePrice( return jr; } } - return json::NullValue; + return json::ValueType::Null; } void @@ -269,7 +269,7 @@ Oracle::set(UpdateArg const& arg) duration_cast(env_.current()->header().closeTime.time_since_epoch()).count() + kEPOCH_OFFSET.count()); } - json::Value dataSeries(json::ArrayValue); + json::Value dataSeries(json::ValueType::Array); auto assetToStr = [](std::string const& s) { // assume standard currency if (s.size() == 3) @@ -361,7 +361,7 @@ Oracle::ledgerEntry( if (jr.isMember(jss::result) && jr[jss::result].isMember(jss::status)) return jr[jss::result]; } - return json::NullValue; + return json::ValueType::Null; } void diff --git a/src/test/jtx/impl/TestHelpers.cpp b/src/test/jtx/impl/TestHelpers.cpp index 6be3220220..0e465d1732 100644 --- a/src/test/jtx/impl/TestHelpers.cpp +++ b/src/test/jtx/impl/TestHelpers.cpp @@ -146,17 +146,17 @@ rpf(jtx::Account const& src, std::optional const& srcAsset, std::optional const& srcIssuer) { - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::command] = "ripple_path_find"; jv[jss::source_account] = toBase58(src); jv[jss::destination_account] = toBase58(dst); - jv[jss::destination_amount] = dstAmount.getJson(JsonOptions::KNone); + jv[jss::destination_amount] = dstAmount.getJson(JsonOptions::Values::None); if (sendMax) - jv[jss::send_max] = sendMax->getJson(JsonOptions::KNone); + jv[jss::send_max] = sendMax->getJson(JsonOptions::Values::None); if (srcAsset) { - auto& sc = jv[jss::source_currencies] = json::ArrayValue; - json::Value j = json::ObjectValue; + auto& sc = jv[jss::source_currencies] = json::ValueType::Array; + json::Value j = json::ValueType::Object; addSourceAsset(j, *srcAsset, srcIssuer); sc.append(j); } @@ -210,18 +210,18 @@ findPathsRequest( {}, {}}; - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::command] = "ripple_path_find"; params[jss::source_account] = toBase58(src); params[jss::destination_account] = toBase58(dst); - params[jss::destination_amount] = saDstAmount.getJson(JsonOptions::KNone); + params[jss::destination_amount] = saDstAmount.getJson(JsonOptions::Values::None); if (saSendMax) - params[jss::send_max] = saSendMax->getJson(JsonOptions::KNone); + params[jss::send_max] = saSendMax->getJson(JsonOptions::Values::None); if (srcAsset) { - auto& sc = params[jss::source_currencies] = json::ArrayValue; - json::Value j = json::ObjectValue; + auto& sc = params[jss::source_currencies] = json::ValueType::Array; + json::Value j = json::ValueType::Object; addSourceAsset(j, *srcAsset, srcIssuer); sc.append(j); } @@ -434,7 +434,7 @@ ledgerEntryState(Env& env, Account const& acctA, Account const& acctB, std::stri json::Value jvParams; jvParams[jss::ledger_index] = "current"; jvParams[jss::ripple_state][jss::currency] = currency; - jvParams[jss::ripple_state][jss::accounts] = json::ArrayValue; + jvParams[jss::ripple_state][jss::accounts] = json::ValueType::Array; jvParams[jss::ripple_state][jss::accounts].append(acctA.human()); jvParams[jss::ripple_state][jss::accounts].append(acctB.human()); return env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result]; @@ -499,7 +499,7 @@ create( jv[jss::TransactionType] = jss::PaymentChannelCreate; jv[jss::Account] = to_string(account); jv[jss::Destination] = to_string(to); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); jv[jss::SettleDelay] = settleDelay.count(); jv[sfPublicKey.fieldName] = strHex(pk.slice()); if (cancelAfter) @@ -520,7 +520,7 @@ fund( jv[jss::TransactionType] = jss::PaymentChannelFund; jv[jss::Account] = to_string(account); jv[sfChannel.fieldName] = to_string(channel); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); if (expiration) jv[sfExpiration.fieldName] = expiration->time_since_epoch().count(); return jv; @@ -540,9 +540,9 @@ claim( jv[jss::Account] = to_string(account); jv["Channel"] = to_string(channel); if (amount) - jv[jss::Amount] = amount->getJson(JsonOptions::KNone); + jv[jss::Amount] = amount->getJson(JsonOptions::Values::None); if (balance) - jv["Balance"] = balance->getJson(JsonOptions::KNone); + jv["Balance"] = balance->getJson(JsonOptions::Values::None); if (signature) jv["Signature"] = strHex(*signature); if (pk) @@ -760,7 +760,7 @@ coverDeposit( jv[sfTransactionType] = jss::LoanBrokerCoverDeposit; jv[sfAccount] = to_string(account); jv[sfLoanBrokerID] = to_string(brokerID); - jv[sfAmount] = amount.getJson(JsonOptions::KNone); + jv[sfAmount] = amount.getJson(JsonOptions::Values::None); jv[sfFlags] = flags; return jv; } @@ -776,7 +776,7 @@ coverWithdraw( jv[sfTransactionType] = jss::LoanBrokerCoverWithdraw; jv[sfAccount] = to_string(account); jv[sfLoanBrokerID] = to_string(brokerID); - jv[sfAmount] = amount.getJson(JsonOptions::KNone); + jv[sfAmount] = amount.getJson(JsonOptions::Values::None); jv[sfFlags] = flags; return jv; } diff --git a/src/test/jtx/impl/batch.cpp b/src/test/jtx/impl/batch.cpp index 857991cfd1..2f7a67b45a 100644 --- a/src/test/jtx/impl/batch.cpp +++ b/src/test/jtx/impl/batch.cpp @@ -44,7 +44,7 @@ outer(jtx::Account const& account, uint32_t seq, STAmount const& fee, std::uint3 json::Value jv; jv[jss::TransactionType] = jss::Batch; jv[jss::Account] = account.human(); - jv[jss::RawTransactions] = json::Value{json::ArrayValue}; + jv[jss::RawTransactions] = json::Value{json::ValueType::Array}; jv[jss::Sequence] = seq; jv[jss::Flags] = flags; jv[jss::Fee] = to_string(fee); diff --git a/src/test/jtx/impl/check.cpp b/src/test/jtx/impl/check.cpp index ec3e4e12fc..936cdcb818 100644 --- a/src/test/jtx/impl/check.cpp +++ b/src/test/jtx/impl/check.cpp @@ -16,7 +16,7 @@ cash(jtx::Account const& dest, uint256 const& checkId, STAmount const& amount) { json::Value jv; jv[sfAccount.jsonName] = dest.human(); - jv[sfAmount.jsonName] = amount.getJson(JsonOptions::KNone); + jv[sfAmount.jsonName] = amount.getJson(JsonOptions::Values::None); jv[sfCheckID.jsonName] = to_string(checkId); jv[sfTransactionType.jsonName] = jss::CheckCash; return jv; @@ -28,7 +28,7 @@ cash(jtx::Account const& dest, uint256 const& checkId, DeliverMin const& atLeast { json::Value jv; jv[sfAccount.jsonName] = dest.human(); - jv[sfDeliverMin.jsonName] = atLeast.value.getJson(JsonOptions::KNone); + jv[sfDeliverMin.jsonName] = atLeast.value.getJson(JsonOptions::Values::None); jv[sfCheckID.jsonName] = to_string(checkId); jv[sfTransactionType.jsonName] = jss::CheckCash; return jv; diff --git a/src/test/jtx/impl/delegate.cpp b/src/test/jtx/impl/delegate.cpp index 139311cf39..13464455e2 100644 --- a/src/test/jtx/impl/delegate.cpp +++ b/src/test/jtx/impl/delegate.cpp @@ -22,7 +22,7 @@ set(jtx::Account const& account, jv[jss::TransactionType] = jss::DelegateSet; jv[jss::Account] = account.human(); jv[sfAuthorize.jsonName] = authorize.human(); - json::Value permissionsJson(json::ArrayValue); + json::Value permissionsJson(json::ValueType::Array); for (auto const& permission : permissions) { json::Value permissionValue; diff --git a/src/test/jtx/impl/delivermin.cpp b/src/test/jtx/impl/delivermin.cpp index 4d13a06ac4..c0df67c4e5 100644 --- a/src/test/jtx/impl/delivermin.cpp +++ b/src/test/jtx/impl/delivermin.cpp @@ -10,7 +10,7 @@ namespace xrpl::test::jtx { void DeliverMin::operator()(Env& env, JTx& jt) const { - jt.jv[jss::DeliverMin] = amount_.getJson(JsonOptions::KNone); + jt.jv[jss::DeliverMin] = amount_.getJson(JsonOptions::Values::None); } } // namespace xrpl::test::jtx diff --git a/src/test/jtx/impl/deposit.cpp b/src/test/jtx/impl/deposit.cpp index daa35d5e20..942b874b52 100644 --- a/src/test/jtx/impl/deposit.cpp +++ b/src/test/jtx/impl/deposit.cpp @@ -39,7 +39,7 @@ authCredentials(jtx::Account const& account, std::vector c { json::Value jv; jv[sfAccount.jsonName] = account.human(); - jv[sfAuthorizeCredentials.jsonName] = json::ArrayValue; + jv[sfAuthorizeCredentials.jsonName] = json::ValueType::Array; auto& arr(jv[sfAuthorizeCredentials.jsonName]); for (auto const& o : auth) { @@ -57,7 +57,7 @@ unauthCredentials(jtx::Account const& account, std::vector { json::Value jv; jv[sfAccount.jsonName] = account.human(); - jv[sfUnauthorizeCredentials.jsonName] = json::ArrayValue; + jv[sfUnauthorizeCredentials.jsonName] = json::ValueType::Array; auto& arr(jv[sfUnauthorizeCredentials.jsonName]); for (auto const& o : auth) { diff --git a/src/test/jtx/impl/envconfig.cpp b/src/test/jtx/impl/envconfig.cpp index 93d976a7c9..474a16165a 100644 --- a/src/test/jtx/impl/envconfig.cpp +++ b/src/test/jtx/impl/envconfig.cpp @@ -72,7 +72,7 @@ secureGateway(std::unique_ptr cfg) { (*cfg)[PORT_RPC].set("admin", ""); (*cfg)[PORT_WS].set("admin", ""); - (*cfg)[PORT_RPC].set("secureGateway", getEnvLocalhostAddr()); + (*cfg)[PORT_RPC].set("secure_gateway", getEnvLocalhostAddr()); return cfg; } @@ -89,8 +89,8 @@ secureGatewayLocalnet(std::unique_ptr cfg) { (*cfg)[PORT_RPC].set("admin", ""); (*cfg)[PORT_WS].set("admin", ""); - (*cfg)[PORT_RPC].set("secureGateway", "127.0.0.0/8"); - (*cfg)[PORT_WS].set("secureGateway", "127.0.0.0/8"); + (*cfg)[PORT_RPC].set("secure_gateway", "127.0.0.0/8"); + (*cfg)[PORT_WS].set("secure_gateway", "127.0.0.0/8"); return cfg; } std::unique_ptr @@ -127,7 +127,7 @@ addGrpcConfigWithSecureGateway(std::unique_ptr cfg, std::string const& s // Check https://man7.org/linux/man-pages/man7/ip.7.html // "ip_local_port_range" section for using 0 ports (*cfg)[SECTION_PORT_GRPC].set("port", "0"); - (*cfg)[SECTION_PORT_GRPC].set("secureGateway", secureGateway); + (*cfg)[SECTION_PORT_GRPC].set("secure_gateway", secureGateway); return cfg; } diff --git a/src/test/jtx/impl/escrow.cpp b/src/test/jtx/impl/escrow.cpp index f6fce08b66..007f492849 100644 --- a/src/test/jtx/impl/escrow.cpp +++ b/src/test/jtx/impl/escrow.cpp @@ -25,7 +25,7 @@ create(AccountID const& account, AccountID const& to, STAmount const& amount) jv[jss::Flags] = tfFullyCanonicalSig; jv[jss::Account] = to_string(account); jv[jss::Destination] = to_string(to); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); return jv; } diff --git a/src/test/jtx/impl/fee.cpp b/src/test/jtx/impl/fee.cpp index 4dd0f01ece..1bdc1251eb 100644 --- a/src/test/jtx/impl/fee.cpp +++ b/src/test/jtx/impl/fee.cpp @@ -22,7 +22,7 @@ Fee::operator()(Env& env, JTx& jt) const } else if (amount_) { - jt[sfFee] = amount_->getJson(JsonOptions::KNone); + jt[sfFee] = amount_->getJson(JsonOptions::Values::None); } } diff --git a/src/test/jtx/impl/flags.cpp b/src/test/jtx/impl/flags.cpp index 7733335668..ad49f559f3 100644 --- a/src/test/jtx/impl/flags.cpp +++ b/src/test/jtx/impl/flags.cpp @@ -34,7 +34,7 @@ Flags::operator()(Env& env) const } else if (sle->isFieldPresent(sfFlags)) { - env.test.expect((sle->getFieldU32(sfFlags) & mask_) == mask_); + env.test.expect(sle->isFlag(mask_)); } else { diff --git a/src/test/jtx/impl/multisign.cpp b/src/test/jtx/impl/multisign.cpp index 1ac65a0274..66c5a4f27d 100644 --- a/src/test/jtx/impl/multisign.cpp +++ b/src/test/jtx/impl/multisign.cpp @@ -74,7 +74,7 @@ Msig::operator()(Env& env, JTx& jt) const } else if (sigObject.isNull()) { - sigObject = json::Value(json::ObjectValue); + sigObject = json::Value(json::ValueType::Object); } std::optional st; try diff --git a/src/test/jtx/impl/offer.cpp b/src/test/jtx/impl/offer.cpp index 2c40b9867b..5704349c83 100644 --- a/src/test/jtx/impl/offer.cpp +++ b/src/test/jtx/impl/offer.cpp @@ -19,8 +19,8 @@ offer( { json::Value jv; jv[jss::Account] = account.human(); - jv[jss::TakerPays] = takerPays.getJson(JsonOptions::KNone); - jv[jss::TakerGets] = takerGets.getJson(JsonOptions::KNone); + jv[jss::TakerPays] = takerPays.getJson(JsonOptions::Values::None); + jv[jss::TakerGets] = takerGets.getJson(JsonOptions::Values::None); if (flags != 0u) jv[jss::Flags] = flags; jv[jss::TransactionType] = jss::OfferCreate; diff --git a/src/test/jtx/impl/paths.cpp b/src/test/jtx/impl/paths.cpp index e644895cb0..eb4b36ae4f 100644 --- a/src/test/jtx/impl/paths.cpp +++ b/src/test/jtx/impl/paths.cpp @@ -61,20 +61,20 @@ Paths::operator()(Env& env, JTx& jt) const // VFALCO TODO API to allow caller to examine the STPathSet // VFALCO isDefault should be renamed to empty() if (!found.isDefault()) - jv[jss::Paths] = found.getJson(JsonOptions::KNone); + jv[jss::Paths] = found.getJson(JsonOptions::Values::None); } //------------------------------------------------------------------------------ Path::Path(STPath const& p) { - jv_ = p.getJson(JsonOptions::KNone); + jv_ = p.getJson(JsonOptions::Values::None); } json::Value& Path::create() { - return jv_.append(json::ObjectValue); + return jv_.append(json::ValueType::Object); } void diff --git a/src/test/jtx/impl/pay.cpp b/src/test/jtx/impl/pay.cpp index 90a9cd8df0..c220d9534b 100644 --- a/src/test/jtx/impl/pay.cpp +++ b/src/test/jtx/impl/pay.cpp @@ -16,7 +16,7 @@ pay(AccountID const& account, AccountID const& to, AnyAmount amount) amount.to(to); json::Value jv; jv[jss::Account] = to_string(account); - jv[jss::Amount] = amount.value.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.value.getJson(JsonOptions::Values::None); jv[jss::Destination] = to_string(to); jv[jss::TransactionType] = jss::Payment; jv[jss::Flags] = tfFullyCanonicalSig; diff --git a/src/test/jtx/impl/permissioned_domains.cpp b/src/test/jtx/impl/permissioned_domains.cpp index f39c9a43ed..690451c7d8 100644 --- a/src/test/jtx/impl/permissioned_domains.cpp +++ b/src/test/jtx/impl/permissioned_domains.cpp @@ -35,10 +35,10 @@ setTx(AccountID const& account, Credentials const& credentials, std::optional const& human2Acc) { Credentials ret; - json::Value credentials(json::ArrayValue); + json::Value credentials(json::ValueType::Array); credentials = object["AcceptedCredentials"]; for (auto const& credential : credentials) { - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); obj = credential[jss::Credential]; auto const& issuer = obj[jss::Issuer]; auto const& credentialType = obj["CredentialType"]; @@ -150,8 +150,8 @@ uint256 getNewDomain(std::shared_ptr const& meta) { uint256 ret; - auto metaJson = meta->getJson(JsonOptions::KNone); - json::Value a(json::ArrayValue); + auto metaJson = meta->getJson(JsonOptions::Values::None); + json::Value a(json::ValueType::Array); a = metaJson["AffectedNodes"]; for (auto const& node : a) diff --git a/src/test/jtx/impl/sendmax.cpp b/src/test/jtx/impl/sendmax.cpp index 3bc39a4a59..2ea8605081 100644 --- a/src/test/jtx/impl/sendmax.cpp +++ b/src/test/jtx/impl/sendmax.cpp @@ -10,7 +10,7 @@ namespace xrpl::test::jtx { void Sendmax::operator()(Env& env, JTx& jt) const { - jt.jv[jss::SendMax] = amount_.getJson(JsonOptions::KNone); + jt.jv[jss::SendMax] = amount_.getJson(JsonOptions::Values::None); } } // namespace xrpl::test::jtx diff --git a/src/test/jtx/impl/token.cpp b/src/test/jtx/impl/token.cpp index 27d21c1694..8604b077c4 100644 --- a/src/test/jtx/impl/token.cpp +++ b/src/test/jtx/impl/token.cpp @@ -50,7 +50,7 @@ Uri::operator()(Env& env, JTx& jt) const void Amount::operator()(Env& env, JTx& jt) const { - jt.jv[sfAmount.jsonName] = amount_.getJson(JsonOptions::KNone); + jt.jv[sfAmount.jsonName] = amount_.getJson(JsonOptions::Values::None); } uint256 @@ -98,7 +98,7 @@ createOffer(jtx::Account const& account, uint256 const& nftokenID, STAmount cons json::Value jv; jv[sfAccount.jsonName] = account.human(); jv[sfNFTokenID.jsonName] = to_string(nftokenID); - jv[sfAmount.jsonName] = amount.getJson(JsonOptions::KNone); + jv[sfAmount.jsonName] = amount.getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::NFTokenCreateOffer; return jv; } @@ -129,7 +129,7 @@ cancelOfferImpl(jtx::Account const& account, T const& nftokenOffers) jv[sfAccount.jsonName] = account.human(); if (!empty(nftokenOffers)) { - jv[sfNFTokenOffers.jsonName] = json::ArrayValue; + jv[sfNFTokenOffers.jsonName] = json::ValueType::Array; for (uint256 const& nftokenOffer : nftokenOffers) jv[sfNFTokenOffers.jsonName].append(to_string(nftokenOffer)); } @@ -192,7 +192,7 @@ brokerOffers( void BrokerFee::operator()(Env& env, JTx& jt) const { - jt.jv[sfNFTokenBrokerFee.jsonName] = brokerFee_.getJson(JsonOptions::KNone); + jt.jv[sfNFTokenBrokerFee.jsonName] = brokerFee_.getJson(JsonOptions::Values::None); } json::Value diff --git a/src/test/jtx/impl/trust.cpp b/src/test/jtx/impl/trust.cpp index ffe14694d9..17fc6e594f 100644 --- a/src/test/jtx/impl/trust.cpp +++ b/src/test/jtx/impl/trust.cpp @@ -21,7 +21,7 @@ trust(Account const& account, STAmount const& amount, std::uint32_t flags) Throw("trust() requires IOU"); json::Value jv; jv[jss::Account] = account.human(); - jv[jss::LimitAmount] = amount.getJson(JsonOptions::KNone); + jv[jss::LimitAmount] = amount.getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::TrustSet; jv[jss::Flags] = flags; return jv; @@ -39,7 +39,7 @@ trust(Account const& account, STAmount const& amount, Account const& peer, std:: json::Value jv; jv[jss::Account] = account.human(); { - auto& ja = jv[jss::LimitAmount] = amount.getJson(JsonOptions::KNone); + auto& ja = jv[jss::LimitAmount] = amount.getJson(JsonOptions::Values::None); ja[jss::issuer] = peer.human(); } jv[jss::TransactionType] = jss::TrustSet; @@ -52,7 +52,7 @@ claw(Account const& account, STAmount const& amount, std::optional cons { json::Value jv; jv[jss::Account] = account.human(); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::Clawback; if (mptHolder) diff --git a/src/test/jtx/impl/utility.cpp b/src/test/jtx/impl/utility.cpp index 21cf8a89c4..9256242417 100644 --- a/src/test/jtx/impl/utility.cpp +++ b/src/test/jtx/impl/utility.cpp @@ -77,7 +77,7 @@ fillSeq(json::Value& jv, ReadView const& view) json::Value cmdToJSONRPC(std::vector const& args, beast::Journal j, unsigned int apiVersion) { - json::Value jv = json::Value(json::ObjectValue); + json::Value jv = json::Value(json::ValueType::Object); auto const paramsObj = rpcCmdToJson(args, jv, apiVersion, j); // Re-use jv to return our formatted result. @@ -89,7 +89,7 @@ cmdToJSONRPC(std::vector const& args, beast::Journal j, unsigned in // If paramsObj is not empty, put it in a [params] array. if (paramsObj.begin() != paramsObj.end()) { - auto& paramsArray = jv[jss::params] = json::ArrayValue; + auto& paramsArray = jv[jss::params] = json::ValueType::Array; paramsArray.append(paramsObj); } if (paramsObj.isMember(jss::jsonrpc)) diff --git a/src/test/jtx/impl/xchain_bridge.cpp b/src/test/jtx/impl/xchain_bridge.cpp index 8941067378..dbd5e7de81 100644 --- a/src/test/jtx/impl/xchain_bridge.cpp +++ b/src/test/jtx/impl/xchain_bridge.cpp @@ -70,9 +70,12 @@ bridgeCreate( jv[jss::Account] = acc.human(); jv[sfXChainBridge.getJsonName()] = bridge; - jv[sfSignatureReward.getJsonName()] = reward.getJson(JsonOptions::KNone); + jv[sfSignatureReward.getJsonName()] = reward.getJson(JsonOptions::Values::None); if (minAccountCreate) - jv[sfMinAccountCreateAmount.getJsonName()] = minAccountCreate->getJson(JsonOptions::KNone); + { + jv[sfMinAccountCreateAmount.getJsonName()] = + minAccountCreate->getJson(JsonOptions::Values::None); + } jv[jss::TransactionType] = jss::XChainCreateBridge; return jv; @@ -90,9 +93,12 @@ bridgeModify( jv[jss::Account] = acc.human(); jv[sfXChainBridge.getJsonName()] = bridge; if (reward) - jv[sfSignatureReward.getJsonName()] = reward->getJson(JsonOptions::KNone); + jv[sfSignatureReward.getJsonName()] = reward->getJson(JsonOptions::Values::None); if (minAccountCreate) - jv[sfMinAccountCreateAmount.getJsonName()] = minAccountCreate->getJson(JsonOptions::KNone); + { + jv[sfMinAccountCreateAmount.getJsonName()] = + minAccountCreate->getJson(JsonOptions::Values::None); + } jv[jss::TransactionType] = jss::XChainModifyBridge; return jv; @@ -109,7 +115,7 @@ xchainCreateClaimId( jv[jss::Account] = acc.human(); jv[sfXChainBridge.getJsonName()] = bridge; - jv[sfSignatureReward.getJsonName()] = reward.getJson(JsonOptions::KNone); + jv[sfSignatureReward.getJsonName()] = reward.getJson(JsonOptions::Values::None); jv[sfOtherChainSource.getJsonName()] = otherChainSource.human(); jv[jss::TransactionType] = jss::XChainCreateClaimID; @@ -129,7 +135,7 @@ xchainCommit( jv[jss::Account] = acc.human(); jv[sfXChainBridge.getJsonName()] = bridge; jv[sfXChainClaimID.getJsonName()] = claimID; - jv[jss::Amount] = amt.value.getJson(JsonOptions::KNone); + jv[jss::Amount] = amt.value.getJson(JsonOptions::Values::None); if (dst) jv[sfOtherChainDestination.getJsonName()] = dst->human(); @@ -151,7 +157,7 @@ xchainClaim( jv[sfXChainBridge.getJsonName()] = bridge; jv[sfXChainClaimID.getJsonName()] = claimID; jv[sfDestination.getJsonName()] = dst.human(); - jv[sfAmount.getJsonName()] = amt.value.getJson(JsonOptions::KNone); + jv[sfAmount.getJsonName()] = amt.value.getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::XChainClaim; return jv; @@ -170,8 +176,8 @@ sidechainXchainAccountCreate( jv[sfAccount.getJsonName()] = acc.human(); jv[sfXChainBridge.getJsonName()] = bridge; jv[sfDestination.getJsonName()] = dst.human(); - jv[sfAmount.getJsonName()] = amt.value.getJson(JsonOptions::KNone); - jv[sfSignatureReward.getJsonName()] = reward.value.getJson(JsonOptions::KNone); + jv[sfAmount.getJsonName()] = amt.value.getJson(JsonOptions::Values::None); + jv[sfSignatureReward.getJsonName()] = reward.value.getJson(JsonOptions::Values::None); jv[jss::TransactionType] = jss::XChainAccountCreateCommit; return jv; @@ -213,11 +219,11 @@ claimAttestation( result[sfPublicKey.getJsonName()] = strHex(pk.slice()); result[sfSignature.getJsonName()] = strHex(sig); result[sfOtherChainSource.getJsonName()] = toBase58(sendingAccount); - result[sfAmount.getJsonName()] = sendingAmount.value.getJson(JsonOptions::KNone); + result[sfAmount.getJsonName()] = sendingAmount.value.getJson(JsonOptions::Values::None); result[sfAttestationRewardAccount.getJsonName()] = toBase58(rewardAccount); result[sfWasLockingChainSend.getJsonName()] = wasLockingChainSend ? 1 : 0; - result[sfXChainClaimID.getJsonName()] = STUInt64{claimID}.getJson(JsonOptions::KNone); + result[sfXChainClaimID.getJsonName()] = STUInt64{claimID}.getJson(JsonOptions::Values::None); if (dst) result[sfDestination.getJsonName()] = toBase58(*dst); @@ -264,14 +270,14 @@ createAccountAttestation( result[sfPublicKey.getJsonName()] = strHex(pk.slice()); result[sfSignature.getJsonName()] = strHex(sig); result[sfOtherChainSource.getJsonName()] = toBase58(sendingAccount); - result[sfAmount.getJsonName()] = sendingAmount.value.getJson(JsonOptions::KNone); + result[sfAmount.getJsonName()] = sendingAmount.value.getJson(JsonOptions::Values::None); result[sfAttestationRewardAccount.getJsonName()] = toBase58(rewardAccount); result[sfWasLockingChainSend.getJsonName()] = wasLockingChainSend ? 1 : 0; result[sfXChainAccountCreateCount.getJsonName()] = - STUInt64{createCount}.getJson(JsonOptions::KNone); + STUInt64{createCount}.getJson(JsonOptions::Values::None); result[sfDestination.getJsonName()] = toBase58(dst); - result[sfSignatureReward.getJsonName()] = rewardAmount.value.getJson(JsonOptions::KNone); + result[sfSignatureReward.getJsonName()] = rewardAmount.value.getJson(JsonOptions::Values::None); result[jss::TransactionType] = jss::XChainAddAccountCreateAttestation; diff --git a/src/test/jtx/paths.h b/src/test/jtx/paths.h index e2c88e215d..a8a8f7900c 100644 --- a/src/test/jtx/paths.h +++ b/src/test/jtx/paths.h @@ -80,7 +80,7 @@ private: }; template -Path::Path(T const& t, Args const&... args) : jv_(json::ArrayValue) +Path::Path(T const& t, Args const&... args) : jv_(json::ValueType::Array) { append(t, args...); } diff --git a/src/test/jtx/xchain_bridge.h b/src/test/jtx/xchain_bridge.h index d33b3bf4ac..fc2665672f 100644 --- a/src/test/jtx/xchain_bridge.h +++ b/src/test/jtx/xchain_bridge.h @@ -220,12 +220,12 @@ struct XChainBridgeObjects [[nodiscard]] json::Value createBridge( Account const& acc, - json::Value const& bridge = json::NullValue, + json::Value const& bridge = json::ValueType::Null, STAmount const& reward = XRP(1), std::optional const& minAccountCreate = std::nullopt) const { return bridgeCreate( - acc, bridge == json::NullValue ? jvb : bridge, reward, minAccountCreate); + acc, bridge == json::ValueType::Null ? jvb : bridge, reward, minAccountCreate); } }; diff --git a/src/test/ledger/View_test.cpp b/src/test/ledger/View_test.cpp index 2cf6517c8a..4b65193f8e 100644 --- a/src/test/ledger/View_test.cpp +++ b/src/test/ledger/View_test.cpp @@ -958,7 +958,7 @@ class View_test : public beast::unit_test::Suite auto const bob = Account("bob"); // The first Env. - Env eA(*this, envconfig(), nullptr, beast::severities::KDisabled); + Env eA(*this, envconfig(), nullptr, beast::Severity::Disabled); eA.fund(XRP(10000), alice); eA.close(); @@ -970,7 +970,7 @@ class View_test : public beast::unit_test::Suite // The two Env's can't share the same ports, so modify the config // of the second Env to use higher port numbers - Env eB{*this, envconfig(), nullptr, beast::severities::KDisabled}; + Env eB{*this, envconfig(), nullptr, beast::Severity::Disabled}; // Make ledgers that are incompatible with the first ledgers. Note // that bob is funded before alice. diff --git a/src/test/nodestore/Backend_test.cpp b/src/test/nodestore/Backend_test.cpp index 110d142f57..32b7d46868 100644 --- a/src/test/nodestore/Backend_test.cpp +++ b/src/test/nodestore/Backend_test.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -40,7 +41,7 @@ public: // Create a batch auto batch = createPredictableBatch(numObjsToTest, rng()); - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("Backend_test", *this); { diff --git a/src/test/nodestore/Database_test.cpp b/src/test/nodestore/Database_test.cpp index a152bb3a2d..f06e2e6c47 100644 --- a/src/test/nodestore/Database_test.cpp +++ b/src/test/nodestore/Database_test.cpp @@ -80,7 +80,7 @@ public: *this, std::move(p), std::make_unique(integrityWarning, &found), - beast::severities::KWarning); + beast::Severity::Warning); }(); BEAST_EXPECT(!found); @@ -109,7 +109,7 @@ public: *this, std::move(p), std::make_unique(integrityWarning, &found), - beast::severities::KWarning); + beast::Severity::Warning); }(); BEAST_EXPECT(found); @@ -139,7 +139,7 @@ public: *this, std::move(p), std::make_unique(integrityWarning, &found), - beast::severities::KWarning); + beast::Severity::Warning); }(); // No warning, even though higher risk settings were used because @@ -172,7 +172,7 @@ public: *this, std::move(p), std::make_unique(integrityWarning, &found), - beast::severities::KWarning); + beast::Severity::Warning); }(); // No warning, even though higher risk settings were used because @@ -210,7 +210,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -239,7 +239,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -268,7 +268,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -297,7 +297,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -325,7 +325,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -353,7 +353,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -381,7 +381,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -409,7 +409,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -464,7 +464,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -487,7 +487,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) @@ -510,7 +510,7 @@ public: *this, std::move(p), std::make_unique(expected, &found), - beast::severities::KWarning); + beast::Severity::Warning); fail(); } catch (...) diff --git a/src/test/nodestore/NuDBFactory_test.cpp b/src/test/nodestore/NuDBFactory_test.cpp index 2c817c0d6c..fae13b9cc8 100644 --- a/src/test/nodestore/NuDBFactory_test.cpp +++ b/src/test/nodestore/NuDBFactory_test.cpp @@ -78,10 +78,7 @@ private: // Helper function to test log messages void - testLogMessage( - Section const& params, - beast::severities::Severity level, - std::string const& expectedMessage) + testLogMessage(Section const& params, beast::Severity level, std::string const& expectedMessage) { test::StreamSink sink(level); beast::Journal const journal(sink); @@ -100,7 +97,7 @@ private: beast::TempDir const tempDir; auto params = createSection(tempDir.path(), size); - test::StreamSink sink(beast::severities::KWarning); + test::StreamSink sink(beast::Severity::Warning); beast::Journal const journal(sink); DummyScheduler scheduler; @@ -202,7 +199,7 @@ public: beast::TempDir const tempDir; auto params = createSection(tempDir.path(), "8192"); - testLogMessage(params, beast::severities::KInfo, "Using custom NuDB block size: 8192"); + testLogMessage(params, beast::Severity::Info, "Using custom NuDB block size: 8192"); } // Test invalid block size failure @@ -210,7 +207,7 @@ public: beast::TempDir const tempDir; auto params = createSection(tempDir.path(), "5000"); - test::StreamSink sink(beast::severities::KWarning); + test::StreamSink sink(beast::Severity::Warning); beast::Journal const journal(sink); DummyScheduler scheduler; @@ -235,7 +232,7 @@ public: beast::TempDir const tempDir; auto params = createSection(tempDir.path(), "invalid"); - test::StreamSink sink(beast::severities::KWarning); + test::StreamSink sink(beast::Severity::Warning); beast::Journal const journal(sink); DummyScheduler scheduler; @@ -280,7 +277,7 @@ public: // We test the validation logic by catching exceptions for invalid // values - test::StreamSink sink(beast::severities::KWarning); + test::StreamSink sink(beast::Severity::Warning); beast::Journal const journal(sink); DummyScheduler scheduler; @@ -348,7 +345,7 @@ public: beast::TempDir const tempDir; auto params = createSection(tempDir.path(), format); - test::StreamSink sink(beast::severities::KInfo); + test::StreamSink sink(beast::Severity::Info); beast::Journal const journal(sink); DummyScheduler scheduler; @@ -370,7 +367,7 @@ public: auto params = createSection(tempDir.path(), format); // Use a lower threshold to capture both info and warning messages - test::StreamSink sink(beast::severities::KDebug); + test::StreamSink sink(beast::Severity::Debug); beast::Journal const journal(sink); DummyScheduler scheduler; diff --git a/src/test/nodestore/Timing_test.cpp b/src/test/nodestore/Timing_test.cpp index dfc1a0235d..6e4e6be37e 100644 --- a/src/test/nodestore/Timing_test.cpp +++ b/src/test/nodestore/Timing_test.cpp @@ -77,9 +77,10 @@ rngcpy(void* buffer, std::size_t bytes, Generator& g) class Sequence { private: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { MinLedger = 1, MaxLedger = 1000000, MinSize = 250, MaxSize = 1250 }; + static constexpr auto kMIN_LEDGER = 1; + static constexpr auto kMAX_LEDGER = 1000000; + static constexpr auto kMIN_SIZE = 250; + static constexpr auto kMAX_SIZE = 1250; beast::xor_shift_engine gen_; std::uint8_t prefix_; @@ -92,7 +93,7 @@ public: // uniform distribution over hotLEDGER - hotTRANSACTION_NODE // but exclude hotTRANSACTION = 2 (removed) , d_type_({1, 1, 0, 1, 1}) - , d_size_(MinSize, MaxSize) + , d_size_(kMIN_SIZE, kMAX_SIZE) { } @@ -137,12 +138,7 @@ public: class Timing_test : public beast::unit_test::Suite { public: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { - // percent of fetches for missing nodes - MissingNodePercent = 20 - }; + static constexpr auto kMISSING_NODE_PERCENT = 20; // percent of fetches for missing nodes std::size_t const default_repeat = 3; #ifndef NDEBUG @@ -466,7 +462,7 @@ public: { try { - if (rand_(gen_) < MissingNodePercent) + if (rand_(gen_) < kMISSING_NODE_PERCENT) { auto const hash = seq2_.key(dist_(gen_)); std::shared_ptr result; @@ -653,7 +649,7 @@ public: log << ss.str() << std::endl; } - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("Timing_test", *this); for (auto const& configString : configStrings) diff --git a/src/test/overlay/TMGetObjectByHash_test.cpp b/src/test/overlay/TMGetObjectByHash_test.cpp index fa47f42740..83fc91ffbe 100644 --- a/src/test/overlay/TMGetObjectByHash_test.cpp +++ b/src/test/overlay/TMGetObjectByHash_test.cpp @@ -213,7 +213,7 @@ class TMGetObjectByHash_test : public beast::unit_test::Suite void run() override { - int const limit = static_cast(Tuning::HardMaxReplyNodes); + int const limit = static_cast(Tuning::kHARD_MAX_REPLY_NODES); testReplyLimit(limit + 1, limit); testReplyLimit(limit, limit); testReplyLimit(limit - 1, limit - 1); diff --git a/src/test/overlay/compression_test.cpp b/src/test/overlay/compression_test.cpp index 0e75b26d51..01ea14160e 100644 --- a/src/test/overlay/compression_test.cpp +++ b/src/test/overlay/compression_test.cpp @@ -350,7 +350,7 @@ public: void testProtocol() { - auto thresh = beast::severities::Severity::KInfo; + auto thresh = beast::Severity::Info; auto logs = std::make_unique(thresh); protocol::TMManifests const manifests; diff --git a/src/test/overlay/short_read_test.cpp b/src/test/overlay/short_read_test.cpp index 1b608edee7..95ab5e8c20 100644 --- a/src/test/overlay/short_read_test.cpp +++ b/src/test/overlay/short_read_test.cpp @@ -19,7 +19,7 @@ #include #include #include -#include +#include // IWYU pragma: keep #include #include diff --git a/src/test/peerfinder/PeerFinder_test.cpp b/src/test/peerfinder/PeerFinder_test.cpp index 17ce6835ef..2e4ab001b4 100644 --- a/src/test/peerfinder/PeerFinder_test.cpp +++ b/src/test/peerfinder/PeerFinder_test.cpp @@ -424,7 +424,7 @@ public: (c.PEERS_MAX == max && c.PEERS_IN_MAX == 0 && c.PEERS_OUT_MAX == 0) || (c.PEERS_IN_MAX == *maxIn && c.PEERS_OUT_MAX == *maxOut)); - Config const config = Config::makeConfig(c, port, false, 0); + Config const config = Config::makeConfig(c, port, false, 0, true); Counts counts; counts.onConfig(config); diff --git a/src/test/protocol/MultiApiJson_test.cpp b/src/test/protocol/MultiApiJson_test.cpp index e66403e0ae..2e5a2bb433 100644 --- a/src/test/protocol/MultiApiJson_test.cpp +++ b/src/test/protocol/MultiApiJson_test.cpp @@ -30,7 +30,7 @@ struct MultiApiJson_test : beast::unit_test::Suite static auto makeJson(char const* key, int val) { - json::Value obj1(json::ObjectValue); + json::Value obj1(json::ValueType::Object); obj1[key] = val; return obj1; } @@ -278,7 +278,7 @@ struct MultiApiJson_test : beast::unit_test::Suite { testcase("set"); - auto x = MultiApiJson<1, 2>{json::ObjectValue}; + auto x = MultiApiJson<1, 2>{json::ValueType::Object}; x.set("name1", 42); BEAST_EXPECT(x.val[0].isMember("name1")); BEAST_EXPECT(x.val[1].isMember("name1")); @@ -296,7 +296,8 @@ struct MultiApiJson_test : beast::unit_test::Suite BEAST_EXPECT(x.val[1]["name2"].asString() == "bar"); // Tests of requires clause - these are expected to match - static_assert([](auto&& v) { return requires { v.set("name", json::NullValue); }; }(x)); + static_assert( + [](auto&& v) { return requires { v.set("name", json::ValueType::Null); }; }(x)); static_assert([](auto&& v) { return requires { v.set("name", "value"); }; }(x)); static_assert([](auto&& v) { return requires { v.set("name", true); }; }(x)); static_assert([](auto&& v) { return requires { v.set("name", 42); }; }(x)); diff --git a/src/test/protocol/STInteger_test.cpp b/src/test/protocol/STInteger_test.cpp index b28273ffb9..789555560d 100644 --- a/src/test/protocol/STInteger_test.cpp +++ b/src/test/protocol/STInteger_test.cpp @@ -17,7 +17,7 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT(u8.value() == 255); BEAST_EXPECT(u8.getText() == "255"); BEAST_EXPECT(u8.getSType() == STI_UINT8); - BEAST_EXPECT(u8.getJson(JsonOptions::KNone) == 255); + BEAST_EXPECT(u8.getJson(JsonOptions::Values::None) == 255); // there is some special handling for sfTransactionResult STUInt8 const tr(sfTransactionResult, 0); @@ -25,14 +25,14 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT( tr.getText() == "The transaction was applied. Only final in a validated ledger."); BEAST_EXPECT(tr.getSType() == STI_UINT8); - BEAST_EXPECT(tr.getJson(JsonOptions::KNone) == "tesSUCCESS"); + BEAST_EXPECT(tr.getJson(JsonOptions::Values::None) == "tesSUCCESS"); // invalid transaction result STUInt8 const tr2(sfTransactionResult, 255); BEAST_EXPECT(tr2.value() == 255); BEAST_EXPECT(tr2.getText() == "255"); BEAST_EXPECT(tr2.getSType() == STI_UINT8); - BEAST_EXPECT(tr2.getJson(JsonOptions::KNone) == 255); + BEAST_EXPECT(tr2.getJson(JsonOptions::Values::None) == 255); } void @@ -43,21 +43,21 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT(u16.value() == 65535); BEAST_EXPECT(u16.getText() == "65535"); BEAST_EXPECT(u16.getSType() == STI_UINT16); - BEAST_EXPECT(u16.getJson(JsonOptions::KNone) == 65535); + BEAST_EXPECT(u16.getJson(JsonOptions::Values::None) == 65535); // there is some special handling for sfLedgerEntryType STUInt16 const let(sfLedgerEntryType, ltACCOUNT_ROOT); BEAST_EXPECT(let.value() == ltACCOUNT_ROOT); BEAST_EXPECT(let.getText() == "AccountRoot"); BEAST_EXPECT(let.getSType() == STI_UINT16); - BEAST_EXPECT(let.getJson(JsonOptions::KNone) == "AccountRoot"); + BEAST_EXPECT(let.getJson(JsonOptions::Values::None) == "AccountRoot"); // there is some special handling for sfTransactionType STUInt16 const tlt(sfTransactionType, ttPAYMENT); BEAST_EXPECT(tlt.value() == ttPAYMENT); BEAST_EXPECT(tlt.getText() == "Payment"); BEAST_EXPECT(tlt.getSType() == STI_UINT16); - BEAST_EXPECT(tlt.getJson(JsonOptions::KNone) == "Payment"); + BEAST_EXPECT(tlt.getJson(JsonOptions::Values::None) == "Payment"); } void @@ -68,19 +68,19 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT(u32.value() == 4'294'967'295u); BEAST_EXPECT(u32.getText() == "4294967295"); BEAST_EXPECT(u32.getSType() == STI_UINT32); - BEAST_EXPECT(u32.getJson(JsonOptions::KNone) == 4'294'967'295u); + BEAST_EXPECT(u32.getJson(JsonOptions::Values::None) == 4'294'967'295u); // there is some special handling for sfPermissionValue STUInt32 const pv(sfPermissionValue, ttPAYMENT + 1); BEAST_EXPECT(pv.value() == ttPAYMENT + 1); BEAST_EXPECT(pv.getText() == "Payment"); BEAST_EXPECT(pv.getSType() == STI_UINT32); - BEAST_EXPECT(pv.getJson(JsonOptions::KNone) == "Payment"); + BEAST_EXPECT(pv.getJson(JsonOptions::Values::None) == "Payment"); STUInt32 const pv2(sfPermissionValue, PaymentMint); BEAST_EXPECT(pv2.value() == PaymentMint); BEAST_EXPECT(pv2.getText() == "PaymentMint"); BEAST_EXPECT(pv2.getSType() == STI_UINT32); - BEAST_EXPECT(pv2.getJson(JsonOptions::KNone) == "PaymentMint"); + BEAST_EXPECT(pv2.getJson(JsonOptions::Values::None) == "PaymentMint"); } void @@ -93,7 +93,7 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT(u64.getSType() == STI_UINT64); // By default, getJson returns hex string - auto jsonVal = u64.getJson(JsonOptions::KNone); + auto jsonVal = u64.getJson(JsonOptions::Values::None); BEAST_EXPECT(jsonVal.isString()); BEAST_EXPECT(jsonVal.asString() == "ffffffffffffffff"); @@ -101,7 +101,7 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT(u642.value() == 0xFFFFFFFFFFFFFFFFull); BEAST_EXPECT(u642.getText() == "18446744073709551615"); BEAST_EXPECT(u642.getSType() == STI_UINT64); - BEAST_EXPECT(u642.getJson(JsonOptions::KNone) == "18446744073709551615"); + BEAST_EXPECT(u642.getJson(JsonOptions::Values::None) == "18446744073709551615"); } void @@ -114,7 +114,7 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT(i32.value() == minInt32); BEAST_EXPECT(i32.getText() == "-2147483648"); BEAST_EXPECT(i32.getSType() == STI_INT32); - BEAST_EXPECT(i32.getJson(JsonOptions::KNone) == minInt32); + BEAST_EXPECT(i32.getJson(JsonOptions::Values::None) == minInt32); } { @@ -123,7 +123,7 @@ struct STInteger_test : public beast::unit_test::Suite BEAST_EXPECT(i32.value() == maxInt32); BEAST_EXPECT(i32.getText() == "2147483647"); BEAST_EXPECT(i32.getSType() == STI_INT32); - BEAST_EXPECT(i32.getJson(JsonOptions::KNone) == maxInt32); + BEAST_EXPECT(i32.getJson(JsonOptions::Values::None) == maxInt32); } } diff --git a/src/test/protocol/STIssue_test.cpp b/src/test/protocol/STIssue_test.cpp index 04364510f0..1d6d750355 100644 --- a/src/test/protocol/STIssue_test.cpp +++ b/src/test/protocol/STIssue_test.cpp @@ -55,7 +55,7 @@ public: auto const data = "00000000000000000000000055534400000000000000000000000000000000" "000000000000000000"; - BaseUint<320> uint; + BaseUInt<320> uint; (void)uint.parseHex(data); SerialIter iter(Slice(uint.data(), uint.size())); STIssue const stissue(iter, sfAsset); @@ -89,7 +89,7 @@ public: auto const data = "0000000000000000000000005553440000000000ae123a8556f3cf91154711" "376afb0f894f832b3d"; - BaseUint<320> uint; + BaseUInt<320> uint; (void)uint.parseHex(data); SerialIter iter(Slice(uint.data(), uint.size())); STIssue const stissue(iter, sfAsset); @@ -103,7 +103,7 @@ public: try { auto const data = "0000000000000000000000000000000000000000"; - BaseUint<160> uint; + BaseUInt<160> uint; (void)uint.parseHex(data); SerialIter iter(Slice(uint.data(), uint.size())); STIssue const stissue(iter, sfAsset); diff --git a/src/test/protocol/STObject_test.cpp b/src/test/protocol/STObject_test.cpp index a408f2503b..1621a278ea 100644 --- a/src/test/protocol/STObject_test.cpp +++ b/src/test/protocol/STObject_test.cpp @@ -103,8 +103,8 @@ public: if (object1.getSerializer() == object2.getSerializer()) { - log << "O1: " << object1.getJson(JsonOptions::KNone) << '\n' - << "O2: " << object2.getJson(JsonOptions::KNone) << std::endl; + log << "O1: " << object1.getJson(JsonOptions::Values::None) << '\n' + << "O2: " << object2.getJson(JsonOptions::Values::None) << std::endl; fail("STObject error 4"); } else diff --git a/src/test/protocol/STParsedJSON_test.cpp b/src/test/protocol/STParsedJSON_test.cpp index ef2f8e971e..bc5c72b4fc 100644 --- a/src/test/protocol/STParsedJSON_test.cpp +++ b/src/test/protocol/STParsedJSON_test.cpp @@ -102,7 +102,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (not a string/int/uint) { json::Value j; - j[sfCloseResolution] = json::Value(json::ArrayValue); + j[sfCloseResolution] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -110,7 +110,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (not a string/int/uint) { json::Value j; - j[sfCloseResolution] = json::Value(json::ObjectValue); + j[sfCloseResolution] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -193,7 +193,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (not a string/int/uint) { json::Value j; - j[sfLedgerEntryType] = json::Value(json::ArrayValue); + j[sfLedgerEntryType] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -201,7 +201,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (not a string/int/uint) { json::Value j; - j[sfLedgerEntryType] = json::Value(json::ObjectValue); + j[sfLedgerEntryType] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -271,7 +271,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (arrayValue) { json::Value j; - j[sfNetworkID] = json::Value(json::ArrayValue); + j[sfNetworkID] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -279,7 +279,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (objectValue) { json::Value j; - j[sfNetworkID] = json::Value(json::ObjectValue); + j[sfNetworkID] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -348,7 +348,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // test arrayValue { json::Value j; - j[sfIndexNext] = json::Value(json::ArrayValue); + j[sfIndexNext] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -356,7 +356,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // test objectValue { json::Value j; - j[sfIndexNext] = json::Value(json::ObjectValue); + j[sfIndexNext] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -393,7 +393,7 @@ class STParsedJSON_test : public beast::unit_test::Suite 0xCD, 0xEF}; // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - BEAST_EXPECT(obj.object->getFieldH128(sfEmailHash) == uint128{expected}); + BEAST_EXPECT(obj.object->getFieldH128(sfEmailHash) == uint128::fromRaw(expected)); } // Valid lowercase hex string for UInt128 @@ -458,7 +458,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Array value for UInt128 (should fail) { json::Value j; - j[sfEmailHash] = json::Value(json::ArrayValue); + j[sfEmailHash] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -466,7 +466,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Object value for UInt128 (should fail) { json::Value j; - j[sfEmailHash] = json::Value(json::ObjectValue); + j[sfEmailHash] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -488,8 +488,9 @@ class STParsedJSON_test : public beast::unit_test::Suite std::array const expected = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67}; - // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - BEAST_EXPECT(obj.object->getFieldH160(sfTakerPaysCurrency) == uint160{expected}); + BEAST_EXPECT( + // NOLINTNEXTLINE(bugprone-unchecked-optional-access) + obj.object->getFieldH160(sfTakerPaysCurrency) == uint160::fromRaw(expected)); } // Valid lowercase hex string for UInt160 { @@ -545,7 +546,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Array value for UInt160 (should fail) { json::Value j; - j[sfTakerPaysCurrency] = json::Value(json::ArrayValue); + j[sfTakerPaysCurrency] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -553,7 +554,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Object value for UInt160 (should fail) { json::Value j; - j[sfTakerPaysCurrency] = json::Value(json::ObjectValue); + j[sfTakerPaysCurrency] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -575,8 +576,9 @@ class STParsedJSON_test : public beast::unit_test::Suite std::array const expected = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; - // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - BEAST_EXPECT(obj.object->getFieldH192(sfMPTokenIssuanceID) == uint192{expected}); + BEAST_EXPECT( + // NOLINTNEXTLINE(bugprone-unchecked-optional-access) + obj.object->getFieldH192(sfMPTokenIssuanceID) == uint192::fromRaw(expected)); } // Valid lowercase hex string for UInt192 @@ -641,7 +643,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Array value for UInt192 (should fail) { json::Value j; - j[sfMPTokenIssuanceID] = json::Value(json::ArrayValue); + j[sfMPTokenIssuanceID] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -649,7 +651,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Object value for UInt192 (should fail) { json::Value j; - j[sfMPTokenIssuanceID] = json::Value(json::ObjectValue); + j[sfMPTokenIssuanceID] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -676,7 +678,7 @@ class STParsedJSON_test : public beast::unit_test::Suite 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - BEAST_EXPECT(obj.object->getFieldH256(sfLedgerHash) == uint256{expected}); + BEAST_EXPECT(obj.object->getFieldH256(sfLedgerHash) == uint256::fromRaw(expected)); } // Valid lowercase hex string for UInt256 { @@ -746,7 +748,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Array value for UInt256 (should fail) { json::Value j; - j[sfLedgerHash] = json::Value(json::ArrayValue); + j[sfLedgerHash] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -754,7 +756,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Object value for UInt256 (should fail) { json::Value j; - j[sfLedgerHash] = json::Value(json::ObjectValue); + j[sfLedgerHash] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -865,7 +867,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (arrayValue) { json::Value j; - j[sfLoanScale] = json::Value(json::ArrayValue); + j[sfLoanScale] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -873,7 +875,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test bad_type (objectValue) { json::Value j; - j[sfLoanScale] = json::Value(json::ObjectValue); + j[sfLoanScale] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -941,7 +943,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test array value for blob (should fail) { json::Value j; - j[sfPublicKey] = json::Value(json::ArrayValue); + j[sfPublicKey] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -949,7 +951,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test object value for blob (should fail) { json::Value j; - j[sfPublicKey] = json::Value(json::ObjectValue); + j[sfPublicKey] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -962,7 +964,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with valid array of hex strings for Vector256 { json::Value j; - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr.append( "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCD" "EF"); @@ -983,7 +985,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test empty array for Vector256 (should be valid, size 0) { json::Value j; - json::Value const arr(json::ArrayValue); + json::Value const arr(json::ValueType::Array); j[sfHashes] = arr; STParsedJSONObject obj("Test", j); BEAST_EXPECT(obj.object.has_value()); @@ -997,7 +999,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test array with invalid hex string (should fail) { json::Value j; - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr.append("nothexstring"); j[sfHashes] = arr; STParsedJSONObject const obj("Test", j); @@ -1007,7 +1009,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test array with string of wrong length (should fail) { json::Value j; - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr.append("0123456789ABCDEF"); // too short for uint256 j[sfHashes] = arr; STParsedJSONObject const obj("Test", j); @@ -1017,7 +1019,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test array with non-string element (should fail) { json::Value j; - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr.append(12345); j[sfHashes] = arr; STParsedJSONObject const obj("Test", j); @@ -1035,8 +1037,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test array with object element (should fail) { json::Value j; - json::Value arr(json::ArrayValue); - json::Value objElem(json::ObjectValue); + json::Value arr(json::ValueType::Array); + json::Value objElem(json::ValueType::Object); objElem["foo"] = "bar"; arr.append(objElem); j[sfHashes] = arr; @@ -1119,7 +1121,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Array value for AccountID (should fail) { json::Value j; - j[sfAccount] = json::Value(json::ArrayValue); + j[sfAccount] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1127,7 +1129,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Object value for AccountID (should fail) { json::Value j; - j[sfAccount] = json::Value(json::ObjectValue); + j[sfAccount] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1229,7 +1231,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Array value for currency (should fail) { json::Value j; - j[sfBaseAsset] = json::Value(json::ArrayValue); + j[sfBaseAsset] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1237,7 +1239,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Object value for currency (should fail) { json::Value j; - j[sfBaseAsset] = json::Value(json::ObjectValue); + j[sfBaseAsset] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1298,7 +1300,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with object value for Amount (should fail) { json::Value j; - j[sfAmount] = json::Value(json::ObjectValue); + j[sfAmount] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1311,13 +1313,13 @@ class STParsedJSON_test : public beast::unit_test::Suite // Valid test: single path with single element { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["account"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; elem["currency"] = "USD"; elem["issuer"] = "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe"; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject obj("Test", j); @@ -1343,13 +1345,13 @@ class STParsedJSON_test : public beast::unit_test::Suite // Valid test: non-standard currency code { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["account"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; elem["currency"] = "0123456789ABCDEF01230123456789ABCDEF0123"; elem["issuer"] = "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe"; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject obj("Test", j); @@ -1372,7 +1374,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with array containing non-array element (should fail) { json::Value j; - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append("notanarray"); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1383,9 +1385,9 @@ class STParsedJSON_test : public beast::unit_test::Suite // fail) { json::Value j; - json::Value path(json::ArrayValue); + json::Value path(json::ValueType::Array); path.append("notanobject"); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1396,11 +1398,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // (should fail) { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["foo"] = "bar"; // not a valid path element key path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1411,11 +1413,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // value (should fail) { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["account"] = "notAValidBase58Account"; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1425,11 +1427,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with account not string (should fail) { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["account"] = 12345; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1439,11 +1441,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with currency not string (should fail) { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["currency"] = 12345; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1453,11 +1455,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with non-standard currency not hex (should fail) { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["currency"] = "notAValidCurrency"; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1467,11 +1469,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with issuer not string (should fail) { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["issuer"] = 12345; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1481,11 +1483,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with issuer not base58 (should fail) { json::Value j; - json::Value path(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value path(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["issuer"] = "notAValidBase58Account"; path.append(elem); - json::Value pathset(json::ArrayValue); + json::Value pathset(json::ValueType::Array); pathset.append(path); j[sfPaths] = pathset; STParsedJSONObject const obj("Test", j); @@ -1500,7 +1502,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Valid Issue: currency and issuer as base58 { json::Value j; - json::Value issueJson(json::ObjectValue); + json::Value issueJson(json::ValueType::Object); issueJson["currency"] = "USD"; issueJson["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; j[sfAsset] = issueJson; @@ -1523,7 +1525,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Valid Issue: currency as hex { json::Value j; - json::Value issueJson(json::ObjectValue); + json::Value issueJson(json::ValueType::Object); issueJson["currency"] = "0123456789ABCDEF01230123456789ABCDEF0123"; issueJson["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; j[sfAsset] = issueJson; @@ -1541,7 +1543,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Valid Issue: MPTID { json::Value j; - json::Value issueJson(json::ObjectValue); + json::Value issueJson(json::ValueType::Object); issueJson["mpt_issuance_id"] = "0000000000000000000000004D5054494431323334234234"; j[sfAsset] = issueJson; STParsedJSONObject obj("Test", j); @@ -1557,7 +1559,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid Issue: missing currency { json::Value j; - json::Value issue(json::ObjectValue); + json::Value issue(json::ValueType::Object); issue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; j[sfAsset] = issue; STParsedJSONObject const obj("Test", j); @@ -1567,7 +1569,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid Issue: missing issuer { json::Value j; - json::Value issue(json::ObjectValue); + json::Value issue(json::ValueType::Object); issue["currency"] = "USD"; j[sfAsset] = issue; STParsedJSONObject const obj("Test", j); @@ -1577,7 +1579,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid Issue: currency too long { json::Value j; - json::Value issue(json::ObjectValue); + json::Value issue(json::ValueType::Object); issue["currency"] = "USDD"; issue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; j[sfAsset] = issue; @@ -1588,7 +1590,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid Issue: issuer not base58 or hex { json::Value j; - json::Value issue(json::ObjectValue); + json::Value issue(json::ValueType::Object); issue["currency"] = "USD"; issue["issuer"] = "notAValidIssuer"; j[sfAsset] = issue; @@ -1599,8 +1601,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid Issue: currency not string { json::Value j; - json::Value issue(json::ObjectValue); - issue["currency"] = json::Value(json::ArrayValue); + json::Value issue(json::ValueType::Object); + issue["currency"] = json::Value(json::ValueType::Array); issue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; j[sfAsset] = issue; STParsedJSONObject const obj("Test", j); @@ -1610,9 +1612,9 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid Issue: issuer not string { json::Value j; - json::Value issue(json::ObjectValue); + json::Value issue(json::ValueType::Object); issue["currency"] = "USD"; - issue["issuer"] = json::Value(json::ObjectValue); + issue["issuer"] = json::Value(json::ValueType::Object); j[sfAsset] = issue; STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); @@ -1634,11 +1636,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Valid XChainBridge { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value issuingChainIssue(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value issuingChainIssue(json::ValueType::Object); issuingChainIssue["currency"] = "USD"; issuingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; - json::Value lockingChainIssue(json::ObjectValue); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "EUR"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1659,11 +1661,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Valid XChainBridge: issues as hex currency { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value issuingChainIssue(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value issuingChainIssue(json::ValueType::Object); issuingChainIssue["currency"] = "0123456789ABCDEF01230123456789ABCDEF0123"; issuingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; - json::Value lockingChainIssue(json::ObjectValue); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "0123456789ABCDEF01230123456789ABCDEF0123"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1684,8 +1686,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: missing LockingChainIssue { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value issuingChainIssue(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value issuingChainIssue(json::ValueType::Object); issuingChainIssue["currency"] = "USD"; issuingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["IssuingChainIssue"] = issuingChainIssue; @@ -1699,8 +1701,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: missing IssuingChainIssue { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value lockingChainIssue(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "EUR"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1714,12 +1716,12 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: missing LockingChainDoor { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value issuingChainIssue(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value issuingChainIssue(json::ValueType::Object); issuingChainIssue["currency"] = "USD"; issuingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["IssuingChainIssue"] = issuingChainIssue; - json::Value lockingChainIssue(json::ObjectValue); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "EUR"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1732,12 +1734,12 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: missing IssuingChainDoor { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value issuingChainIssue(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value issuingChainIssue(json::ValueType::Object); issuingChainIssue["currency"] = "USD"; issuingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["IssuingChainIssue"] = issuingChainIssue; - json::Value lockingChainIssue(json::ObjectValue); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "EUR"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1750,7 +1752,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: IssuingChainIssue not an object { json::Value j; - json::Value bridge(json::ObjectValue); + json::Value bridge(json::ValueType::Object); bridge["LockingChainIssue"] = "notanobject"; bridge["IssuingChainIssue"] = "notanobject"; j[sfXChainBridge] = bridge; @@ -1761,10 +1763,10 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: IssuingChainIssue missing currency { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value asset(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value asset(json::ValueType::Object); asset["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; - json::Value lockingChainIssue(json::ObjectValue); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "EUR"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1777,10 +1779,10 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: asset missing issuer { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value asset(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value asset(json::ValueType::Object); asset["currency"] = "USD"; - json::Value lockingChainIssue(json::ObjectValue); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "EUR"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1793,11 +1795,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid XChainBridge: asset issuer not base58 { json::Value j; - json::Value bridge(json::ObjectValue); - json::Value asset(json::ObjectValue); + json::Value bridge(json::ValueType::Object); + json::Value asset(json::ValueType::Object); asset["currency"] = "USD"; asset["issuer"] = "notAValidBase58Account"; - json::Value lockingChainIssue(json::ObjectValue); + json::Value lockingChainIssue(json::ValueType::Object); lockingChainIssue["currency"] = "EUR"; lockingChainIssue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; bridge["LockingChainIssue"] = lockingChainIssue; @@ -1903,7 +1905,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid array value for STNumber { json::Value j; - j[sfNumber] = json::Value(json::ArrayValue); + j[sfNumber] = json::Value(json::ValueType::Array); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1911,7 +1913,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Invalid object value for STNumber { json::Value j; - j[sfNumber] = json::Value(json::ObjectValue); + j[sfNumber] = json::Value(json::ValueType::Object); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1932,7 +1934,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with valid object for Object { json::Value j; - json::Value objVal(json::ObjectValue); + json::Value objVal(json::ValueType::Object); objVal[sfTransactionResult] = 1; j[sfTransactionMetaData] = objVal; STParsedJSONObject obj("Test", j); @@ -1955,7 +1957,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with array value for Object (should fail) { json::Value j; - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr.append(1); j[sfTransactionMetaData] = arr; STParsedJSONObject const obj("Test", j); @@ -1965,7 +1967,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with null value for Object (should fail) { json::Value j; - j[sfTransactionMetaData] = json::Value(json::NullValue); + j[sfTransactionMetaData] = json::Value(json::ValueType::Null); STParsedJSONObject const obj("Test", j); BEAST_EXPECT(!obj.object.has_value()); } @@ -1974,11 +1976,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // max depth is 64 { json::Value j; - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); json::Value* current = &obj; for (int i = 0; i < 63; ++i) { - json::Value const next(json::ObjectValue); + json::Value const next(json::ValueType::Object); (*current)[sfTransactionMetaData] = next; current = &((*current)[sfTransactionMetaData]); } @@ -1993,11 +1995,11 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with depth exceeding maxDepth (should fail) { json::Value j; - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); json::Value* current = &obj; for (int i = 0; i < 64; ++i) { - json::Value const next(json::ObjectValue); + json::Value const next(json::ValueType::Object); (*current)[sfTransactionMetaData] = next; current = &((*current)[sfTransactionMetaData]); } @@ -2015,10 +2017,10 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with valid array for Array { json::Value j; - json::Value arr(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value arr(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem[sfTransactionResult] = 2; - json::Value elem2(json::ObjectValue); + json::Value elem2(json::ValueType::Object); elem2[sfTransactionMetaData] = elem; arr.append(elem2); j[sfSignerEntries] = arr; @@ -2038,7 +2040,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with array containing non-object element (should fail) { json::Value j; - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr.append("notanobject"); j[sfSignerEntries] = arr; STParsedJSONObject const obj("Test", j); @@ -2048,8 +2050,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with array containing object with invalid field (should fail) { json::Value j; - json::Value arr(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value arr(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem["invalidField"] = 1; arr.append(elem); j[sfSignerEntries] = arr; @@ -2060,8 +2062,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with array containing object with multiple keys (should fail) { json::Value j; - json::Value arr(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value arr(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem[sfTransactionResult] = 2; elem[sfNetworkID] = 3; arr.append(elem); @@ -2082,8 +2084,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // (should fail) { json::Value j; - json::Value arr(json::ArrayValue); - json::Value elem(json::ObjectValue); + json::Value arr(json::ValueType::Array); + json::Value elem(json::ValueType::Object); elem[sfTransactionResult] = "notanint"; arr.append(elem); j[sfSignerEntries] = arr; @@ -2094,7 +2096,7 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with empty array for Array (should be valid) { json::Value j; - json::Value const arr(json::ArrayValue); + json::Value const arr(json::ValueType::Array); j[sfSignerEntries] = arr; STParsedJSONObject obj("Test", j); BEAST_EXPECT(obj.object.has_value()); @@ -2105,8 +2107,8 @@ class STParsedJSON_test : public beast::unit_test::Suite // Test with object provided but not object SField { json::Value j; - json::Value obj(json::ArrayValue); - obj.append(json::Value(json::ObjectValue)); + json::Value obj(json::ValueType::Array); + obj.append(json::Value(json::ValueType::Object)); obj[0u][sfTransactionResult] = 1; j[sfSignerEntries] = obj; STParsedJSONObject const parsed("Test", j); @@ -2173,7 +2175,7 @@ class STParsedJSON_test : public beast::unit_test::Suite { std::string const& serialized( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - to_string(parsed.object->getJson(JsonOptions::KNone))); + to_string(parsed.object->getJson(JsonOptions::Values::None))); BEAST_EXPECT(serialized == goodJson); } } @@ -2198,7 +2200,7 @@ class STParsedJSON_test : public beast::unit_test::Suite { std::string const& serialized( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - to_string(parsed.object->getJson(JsonOptions::KNone))); + to_string(parsed.object->getJson(JsonOptions::Values::None))); BEAST_EXPECT(serialized == expectedJson); } } @@ -2223,7 +2225,7 @@ class STParsedJSON_test : public beast::unit_test::Suite { std::string const& serialized( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - to_string(parsed.object->getJson(JsonOptions::KNone))); + to_string(parsed.object->getJson(JsonOptions::Values::None))); BEAST_EXPECT(serialized == expectedJson); } } @@ -2332,7 +2334,7 @@ class STParsedJSON_test : public beast::unit_test::Suite { std::string const& serialized( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - to_string(parsed.object->getJson(JsonOptions::KNone))); + to_string(parsed.object->getJson(JsonOptions::Values::None))); BEAST_EXPECT(serialized == expectedJson); } } diff --git a/src/test/protocol/STTx_test.cpp b/src/test/protocol/STTx_test.cpp index 87cbb56a6b..9edc7e2ff3 100644 --- a/src/test/protocol/STTx_test.cpp +++ b/src/test/protocol/STTx_test.cpp @@ -1352,8 +1352,8 @@ public: if (copy != j) { - log << "j=" << j.getJson(JsonOptions::KNone) << '\n' - << "copy=" << copy.getJson(JsonOptions::KNone) << std::endl; + log << "j=" << j.getJson(JsonOptions::Values::None) << '\n' + << "copy=" << copy.getJson(JsonOptions::Values::None) << std::endl; fail("Transaction fails serialize/deserialize test"); } else @@ -1361,15 +1361,15 @@ public: pass(); } - STParsedJSONObject parsed("test", j.getJson(JsonOptions::KNone)); + STParsedJSONObject parsed("test", j.getJson(JsonOptions::Values::None)); if (!parsed.object.has_value()) { fail("Unable to build object from json"); } else if (STObject(j) != parsed.object) { - log << "ORIG: " << j.getJson(JsonOptions::KNone) << '\n' - << "BUILT " << parsed.object->getJson(JsonOptions::KNone) << std::endl; + log << "ORIG: " << j.getJson(JsonOptions::Values::None) << '\n' + << "BUILT " << parsed.object->getJson(JsonOptions::Values::None) << std::endl; fail("Built a different transaction"); } else diff --git a/src/test/resource/Logic_test.cpp b/src/test/resource/Logic_test.cpp index 1f2dc8f4dc..0710bdcc93 100644 --- a/src/test/resource/Logic_test.cpp +++ b/src/test/resource/Logic_test.cpp @@ -86,7 +86,7 @@ public: TestLogic logic(j); - Charge const fee(DropThreshold + 1); + Charge const fee(kDROP_THRESHOLD + 1); beast::IP::Endpoint const addr(beast::IP::Endpoint::fromString("192.0.2.2")); std::function const ep = limited @@ -278,7 +278,7 @@ public: void run() override { - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("ResourceManager_test", *this); testDrop(journal, true); diff --git a/src/test/rpc/AccountCurrencies_test.cpp b/src/test/rpc/AccountCurrencies_test.cpp index 5e8100f76f..cc7884cc36 100644 --- a/src/test/rpc/AccountCurrencies_test.cpp +++ b/src/test/rpc/AccountCurrencies_test.cpp @@ -62,9 +62,9 @@ class AccountCurrencies_test : public beast::unit_test::Suite testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } { @@ -80,9 +80,9 @@ class AccountCurrencies_test : public beast::unit_test::Suite testInvalidIdentParam(1); testInvalidIdentParam(1.1); testInvalidIdentParam(true); - testInvalidIdentParam(json::Value(json::NullValue)); - testInvalidIdentParam(json::Value(json::ObjectValue)); - testInvalidIdentParam(json::Value(json::ArrayValue)); + testInvalidIdentParam(json::Value(json::ValueType::Null)); + testInvalidIdentParam(json::Value(json::ValueType::Object)); + testInvalidIdentParam(json::Value(json::ValueType::Array)); } { diff --git a/src/test/rpc/AccountInfo_test.cpp b/src/test/rpc/AccountInfo_test.cpp index 2739b84d50..b0cb949231 100644 --- a/src/test/rpc/AccountInfo_test.cpp +++ b/src/test/rpc/AccountInfo_test.cpp @@ -75,9 +75,9 @@ public: testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } { // Cannot pass a non-string into the `ident` param @@ -93,9 +93,9 @@ public: testInvalidIdentParam(1); testInvalidIdentParam(1.1); testInvalidIdentParam(true); - testInvalidIdentParam(json::Value(json::NullValue)); - testInvalidIdentParam(json::Value(json::ObjectValue)); - testInvalidIdentParam(json::Value(json::ArrayValue)); + testInvalidIdentParam(json::Value(json::ValueType::Null)); + testInvalidIdentParam(json::Value(json::ValueType::Object)); + testInvalidIdentParam(json::Value(json::ValueType::Array)); } } diff --git a/src/test/rpc/AccountLines_test.cpp b/src/test/rpc/AccountLines_test.cpp index 750ba9cc78..7bb1ca227f 100644 --- a/src/test/rpc/AccountLines_test.cpp +++ b/src/test/rpc/AccountLines_test.cpp @@ -75,9 +75,9 @@ public: testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } Account const alice{"alice"}; { @@ -215,7 +215,7 @@ public: // Invalid index json::Value params; params[jss::account] = alice.human(); - params[jss::ledger_index] = json::ObjectValue; + params[jss::ledger_index] = json::ValueType::Object; auto const lines = env.rpc("json", "account_lines", to_string(params))[jss::result]; BEAST_EXPECT(lines[jss::error] == "invalidParams"); BEAST_EXPECT( @@ -528,7 +528,7 @@ public: jv[jss::TransactionType] = jss::PaymentChannelCreate; jv[jss::Account] = account.human(); jv[jss::Destination] = to.human(); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); jv["SettleDelay"] = settleDelay.count(); jv["PublicKey"] = strHex(pk.slice()); return jv; @@ -618,7 +618,7 @@ public: // the list will be empty for most calls. auto getNextLine = [](Env& env, Account const& alice, std::optional const marker) { - json::Value params(json::ObjectValue); + json::Value params(json::ValueType::Object); params[jss::account] = alice.human(); params[jss::limit] = 1; if (marker) diff --git a/src/test/rpc/AccountObjects_test.cpp b/src/test/rpc/AccountObjects_test.cpp index 6feec6334b..427627c0ad 100644 --- a/src/test/rpc/AccountObjects_test.cpp +++ b/src/test/rpc/AccountObjects_test.cpp @@ -144,9 +144,9 @@ public: testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } // test error on malformed account string. { @@ -674,7 +674,7 @@ public: jvEscrow[jss::TransactionType] = jss::EscrowCreate; jvEscrow[jss::Account] = gw.human(); jvEscrow[jss::Destination] = gw.human(); - jvEscrow[jss::Amount] = XRP(100).value().getJson(JsonOptions::KNone); + jvEscrow[jss::Amount] = XRP(100).value().getJson(JsonOptions::Values::None); jvEscrow[sfFinishAfter.jsonName] = env.now().time_since_epoch().count() + 1; env(jvEscrow); env.close(); @@ -860,7 +860,7 @@ public: jvPayChan[jss::TransactionType] = jss::PaymentChannelCreate; jvPayChan[jss::Account] = gw.human(); jvPayChan[jss::Destination] = alice.human(); - jvPayChan[jss::Amount] = XRP(300).value().getJson(JsonOptions::KNone); + jvPayChan[jss::Amount] = XRP(300).value().getJson(JsonOptions::Values::None); jvPayChan[sfSettleDelay.jsonName] = 24 * 60 * 60; jvPayChan[sfPublicKey.jsonName] = strHex(gw.pk().slice()); env(jvPayChan); @@ -1180,9 +1180,9 @@ public: testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } } diff --git a/src/test/rpc/AccountOffers_test.cpp b/src/test/rpc/AccountOffers_test.cpp index 8236439a37..7c81bb55e9 100644 --- a/src/test/rpc/AccountOffers_test.cpp +++ b/src/test/rpc/AccountOffers_test.cpp @@ -212,9 +212,9 @@ public: testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } { diff --git a/src/test/rpc/AccountTx_test.cpp b/src/test/rpc/AccountTx_test.cpp index 4de0928555..610a07c275 100644 --- a/src/test/rpc/AccountTx_test.cpp +++ b/src/test/rpc/AccountTx_test.cpp @@ -374,9 +374,9 @@ class AccountTx_test : public beast::unit_test::Suite testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } // test binary and forward for bool/non bool values { @@ -449,13 +449,13 @@ class AccountTx_test : public beast::unit_test::Suite RPC::expectedFieldMessage(jss::limit, "unsigned integer")); // Test case: limit = [] should fail (array instead of integer) - p[jss::limit] = json::Value(json::ArrayValue); + p[jss::limit] = json::Value(json::ValueType::Array); BEAST_EXPECT( env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] == RPC::expectedFieldMessage(jss::limit, "unsigned integer")); // Test case: limit = {} should fail (object instead of integer) - p[jss::limit] = json::Value(json::ObjectValue); + p[jss::limit] = json::Value(json::ValueType::Object); BEAST_EXPECT( env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] == RPC::expectedFieldMessage(jss::limit, "unsigned integer")); @@ -467,7 +467,7 @@ class AccountTx_test : public beast::unit_test::Suite RPC::expectedFieldMessage(jss::limit, "unsigned integer")); // Test case: limit = ["limit"] should fail (array with string) - p[jss::limit] = json::Value(json::ArrayValue); + p[jss::limit] = json::Value(json::ValueType::Array); p[jss::limit].append("limit"); BEAST_EXPECT( env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] == @@ -475,7 +475,7 @@ class AccountTx_test : public beast::unit_test::Suite // Test case: limit = {"limit": 10} should fail (object with // property) - p[jss::limit] = json::Value(json::ObjectValue); + p[jss::limit] = json::Value(json::ValueType::Object); p[jss::limit][jss::limit] = 10; BEAST_EXPECT( env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] == @@ -537,7 +537,7 @@ class AccountTx_test : public beast::unit_test::Suite escrow[jss::TransactionType] = jss::EscrowCreate; escrow[jss::Account] = account.human(); escrow[jss::Destination] = to.human(); - escrow[jss::Amount] = amount.getJson(JsonOptions::KNone); + escrow[jss::Amount] = amount.getJson(JsonOptions::Values::None); return escrow; }; @@ -583,7 +583,7 @@ class AccountTx_test : public beast::unit_test::Suite payChanCreate[jss::TransactionType] = jss::PaymentChannelCreate; payChanCreate[jss::Account] = alice.human(); payChanCreate[jss::Destination] = gw.human(); - payChanCreate[jss::Amount] = XRP(500).value().getJson(JsonOptions::KNone); + payChanCreate[jss::Amount] = XRP(500).value().getJson(JsonOptions::Values::None); payChanCreate[sfSettleDelay.jsonName] = NetClock::duration{100s}.count(); payChanCreate[sfPublicKey.jsonName] = strHex(alice.pk().slice()); env(payChanCreate, Sig(alie)); @@ -596,7 +596,7 @@ class AccountTx_test : public beast::unit_test::Suite payChanFund[jss::TransactionType] = jss::PaymentChannelFund; payChanFund[jss::Account] = alice.human(); payChanFund[sfChannel.jsonName] = payChanIndex; - payChanFund[jss::Amount] = XRP(200).value().getJson(JsonOptions::KNone); + payChanFund[jss::Amount] = XRP(200).value().getJson(JsonOptions::Values::None); env(payChanFund, Sig(alie)); env.close(); } @@ -774,7 +774,7 @@ class AccountTx_test : public beast::unit_test::Suite // All it takes is a large enough XRP payment to resurrect // becky's account. Try too small a payment. - env(pay(alice, becky, drops(env.current()->fees().accountReserve(0)) - XRP(1)), + env(pay(alice, becky, drops(env.current()->fees().accountReserve(0)) - drops(1)), Ter(tecNO_DST_INSUF_XRP)); env.close(); @@ -841,7 +841,8 @@ class AccountTx_test : public beast::unit_test::Suite auto const& tx0(jv[jss::transactions][0u][jss::tx]); BEAST_EXPECT(tx0[jss::TransactionType] == txType); - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; BEAST_EXPECT(tx0[jss::hash] == txHash); }; diff --git a/src/test/rpc/AmendmentBlocked_test.cpp b/src/test/rpc/AmendmentBlocked_test.cpp index 4e0daaef0d..ae4fb99542 100644 --- a/src/test/rpc/AmendmentBlocked_test.cpp +++ b/src/test/rpc/AmendmentBlocked_test.cpp @@ -75,7 +75,7 @@ class AmendmentBlocked_test : public beast::unit_test::Suite pfReq[jss::subcommand] = "create"; pfReq[jss::source_account] = alice.human(); pfReq[jss::destination_account] = bob.human(); - pfReq[jss::destination_amount] = bob["USD"](20).value().getJson(JsonOptions::KNone); + pfReq[jss::destination_amount] = bob["USD"](20).value().getJson(JsonOptions::Values::None); jr = wsc->invoke("path_find", pfReq)[jss::result]; BEAST_EXPECT( jr.isMember(jss::alternatives) && jr[jss::alternatives].isArray() && @@ -140,7 +140,7 @@ class AmendmentBlocked_test : public beast::unit_test::Suite pfReq[jss::subcommand] = "create"; pfReq[jss::source_account] = alice.human(); pfReq[jss::destination_account] = bob.human(); - pfReq[jss::destination_amount] = bob["USD"](20).value().getJson(JsonOptions::KNone); + pfReq[jss::destination_amount] = bob["USD"](20).value().getJson(JsonOptions::Values::None); jr = wsc->invoke("path_find", pfReq)[jss::result]; BEAST_EXPECT( jr.isMember(jss::alternatives) && jr[jss::alternatives].isArray() && diff --git a/src/test/rpc/BookChanges_test.cpp b/src/test/rpc/BookChanges_test.cpp index 182b569fde..98a9372982 100644 --- a/src/test/rpc/BookChanges_test.cpp +++ b/src/test/rpc/BookChanges_test.cpp @@ -99,7 +99,8 @@ public: env(pay(bob, carol, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID)); env.close(); - std::string const txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string const txHash{ + env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; json::Value const txResult = env.rpc("tx", txHash)[jss::result]; auto const ledgerIndex = txResult[jss::ledger_index].asInt(); diff --git a/src/test/rpc/Book_test.cpp b/src/test/rpc/Book_test.cpp index d7de678933..453a1800c1 100644 --- a/src/test/rpc/Book_test.cpp +++ b/src/test/rpc/Book_test.cpp @@ -76,9 +76,9 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_gets][jss::currency] = "XRP"; j[jss::taker_pays][jss::currency] = "USD"; @@ -109,8 +109,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -153,9 +153,9 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_gets][jss::currency] = "XRP"; j[jss::taker_pays][jss::currency] = "USD"; @@ -175,10 +175,10 @@ public: jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 1); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerGets] == - XRP(200).value().getJson(JsonOptions::KNone)); + XRP(200).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerPays] == - usd(100).value().getJson(JsonOptions::KNone)); + usd(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(!jv[jss::result].isMember(jss::asks)); BEAST_EXPECT(!jv[jss::result].isMember(jss::bids)); } @@ -192,8 +192,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -229,9 +229,9 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::both] = true; j[jss::taker_gets][jss::currency] = "XRP"; @@ -264,8 +264,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -278,8 +278,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None); })); } @@ -315,9 +315,9 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::both] = true; j[jss::taker_gets][jss::currency] = "XRP"; @@ -340,16 +340,16 @@ public: jv[jss::result].isMember(jss::bids) && jv[jss::result][jss::bids].size() == 1); BEAST_EXPECT( jv[jss::result][jss::asks][0u][jss::TakerGets] == - usd(100).value().getJson(JsonOptions::KNone)); + usd(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::asks][0u][jss::TakerPays] == - XRP(500).value().getJson(JsonOptions::KNone)); + XRP(500).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::bids][0u][jss::TakerGets] == - XRP(200).value().getJson(JsonOptions::KNone)); + XRP(200).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::bids][0u][jss::TakerPays] == - usd(100).value().getJson(JsonOptions::KNone)); + usd(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(!jv[jss::result].isMember(jss::offers)); } @@ -362,8 +362,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -376,8 +376,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None); })); } @@ -408,16 +408,16 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_gets][jss::currency] = "XRP"; j[jss::taker_pays][jss::currency] = "USD"; j[jss::taker_pays][jss::issuer] = Account("alice").human(); } { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_gets][jss::currency] = "CNY"; j[jss::taker_gets][jss::issuer] = Account("alice").human(); @@ -449,8 +449,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -470,8 +470,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None); })); } @@ -522,16 +522,16 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_gets][jss::currency] = "XRP"; j[jss::taker_pays][jss::currency] = "USD"; j[jss::taker_pays][jss::issuer] = Account("alice").human(); } { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_gets][jss::currency] = "CNY"; j[jss::taker_gets][jss::issuer] = Account("alice").human(); @@ -552,16 +552,16 @@ public: jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 2); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerGets] == - XRP(200).value().getJson(JsonOptions::KNone)); + XRP(200).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerPays] == - usd(100).value().getJson(JsonOptions::KNone)); + usd(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][1u][jss::TakerGets] == - cny(200).value().getJson(JsonOptions::KNone)); + cny(200).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][1u][jss::TakerPays] == - jpy(100).value().getJson(JsonOptions::KNone)); + jpy(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(!jv[jss::result].isMember(jss::asks)); BEAST_EXPECT(!jv[jss::result].isMember(jss::bids)); } @@ -575,8 +575,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -596,8 +596,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None); })); } @@ -635,9 +635,9 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::both] = true; j[jss::taker_gets][jss::currency] = "XRP"; @@ -645,7 +645,7 @@ public: j[jss::taker_pays][jss::issuer] = Account("alice").human(); } { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::both] = true; j[jss::taker_gets][jss::currency] = "CNY"; @@ -679,8 +679,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -693,8 +693,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None); })); } @@ -707,8 +707,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None); })); } @@ -721,8 +721,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == cny(75).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == jpy(100).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == cny(75).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == jpy(100).value().getJson(JsonOptions::Values::None); })); } @@ -766,9 +766,9 @@ public: { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::both] = true; j[jss::taker_gets][jss::currency] = "XRP"; @@ -777,7 +777,7 @@ public: } // RPC subscribe to books stream { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::both] = true; j[jss::taker_gets][jss::currency] = "CNY"; @@ -801,28 +801,28 @@ public: jv[jss::result].isMember(jss::bids) && jv[jss::result][jss::bids].size() == 2); BEAST_EXPECT( jv[jss::result][jss::asks][0u][jss::TakerGets] == - usd(100).value().getJson(JsonOptions::KNone)); + usd(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::asks][0u][jss::TakerPays] == - XRP(500).value().getJson(JsonOptions::KNone)); + XRP(500).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::asks][1u][jss::TakerGets] == - jpy(100).value().getJson(JsonOptions::KNone)); + jpy(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::asks][1u][jss::TakerPays] == - cny(500).value().getJson(JsonOptions::KNone)); + cny(500).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::bids][0u][jss::TakerGets] == - XRP(200).value().getJson(JsonOptions::KNone)); + XRP(200).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::bids][0u][jss::TakerPays] == - usd(100).value().getJson(JsonOptions::KNone)); + usd(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::bids][1u][jss::TakerGets] == - cny(200).value().getJson(JsonOptions::KNone)); + cny(200).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::bids][1u][jss::TakerPays] == - jpy(100).value().getJson(JsonOptions::KNone)); + jpy(100).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(!jv[jss::result].isMember(jss::offers)); } @@ -835,8 +835,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None); })); } @@ -849,8 +849,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None); })); } @@ -863,8 +863,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None); })); } @@ -877,8 +877,8 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) { auto const& t = jv[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == cny(75).value().getJson(JsonOptions::KNone) && - t[jss::TakerPays] == jpy(100).value().getJson(JsonOptions::KNone); + t[jss::TakerGets] == cny(75).value().getJson(JsonOptions::Values::None) && + t[jss::TakerPays] == jpy(100).value().getJson(JsonOptions::Values::None); })); } @@ -909,9 +909,9 @@ public: json::Value books; { - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_gets][jss::currency] = "XRP"; j[jss::taker_pays][jss::currency] = "USD"; @@ -968,8 +968,9 @@ public: BEAST_EXPECT(jrOffer[sfLedgerEntryType.fieldName] == jss::Offer); BEAST_EXPECT(jrOffer[sfOwnerNode.fieldName] == "0"); BEAST_EXPECT(jrOffer[sfSequence.fieldName] == 5); - BEAST_EXPECT(jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::KNone)); - BEAST_EXPECT(jrOffer[jss::TakerPays] == XRP(4000).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT(jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None)); + BEAST_EXPECT( + jrOffer[jss::TakerPays] == XRP(4000).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jrOffer[jss::owner_funds] == "100"); BEAST_EXPECT(jrOffer[jss::quality] == "400000000"); @@ -977,9 +978,9 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jval) { auto const& t = jval[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(10).value().getJson(JsonOptions::KNone) && + t[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None) && t[jss::owner_funds] == "100" && - t[jss::TakerPays] == XRP(4000).value().getJson(JsonOptions::KNone); + t[jss::TakerPays] == XRP(4000).value().getJson(JsonOptions::Values::None); })); env(offer(bob, XRP(2000), usd(5))); @@ -988,9 +989,9 @@ public: BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jval) { auto const& t = jval[jss::transaction]; return t[jss::TransactionType] == jss::OfferCreate && - t[jss::TakerGets] == usd(5).value().getJson(JsonOptions::KNone) && + t[jss::TakerGets] == usd(5).value().getJson(JsonOptions::Values::None) && t[jss::owner_funds] == "50" && - t[jss::TakerPays] == XRP(2000).value().getJson(JsonOptions::KNone); + t[jss::TakerPays] == XRP(2000).value().getJson(JsonOptions::Values::None); })); jv = wsc->invoke("book_offers", jvParams); @@ -1012,8 +1013,10 @@ public: BEAST_EXPECT(jrNextOffer[sfLedgerEntryType.fieldName] == jss::Offer); BEAST_EXPECT(jrNextOffer[sfOwnerNode.fieldName] == "0"); BEAST_EXPECT(jrNextOffer[sfSequence.fieldName] == 5); - BEAST_EXPECT(jrNextOffer[jss::TakerGets] == usd(5).value().getJson(JsonOptions::KNone)); - BEAST_EXPECT(jrNextOffer[jss::TakerPays] == XRP(2000).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jrNextOffer[jss::TakerGets] == usd(5).value().getJson(JsonOptions::Values::None)); + BEAST_EXPECT( + jrNextOffer[jss::TakerPays] == XRP(2000).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jrNextOffer[jss::owner_funds] == "50"); BEAST_EXPECT(jrNextOffer[jss::quality] == "400000000"); @@ -1044,8 +1047,8 @@ public: return false; auto const& t = (*maybeJv)[jss::transaction]; if (t[jss::TransactionType] != jss::OfferCreate || - t[jss::TakerGets] != takerGets.value().getJson(JsonOptions::KNone) || - t[jss::TakerPays] != takerPays.value().getJson(JsonOptions::KNone)) + t[jss::TakerGets] != takerGets.value().getJson(JsonOptions::Values::None) || + t[jss::TakerPays] != takerPays.value().getJson(JsonOptions::Values::None)) return false; // Make sure no other message is waiting return wsc->getMsg(timeout) == std::nullopt; @@ -1093,9 +1096,9 @@ public: json::Value books; { // RPC subscribe to books stream - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = false; j[jss::taker_gets][jss::currency] = "XRP"; j[jss::taker_pays][jss::currency] = "USD"; @@ -1169,9 +1172,9 @@ public: { // RPC subscribe to multiple book streams - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = false; j[jss::taker_gets][jss::currency] = "XRP"; j[jss::taker_pays][jss::currency] = "USD"; @@ -1179,7 +1182,7 @@ public: } { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = false; j[jss::taker_gets][jss::currency] = "EUR"; j[jss::taker_gets][jss::issuer] = gw.human(); @@ -1233,7 +1236,7 @@ public: { json::Value jvParams; jvParams[jss::ledger_index] = "validated"; - jvParams[jss::taker_pays] = json::ObjectValue; + jvParams[jss::taker_pays] = json::ValueType::Object; auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::error] == "invalidParams"); BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_gets'."); @@ -1243,7 +1246,7 @@ public: json::Value jvParams; jvParams[jss::ledger_index] = "validated"; jvParams[jss::taker_pays] = "not an object"; - jvParams[jss::taker_gets] = json::ObjectValue; + jvParams[jss::taker_gets] = json::ValueType::Object; auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::error] == "invalidParams"); BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker_pays', not object."); @@ -1252,7 +1255,7 @@ public: { json::Value jvParams; jvParams[jss::ledger_index] = "validated"; - jvParams[jss::taker_pays] = json::ObjectValue; + jvParams[jss::taker_pays] = json::ValueType::Object; jvParams[jss::taker_gets] = "not an object"; auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::error] == "invalidParams"); @@ -1262,8 +1265,8 @@ public: { json::Value jvParams; jvParams[jss::ledger_index] = "validated"; - jvParams[jss::taker_pays] = json::ObjectValue; - jvParams[jss::taker_gets] = json::ObjectValue; + jvParams[jss::taker_pays] = json::ValueType::Object; + jvParams[jss::taker_gets] = json::ValueType::Object; auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::error] == "invalidParams"); BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_pays.currency'."); @@ -1273,7 +1276,7 @@ public: json::Value jvParams; jvParams[jss::ledger_index] = "validated"; jvParams[jss::taker_pays][jss::currency] = 1; - jvParams[jss::taker_gets] = json::ObjectValue; + jvParams[jss::taker_gets] = json::ValueType::Object; auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::error] == "invalidParams"); BEAST_EXPECT( @@ -1284,7 +1287,7 @@ public: json::Value jvParams; jvParams[jss::ledger_index] = "validated"; jvParams[jss::taker_pays][jss::currency] = "XRP"; - jvParams[jss::taker_gets] = json::ObjectValue; + jvParams[jss::taker_gets] = json::ValueType::Object; auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::error] == "invalidParams"); BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_gets.currency'."); @@ -1568,7 +1571,7 @@ public: BEAST_EXPECT( jrr[jss::offers].size() == (asAdmin ? RPC::Tuning::kBOOK_OFFERS.rmax + 1 : 0u)); - jvParams[jss::limit] = json::NullValue; + jvParams[jss::limit] = json::ValueType::Null; jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::offers].isArray()); BEAST_EXPECT( @@ -1610,8 +1613,10 @@ public: BEAST_EXPECT(jrOffer[jss::Flags] == 0); BEAST_EXPECT(jrOffer[sfLedgerEntryType.fieldName] == jss::Offer); BEAST_EXPECT(jrOffer[sfOwnerNode.fieldName] == "0"); - BEAST_EXPECT(jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::KNone)); - BEAST_EXPECT(jrOffer[jss::TakerPays] == XRP(10).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None)); + BEAST_EXPECT( + jrOffer[jss::TakerPays] == XRP(10).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jrOffer[sfDomainID.jsonName].asString() == to_string(domainID)); }; @@ -1635,10 +1640,10 @@ public: jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 1); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerGets] == - usd(10).value().getJson(JsonOptions::KNone)); + usd(10).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerPays] == - XRP(10).value().getJson(JsonOptions::KNone)); + XRP(10).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][0u][sfDomainID.jsonName].asString() == to_string(domainID)); @@ -1662,9 +1667,9 @@ public: // subscribe to domain book should return domain offer { json::Value books; - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_pays][jss::currency] = "XRP"; j[jss::taker_gets][jss::currency] = "USD"; @@ -1681,9 +1686,9 @@ public: // subscribe to open book should not return domain offer { json::Value books; - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_pays][jss::currency] = "XRP"; j[jss::taker_gets][jss::currency] = "USD"; @@ -1733,8 +1738,10 @@ public: BEAST_EXPECT(jrOffer[jss::Flags] == lsfHybrid); BEAST_EXPECT(jrOffer[sfLedgerEntryType.fieldName] == jss::Offer); BEAST_EXPECT(jrOffer[sfOwnerNode.fieldName] == "0"); - BEAST_EXPECT(jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::KNone)); - BEAST_EXPECT(jrOffer[jss::TakerPays] == XRP(10).value().getJson(JsonOptions::KNone)); + BEAST_EXPECT( + jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None)); + BEAST_EXPECT( + jrOffer[jss::TakerPays] == XRP(10).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT(jrOffer[sfDomainID.jsonName].asString() == to_string(domainID)); BEAST_EXPECT(jrOffer[sfAdditionalBooks.jsonName].size() == 1); }; @@ -1758,10 +1765,10 @@ public: jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 1); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerGets] == - usd(10).value().getJson(JsonOptions::KNone)); + usd(10).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][0u][jss::TakerPays] == - XRP(10).value().getJson(JsonOptions::KNone)); + XRP(10).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( jv[jss::result][jss::offers][0u][sfDomainID.jsonName].asString() == to_string(domainID)); @@ -1785,9 +1792,9 @@ public: // subscribe to domain book should return hybrid offer { json::Value books; - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_pays][jss::currency] = "XRP"; j[jss::taker_gets][jss::currency] = "USD"; @@ -1809,9 +1816,9 @@ public: // subscribe to open book should return hybrid offer { json::Value books; - books[jss::books] = json::ArrayValue; + books[jss::books] = json::ValueType::Array; { - auto& j = books[jss::books].append(json::ObjectValue); + auto& j = books[jss::books].append(json::ValueType::Object); j[jss::snapshot] = true; j[jss::taker_pays][jss::currency] = "XRP"; j[jss::taker_gets][jss::currency] = "USD"; diff --git a/src/test/rpc/DeliveredAmount_test.cpp b/src/test/rpc/DeliveredAmount_test.cpp index 213b4afd01..0e171a8c84 100644 --- a/src/test/rpc/DeliveredAmount_test.cpp +++ b/src/test/rpc/DeliveredAmount_test.cpp @@ -245,9 +245,9 @@ class DeliveredAmount_test : public beast::unit_test::Suite { json::Value stream; // RPC subscribe to ledger stream - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("ledger"); - stream[jss::accounts] = json::ArrayValue; + stream[jss::accounts] = json::ValueType::Array; stream[jss::accounts].append(toBase58(alice.id())); stream[jss::accounts].append(toBase58(bob.id())); stream[jss::accounts].append(toBase58(carol.id())); @@ -368,15 +368,17 @@ class DeliveredAmount_test : public beast::unit_test::Suite env.close(); // Get the hash for the most recent transaction. - std::string txHash{env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString()}; + std::string txHash{env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()}; json::Value meta = env.rpc("tx", txHash)[jss::result][jss::meta]; if (features[fixMPTDeliveredAmount]) { BEAST_EXPECT( - meta[sfDeliveredAmount.jsonName] == STAmount{mpt(800)}.getJson(JsonOptions::KNone)); + meta[sfDeliveredAmount.jsonName] == + STAmount{mpt(800)}.getJson(JsonOptions::Values::None)); BEAST_EXPECT( - meta[jss::delivered_amount] == STAmount{mpt(800)}.getJson(JsonOptions::KNone)); + meta[jss::delivered_amount] == + STAmount{mpt(800)}.getJson(JsonOptions::Values::None)); } else { @@ -387,15 +389,17 @@ class DeliveredAmount_test : public beast::unit_test::Suite env(pay(bob, carol, mpt(1000)), Sendmax(mpt(1200)), Txflags(tfPartialPayment)); env.close(); - txHash = env.tx()->getJson(JsonOptions::KNone)[jss::hash].asString(); + txHash = env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString(); meta = env.rpc("tx", txHash)[jss::result][jss::meta]; if (features[fixMPTDeliveredAmount]) { BEAST_EXPECT( - meta[sfDeliveredAmount.jsonName] == STAmount{mpt(960)}.getJson(JsonOptions::KNone)); + meta[sfDeliveredAmount.jsonName] == + STAmount{mpt(960)}.getJson(JsonOptions::Values::None)); BEAST_EXPECT( - meta[jss::delivered_amount] == STAmount{mpt(960)}.getJson(JsonOptions::KNone)); + meta[jss::delivered_amount] == + STAmount{mpt(960)}.getJson(JsonOptions::Values::None)); } else { diff --git a/src/test/rpc/DepositAuthorized_test.cpp b/src/test/rpc/DepositAuthorized_test.cpp index 542f1c2c85..9fff429fa1 100644 --- a/src/test/rpc/DepositAuthorized_test.cpp +++ b/src/test/rpc/DepositAuthorized_test.cpp @@ -32,7 +32,7 @@ public: std::string const& ledger = "", std::vector const& credentials = {}) { - json::Value args{json::ObjectValue}; + json::Value args{json::ValueType::Object}; args[jss::source_account] = source.human(); args[jss::destination_account] = dest.human(); if (!ledger.empty()) @@ -40,7 +40,7 @@ public: if (!credentials.empty()) { - auto& arr(args[jss::credentials] = json::ArrayValue); + auto& arr(args[jss::credentials] = json::ValueType::Array); for (auto const& s : credentials) arr.append(s); } @@ -331,7 +331,7 @@ public: testcase("deposit_authorized with credentials failure: empty array."); auto args = depositAuthArgs(alice, becky, "validated"); - args[jss::credentials] = json::ArrayValue; + args[jss::credentials] = json::ValueType::Array; auto const jv = env.rpc("json", "deposit_authorized", args.toStyledString()); checkCredentialsResponse(jv[jss::result], alice, becky, false, {}, "invalidParams"); @@ -343,7 +343,7 @@ public: "credentials"); auto args = depositAuthArgs(alice, becky, "validated"); - args[jss::credentials] = json::ArrayValue; + args[jss::credentials] = json::ValueType::Array; args[jss::credentials].append(1); args[jss::credentials].append(3); @@ -357,7 +357,7 @@ public: "credentials"); auto args = depositAuthArgs(alice, becky, "validated"); - args[jss::credentials] = json::ArrayValue; + args[jss::credentials] = json::ValueType::Array; args[jss::credentials].append("hello world"); auto const jv = env.rpc("json", "deposit_authorized", args.toStyledString()); diff --git a/src/test/rpc/Feature_test.cpp b/src/test/rpc/Feature_test.cpp index 3eedc5fa14..befb5aeddb 100644 --- a/src/test/rpc/Feature_test.cpp +++ b/src/test/rpc/Feature_test.cpp @@ -258,9 +258,9 @@ class Feature_test : public beast::unit_test::Suite testInvalidParam(1); testInvalidParam(1.1); testInvalidParam(true); - testInvalidParam(json::Value(json::NullValue)); - testInvalidParam(json::Value(json::ObjectValue)); - testInvalidParam(json::Value(json::ArrayValue)); + testInvalidParam(json::Value(json::ValueType::Null)); + testInvalidParam(json::Value(json::ValueType::Object)); + testInvalidParam(json::Value(json::ValueType::Array)); { auto jrr = env.rpc("feature", "AllTheThings")[jss::result]; diff --git a/src/test/rpc/JSONRPC_test.cpp b/src/test/rpc/JSONRPC_test.cpp index 6c45815555..3b4d482a6a 100644 --- a/src/test/rpc/JSONRPC_test.cpp +++ b/src/test/rpc/JSONRPC_test.cpp @@ -2602,7 +2602,7 @@ public: result[jss::tx_json].isMember(jss::Fee) && result[jss::tx_json][jss::Fee] == "10"); BEAST_EXPECT( result[jss::tx_json].isMember(jss::Sequence) && - result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UintValue)); + result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UInt)); } { @@ -2629,7 +2629,7 @@ public: result[jss::tx_json][jss::Fee] == "7813"); BEAST_EXPECT( result[jss::tx_json].isMember(jss::Sequence) && - result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UintValue)); + result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UInt)); env.close(); } @@ -2655,7 +2655,7 @@ public: result[jss::tx_json].isMember(jss::Fee) && result[jss::tx_json][jss::Fee] == "47"); BEAST_EXPECT( result[jss::tx_json].isMember(jss::Sequence) && - result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UintValue)); + result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UInt)); } { @@ -2687,7 +2687,7 @@ public: result[jss::tx_json][jss::Fee] == "6806"); BEAST_EXPECT( result[jss::tx_json].isMember(jss::Sequence) && - result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UintValue)); + result[jss::tx_json][jss::Sequence].isConvertibleTo(json::ValueType::UInt)); } } diff --git a/src/test/rpc/KeyGeneration_test.cpp b/src/test/rpc/KeyGeneration_test.cpp index 0195657d7f..d4807176dd 100644 --- a/src/test/rpc/KeyGeneration_test.cpp +++ b/src/test/rpc/KeyGeneration_test.cpp @@ -230,7 +230,7 @@ public: { json::Value params; params[jss::key_type] = "secp256k1"; - params[jss::seed] = json::ObjectValue; + params[jss::seed] = json::ValueType::Object; auto result = walletPropose(params); BEAST_EXPECT(containsError(result)); BEAST_EXPECT(result[jss::error_message] == "Invalid field 'seed', not string."); @@ -239,7 +239,7 @@ public: { json::Value params; params[jss::key_type] = "ed25519"; - params[jss::seed_hex] = json::ArrayValue; + params[jss::seed_hex] = json::ValueType::Array; auto result = walletPropose(params); BEAST_EXPECT(containsError(result)); BEAST_EXPECT(result[jss::error_message] == "Invalid field 'seed_hex', not string."); @@ -272,7 +272,7 @@ public: { json::Value params; - params[jss::key_type] = json::ObjectValue; + params[jss::key_type] = json::ValueType::Object; params[jss::seed_hex] = common::gMasterSeedHex; auto result = walletPropose(params); BEAST_EXPECT(containsError(result)); @@ -281,7 +281,7 @@ public: { json::Value params; - params[jss::key_type] = json::ArrayValue; + params[jss::key_type] = json::ValueType::Array; params[jss::seed] = common::gMasterSeed; auto result = walletPropose(params); BEAST_EXPECT(containsError(result)); @@ -410,7 +410,7 @@ public: { json::Value params; json::Value error; - params[jss::secret] = json::ArrayValue; + params[jss::secret] = json::ValueType::Array; params[jss::secret].append("array:0"); auto ret = keypairForSignature(params, error); @@ -422,7 +422,7 @@ public: { json::Value params; json::Value error; - params[jss::secret] = json::ObjectValue; + params[jss::secret] = json::ValueType::Object; params[jss::secret]["string"] = "string"; params[jss::secret]["number"] = 702; @@ -463,7 +463,7 @@ public: { json::Value params; json::Value error; - params[jss::key_type] = json::ObjectValue; + params[jss::key_type] = json::ValueType::Object; params[jss::seed_hex] = common::gMasterSeedHex; auto ret = keypairForSignature(params, error); @@ -475,7 +475,7 @@ public: { json::Value params; json::Value error; - params[jss::key_type] = json::ArrayValue; + params[jss::key_type] = json::ValueType::Array; params[jss::seed] = common::gMasterSeed; auto ret = keypairForSignature(params, error); @@ -501,7 +501,7 @@ public: json::Value params; json::Value error; params[jss::key_type] = "secp256k1"; - params[jss::passphrase] = json::ObjectValue; + params[jss::passphrase] = json::ValueType::Object; auto ret = keypairForSignature(params, error); BEAST_EXPECT(containsError(error)); @@ -513,7 +513,7 @@ public: json::Value params; json::Value error; params[jss::key_type] = "secp256k1"; - params[jss::passphrase] = json::ArrayValue; + params[jss::passphrase] = json::ValueType::Array; auto ret = keypairForSignature(params, error); BEAST_EXPECT(containsError(error)); @@ -550,7 +550,7 @@ public: json::Value params; json::Value error; params[jss::key_type] = "secp256k1"; - params[jss::seed] = json::ObjectValue; + params[jss::seed] = json::ValueType::Object; auto ret = keypairForSignature(params, error); BEAST_EXPECT(containsError(error)); @@ -562,7 +562,7 @@ public: json::Value params; json::Value error; params[jss::key_type] = "secp256k1"; - params[jss::seed] = json::ArrayValue; + params[jss::seed] = json::ValueType::Array; auto ret = keypairForSignature(params, error); BEAST_EXPECT(containsError(error)); @@ -623,7 +623,7 @@ public: json::Value params; json::Value error; params[jss::key_type] = "secp256k1"; - params[jss::seed_hex] = json::ObjectValue; + params[jss::seed_hex] = json::ValueType::Object; auto ret = keypairForSignature(params, error); BEAST_EXPECT(containsError(error)); @@ -635,7 +635,7 @@ public: json::Value params; json::Value error; params[jss::key_type] = "secp256k1"; - params[jss::seed_hex] = json::ArrayValue; + params[jss::seed_hex] = json::ValueType::Array; auto ret = keypairForSignature(params, error); BEAST_EXPECT(containsError(error)); diff --git a/src/test/rpc/LedgerData_test.cpp b/src/test/rpc/LedgerData_test.cpp index f11b807529..94e6897036 100644 --- a/src/test/rpc/LedgerData_test.cpp +++ b/src/test/rpc/LedgerData_test.cpp @@ -333,7 +333,7 @@ public: jv[jss::TransactionType] = jss::EscrowCreate; jv[jss::Account] = Account{"bob5"}.human(); jv[jss::Destination] = Account{"bob6"}.human(); - jv[jss::Amount] = XRP(50).value().getJson(JsonOptions::KNone); + jv[jss::Amount] = XRP(50).value().getJson(JsonOptions::Values::None); jv[sfFinishAfter.fieldName] = NetClock::time_point{env.now() + 10s}.time_since_epoch().count(); env(jv); @@ -344,7 +344,7 @@ public: jv[jss::TransactionType] = jss::PaymentChannelCreate; jv[jss::Account] = Account{"bob6"}.human(); jv[jss::Destination] = Account{"bob7"}.human(); - jv[jss::Amount] = XRP(100).value().getJson(JsonOptions::KNone); + jv[jss::Amount] = XRP(100).value().getJson(JsonOptions::Values::None); jv[jss::SettleDelay] = NetClock::duration{10s}.count(); jv[sfPublicKey.fieldName] = strHex(Account{"bob6"}.pk().slice()); jv[sfCancelAfter.fieldName] = diff --git a/src/test/rpc/LedgerEntry_test.cpp b/src/test/rpc/LedgerEntry_test.cpp index 298d0e5149..8fcdf2d064 100644 --- a/src/test/rpc/LedgerEntry_test.cpp +++ b/src/test/rpc/LedgerEntry_test.cpp @@ -163,7 +163,7 @@ class LedgerEntry_test : public beast::unit_test::Suite if (msg.empty()) { BEAST_EXPECTS( - jv[jss::error_message] == json::NullValue || jv[jss::error_message] == "", + jv[jss::error_message] == json::ValueType::Null || jv[jss::error_message] == "", "Expected no error message, received \"" + jv[jss::error_message].asString() + "\", at line " + std::to_string(location.line()) + ", " + jv.toStyledString()); } @@ -181,13 +181,13 @@ class LedgerEntry_test : public beast::unit_test::Suite getBadValues(FieldType fieldType) { static json::Value const kINJECT_OBJECT = []() { - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); obj[jss::account] = "rhigTLJJyXXSRUyRCQtqi1NoAZZzZnS4KU"; obj[jss::ledger_index] = "validated"; return obj; }(); static json::Value const kINJECT_ARRAY = []() { - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr[0u] = "rhigTLJJyXXSRUyRCQtqi1NoAZZzZnS4KU"; arr[1u] = "validated"; return arr; @@ -210,11 +210,11 @@ class LedgerEntry_test : public beast::unit_test::Suite "USD", // 14 "USDollars", // 15 "5233D68B4D44388F98559DE42903767803EFA7C1F8D01413FC16EE6B01403D" - "6D", // 16 - json::ArrayValue, // 17 - json::ObjectValue, // 18 - kINJECT_OBJECT, // 19 - kINJECT_ARRAY // 20 + "6D", // 16 + json::ValueType::Array, // 17 + json::ValueType::Object, // 18 + kINJECT_OBJECT, // 19 + kINJECT_ARRAY // 20 }; auto remove = [&](std::vector indices) -> std::vector { @@ -275,13 +275,13 @@ class LedgerEntry_test : public beast::unit_test::Suite getCorrectValue(json::StaticString fieldName) { static json::Value const kTWO_ACCOUNT_ARRAY = []() { - json::Value arr(json::ArrayValue); + json::Value arr(json::ValueType::Array); arr[0u] = "rhigTLJJyXXSRUyRCQtqi1NoAZZzZnS4KU"; arr[1u] = "r4MrUGTdB57duTnRs6KbsRGQXgkseGb1b5"; return arr; }(); static json::Value const kISSUE_OBJECT = []() { - json::Value arr(json::ObjectValue); + json::Value arr(json::ValueType::Object); arr[jss::currency] = "XRP"; return arr; }(); @@ -292,7 +292,7 @@ class LedgerEntry_test : public beast::unit_test::Suite case FieldType::AccountField: return "r4MrUGTdB57duTnRs6KbsRGQXgkseGb1b5"; case FieldType::ArrayField: - return json::ArrayValue; + return json::ValueType::Array; case FieldType::BlobField: return "ABCDEF"; case FieldType::CurrencyField: @@ -359,7 +359,7 @@ class LedgerEntry_test : public beast::unit_test::Suite } if (required) { - tryField(json::NullValue); + tryField(json::ValueType::Null); } }); } @@ -384,7 +384,7 @@ class LedgerEntry_test : public beast::unit_test::Suite checkErrorValue( jrr, "malformedRequest", RPC::missingFieldMessage(fieldName.cStr()), location); - correctRequest[parentFieldName][fieldName] = json::NullValue; + correctRequest[parentFieldName][fieldName] = json::ValueType::Null; json::Value const jrr2 = env.rpc( apiVersion, "json", "ledger_entry", to_string(correctRequest))[jss::result]; checkErrorValue( @@ -451,7 +451,7 @@ class LedgerEntry_test : public beast::unit_test::Suite location); json::Value correctOutput; - correctOutput[parentField] = json::ObjectValue; + correctOutput[parentField] = json::ValueType::Object; for (auto const& subfield : subfields) { correctOutput[parentField][subfield.fieldName] = getCorrectValue(subfield.fieldName); @@ -528,7 +528,7 @@ class LedgerEntry_test : public beast::unit_test::Suite forAllApiVersions([&, this](unsigned apiVersion) { // "features" is not an option supported by ledger_entry. { - json::Value jvParams = json::ObjectValue; + json::Value jvParams = json::ValueType::Object; jvParams[jss::features] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" "AAAAAAAAAA"; @@ -759,14 +759,14 @@ class LedgerEntry_test : public beast::unit_test::Suite { json::Value jvParams; - json::Value ammParams(json::ObjectValue); + json::Value ammParams(json::ValueType::Object); { - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); obj[jss::currency] = "XRP"; ammParams[jss::asset] = obj; } { - json::Value const obj(json::ObjectValue); + json::Value const obj(json::ValueType::Object); ammParams[jss::asset2] = toJson(usd.raw()); } jvParams[jss::amm] = ammParams; @@ -1047,7 +1047,7 @@ class LedgerEntry_test : public beast::unit_test::Suite jvParams[jss::ledger_index] = jss::validated; jvParams[jss::deposit_preauth][jss::owner] = bob.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto& arr(jvParams[jss::deposit_preauth][jss::authorized_credentials]); json::Value jo; @@ -1070,7 +1070,7 @@ class LedgerEntry_test : public beast::unit_test::Suite jvParams[jss::deposit_preauth][jss::owner] = bob.human(); auto tryField = [&](json::Value fieldValue) -> void { - json::Value arr = json::ArrayValue; + json::Value arr = json::ValueType::Array; json::Value jo; jo[jss::issuer] = fieldValue; jo[jss::credential_type] = strHex(std::string_view(credType)); @@ -1090,7 +1090,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { tryField(value); } - tryField(json::NullValue); + tryField(json::ValueType::Null); } { @@ -1099,7 +1099,7 @@ class LedgerEntry_test : public beast::unit_test::Suite jvParams[jss::ledger_index] = jss::validated; jvParams[jss::deposit_preauth][jss::owner] = bob.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto& arr(jvParams[jss::deposit_preauth][jss::authorized_credentials]); json::Value jo; @@ -1121,7 +1121,7 @@ class LedgerEntry_test : public beast::unit_test::Suite jvParams[jss::deposit_preauth][jss::owner] = bob.human(); auto tryField = [&](json::Value fieldValue) -> void { - json::Value arr = json::ArrayValue; + json::Value arr = json::ValueType::Array; json::Value jo; jo[jss::issuer] = issuer.human(); jo[jss::credential_type] = fieldValue; @@ -1141,7 +1141,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { tryField(value); } - tryField(json::NullValue); + tryField(json::ValueType::Null); } { @@ -1151,7 +1151,7 @@ class LedgerEntry_test : public beast::unit_test::Suite jvParams[jss::deposit_preauth][jss::owner] = bob.human(); jvParams[jss::deposit_preauth][jss::authorized] = alice.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto& arr(jvParams[jss::deposit_preauth][jss::authorized_credentials]); json::Value jo; @@ -1187,7 +1187,7 @@ class LedgerEntry_test : public beast::unit_test::Suite json::Value jvParams; jvParams[jss::ledger_index] = jss::validated; jvParams[jss::deposit_preauth][jss::owner] = bob.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto& arr(jvParams[jss::deposit_preauth][jss::authorized_credentials]); arr.append("foobar"); @@ -1203,9 +1203,9 @@ class LedgerEntry_test : public beast::unit_test::Suite json::Value jvParams; jvParams[jss::ledger_index] = jss::validated; jvParams[jss::deposit_preauth][jss::owner] = bob.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto& arr(jvParams[jss::deposit_preauth][jss::authorized_credentials]); - json::Value payload = json::ArrayValue; + json::Value payload = json::ValueType::Array; payload.append(42); arr.append(std::move(payload)); @@ -1221,7 +1221,7 @@ class LedgerEntry_test : public beast::unit_test::Suite json::Value jvParams; jvParams[jss::ledger_index] = jss::validated; jvParams[jss::deposit_preauth][jss::owner] = bob.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto const jrr = env.rpc("json", "ledger_entry", to_string(jvParams)); checkErrorValue( @@ -1240,7 +1240,7 @@ class LedgerEntry_test : public beast::unit_test::Suite json::Value jvParams; jvParams[jss::ledger_index] = jss::validated; jvParams[jss::deposit_preauth][jss::owner] = bob.human(); - jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ArrayValue; + jvParams[jss::deposit_preauth][jss::authorized_credentials] = json::ValueType::Array; auto& arr(jvParams[jss::deposit_preauth][jss::authorized_credentials]); @@ -1305,7 +1305,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Locate directory by directory root. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::directory][jss::dir_root] = dirRootIndex; json::Value const jrr = env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result]; @@ -1314,7 +1314,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Locate directory by owner. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::directory][jss::owner] = alice.human(); jvParams[jss::ledger_hash] = ledgerHash; json::Value const jrr = @@ -1324,7 +1324,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Locate directory by directory root and sub_index. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::directory][jss::dir_root] = dirRootIndex; jvParams[jss::directory][jss::sub_index] = 1; json::Value const jrr = @@ -1335,7 +1335,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Locate directory by owner and sub_index. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::directory][jss::owner] = alice.human(); jvParams[jss::directory][jss::sub_index] = 1; jvParams[jss::ledger_hash] = ledgerHash; @@ -1354,7 +1354,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Non-integer sub_index. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::directory][jss::dir_root] = dirRootIndex; jvParams[jss::ledger_hash] = ledgerHash; testMalformedSubfield( @@ -1369,7 +1369,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Malformed owner entry. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::ledger_hash] = ledgerHash; testMalformedSubfield( @@ -1384,7 +1384,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Malformed directory object. Specifies both dir_root and owner. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::directory][jss::owner] = alice.human(); jvParams[jss::directory][jss::dir_root] = dirRootIndex; jvParams[jss::ledger_hash] = ledgerHash; @@ -1396,7 +1396,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Incomplete directory object. Missing both dir_root and owner. json::Value jvParams; - jvParams[jss::directory] = json::ObjectValue; + jvParams[jss::directory] = json::ValueType::Object; jvParams[jss::directory][jss::sub_index] = 1; jvParams[jss::ledger_hash] = ledgerHash; json::Value const jrr = @@ -1425,7 +1425,7 @@ class LedgerEntry_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::EscrowCreate; jv[jss::Account] = account.human(); jv[jss::Destination] = to.human(); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); jv[sfFinishAfter.jsonName] = cancelAfter.time_since_epoch().count() + 2; return jv; }; @@ -1439,7 +1439,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Request the escrow using owner and sequence. json::Value jvParams; - jvParams[jss::escrow] = json::ObjectValue; + jvParams[jss::escrow] = json::ValueType::Object; jvParams[jss::escrow][jss::owner] = alice.human(); jvParams[jss::escrow][jss::seq] = env.seq(alice) - 1; json::Value const jrr = @@ -1645,7 +1645,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Request the offer using owner and sequence. json::Value jvParams; - jvParams[jss::offer] = json::ObjectValue; + jvParams[jss::offer] = json::ValueType::Object; jvParams[jss::offer][jss::account] = alice.human(); jvParams[jss::offer][jss::seq] = env.seq(alice) - 1; jvParams[jss::ledger_hash] = ledgerHash; @@ -1694,7 +1694,7 @@ class LedgerEntry_test : public beast::unit_test::Suite jv[jss::TransactionType] = jss::PaymentChannelCreate; jv[jss::Account] = account.human(); jv[jss::Destination] = to.human(); - jv[jss::Amount] = amount.getJson(JsonOptions::KNone); + jv[jss::Amount] = amount.getJson(JsonOptions::Values::None); jv[sfSettleDelay.jsonName] = settleDelay.count(); jv[sfPublicKey.jsonName] = strHex(pk.slice()); return jv; @@ -1758,8 +1758,8 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Request the trust line using the accounts and currency. json::Value jvParams; - jvParams[fieldName] = json::ObjectValue; - jvParams[fieldName][jss::accounts] = json::ArrayValue; + jvParams[fieldName] = json::ValueType::Object; + jvParams[fieldName][jss::accounts] = json::ValueType::Array; jvParams[fieldName][jss::accounts][0u] = alice.human(); jvParams[fieldName][jss::accounts][1u] = gw.human(); jvParams[fieldName][jss::currency] = "USD"; @@ -1782,8 +1782,8 @@ class LedgerEntry_test : public beast::unit_test::Suite { // ripple_state one of the accounts is missing. json::Value jvParams; - jvParams[fieldName] = json::ObjectValue; - jvParams[fieldName][jss::accounts] = json::ArrayValue; + jvParams[fieldName] = json::ValueType::Object; + jvParams[fieldName][jss::accounts] = json::ValueType::Array; jvParams[fieldName][jss::accounts][0u] = alice.human(); jvParams[fieldName][jss::currency] = "USD"; jvParams[jss::ledger_hash] = ledgerHash; @@ -1798,8 +1798,8 @@ class LedgerEntry_test : public beast::unit_test::Suite { // ripple_state more than 2 accounts. json::Value jvParams; - jvParams[fieldName] = json::ObjectValue; - jvParams[fieldName][jss::accounts] = json::ArrayValue; + jvParams[fieldName] = json::ValueType::Object; + jvParams[fieldName][jss::accounts] = json::ValueType::Array; jvParams[fieldName][jss::accounts][0u] = alice.human(); jvParams[fieldName][jss::accounts][1u] = gw.human(); jvParams[fieldName][jss::accounts][2u] = alice.human(); @@ -1816,11 +1816,11 @@ class LedgerEntry_test : public beast::unit_test::Suite { // ripple_state account[0] / account[1] is not an account. json::Value jvParams; - jvParams[fieldName] = json::ObjectValue; + jvParams[fieldName] = json::ValueType::Object; auto tryField = [&](json::Value badAccount) -> void { { // account[0] - jvParams[fieldName][jss::accounts] = json::ArrayValue; + jvParams[fieldName][jss::accounts] = json::ValueType::Array; jvParams[fieldName][jss::accounts][0u] = badAccount; jvParams[fieldName][jss::accounts][1u] = gw.human(); jvParams[fieldName][jss::currency] = "USD"; @@ -1835,7 +1835,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // account[1] - jvParams[fieldName][jss::accounts] = json::ArrayValue; + jvParams[fieldName][jss::accounts] = json::ValueType::Array; jvParams[fieldName][jss::accounts][0u] = alice.human(); jvParams[fieldName][jss::accounts][1u] = badAccount; jvParams[fieldName][jss::currency] = "USD"; @@ -1854,13 +1854,13 @@ class LedgerEntry_test : public beast::unit_test::Suite { tryField(value); } - tryField(json::NullValue); + tryField(json::ValueType::Null); } { // ripple_state account[0] == account[1]. json::Value jvParams; - jvParams[fieldName] = json::ObjectValue; - jvParams[fieldName][jss::accounts] = json::ArrayValue; + jvParams[fieldName] = json::ValueType::Object; + jvParams[fieldName][jss::accounts] = json::ValueType::Array; jvParams[fieldName][jss::accounts][0u] = alice.human(); jvParams[fieldName][jss::accounts][1u] = alice.human(); jvParams[fieldName][jss::currency] = "USD"; @@ -1920,7 +1920,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Second real ticket requested by account and sequence. json::Value jvParams; - jvParams[jss::ticket] = json::ObjectValue; + jvParams[jss::ticket] = json::ValueType::Object; jvParams[jss::ticket][jss::account] = env.master.human(); jvParams[jss::ticket][jss::ticket_seq] = tkt1 + 1; jvParams[jss::ledger_hash] = ledgerHash; @@ -1932,7 +1932,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Not a valid ticket requested by account and sequence. json::Value jvParams; - jvParams[jss::ticket] = json::ObjectValue; + jvParams[jss::ticket] = json::ValueType::Object; jvParams[jss::ticket][jss::account] = env.master.human(); jvParams[jss::ticket][jss::ticket_seq] = tkt1 + 2; jvParams[jss::ledger_hash] = ledgerHash; @@ -2129,7 +2129,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Request the MPToken using its owner + mptIssuanceID. json::Value jvParams; - jvParams[jss::mptoken] = json::ObjectValue; + jvParams[jss::mptoken] = json::ValueType::Object; jvParams[jss::mptoken][jss::account] = bob.human(); jvParams[jss::mptoken][jss::mpt_issuance_id] = strHex(mptAlice.issuanceID()); jvParams[jss::ledger_hash] = ledgerHash; @@ -2141,7 +2141,7 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Request the MPToken using a bad mptIssuanceID. json::Value jvParams; - jvParams[jss::mptoken] = json::ObjectValue; + jvParams[jss::mptoken] = json::ValueType::Object; jvParams[jss::mptoken][jss::account] = bob.human(); jvParams[jss::mptoken][jss::mpt_issuance_id] = badMptID; jvParams[jss::ledger_hash] = ledgerHash; @@ -2302,7 +2302,7 @@ class LedgerEntry_test : public beast::unit_test::Suite // "field":null json::Value params; params[jss::ledger_index] = jss::validated; - params[field] = json::NullValue; + params[field] = json::ValueType::Null; auto const jv = env.rpc("json", "ledger_entry", to_string(params)); checkResult(false, jv, expectedType, "malformedRequest"); BEAST_EXPECT(!jv[jss::result].isMember(jss::index)); @@ -2499,7 +2499,7 @@ class LedgerEntry_test : public beast::unit_test::Suite // "hashes":null json::Value params; params[jss::ledger_index] = jss::validated; - params[jss::hashes] = json::NullValue; + params[jss::hashes] = json::ValueType::Null; auto jv = env.rpc("json", "ledger_entry", to_string(params)); checkResult(false, jv, 0, "malformedRequest"); BEAST_EXPECT(!jv[jss::result].isMember(jss::index)); @@ -2696,7 +2696,8 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite, BEAST_EXPECT(jv[jss::error] == err); if (msg.empty()) { - BEAST_EXPECT(jv[jss::error_message] == json::NullValue || jv[jss::error_message] == ""); + BEAST_EXPECT( + jv[jss::error_message] == json::ValueType::Null || jv[jss::error_message] == ""); } else if (BEAST_EXPECT(jv.isMember(jss::error_message))) { diff --git a/src/test/rpc/LedgerHeader_test.cpp b/src/test/rpc/LedgerHeader_test.cpp index 885fabb255..0f6831a0e5 100644 --- a/src/test/rpc/LedgerHeader_test.cpp +++ b/src/test/rpc/LedgerHeader_test.cpp @@ -16,7 +16,7 @@ class LedgerHeader_test : public beast::unit_test::Suite using namespace test::jtx; Env env{*this, envconfig(noAdmin)}; - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::api_version] = 1; params[jss::ledger_index] = "current"; auto const result = env.client().invoke("ledger_header", params)[jss::result]; @@ -33,7 +33,7 @@ class LedgerHeader_test : public beast::unit_test::Suite using namespace test::jtx; Env env{*this, envconfig(noAdmin)}; - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::api_version] = 1; params[jss::ledger_index] = "validated"; auto const result = env.client().invoke("ledger_header", params)[jss::result]; @@ -50,7 +50,7 @@ class LedgerHeader_test : public beast::unit_test::Suite using namespace test::jtx; Env env{*this, envconfig(noAdmin)}; - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::api_version] = 2; auto const result = env.client().invoke("ledger_header", params)[jss::result]; BEAST_EXPECT(result[jss::error] == "unknownCmd"); diff --git a/src/test/rpc/LedgerRPC_test.cpp b/src/test/rpc/LedgerRPC_test.cpp index 13887e5710..f8d7901ec0 100644 --- a/src/test/rpc/LedgerRPC_test.cpp +++ b/src/test/rpc/LedgerRPC_test.cpp @@ -38,7 +38,8 @@ class LedgerRPC_test : public beast::unit_test::Suite BEAST_EXPECT(jv[jss::error] == err); if (msg.empty()) { - BEAST_EXPECT(jv[jss::error_message] == json::NullValue || jv[jss::error_message] == ""); + BEAST_EXPECT( + jv[jss::error_message] == json::ValueType::Null || jv[jss::error_message] == ""); } else if (BEAST_EXPECT(jv.isMember(jss::error_message))) { diff --git a/src/test/rpc/LedgerRequest_test.cpp b/src/test/rpc/LedgerRequest_test.cpp index 65c5a57712..65bcfb309b 100644 --- a/src/test/rpc/LedgerRequest_test.cpp +++ b/src/test/rpc/LedgerRequest_test.cpp @@ -342,7 +342,7 @@ public: // The current HTTP/S ServerHandler returns an HTTP 403 error code here // rather than a noPermission JSON error. The JSONRPCClient just eats // that error and returns an null result. - BEAST_EXPECT(result.type() == json::NullValue); + BEAST_EXPECT(result.type() == json::ValueType::Null); } void diff --git a/src/test/rpc/NoRippleCheck_test.cpp b/src/test/rpc/NoRippleCheck_test.cpp index 5099a2da2f..28d0462203 100644 --- a/src/test/rpc/NoRippleCheck_test.cpp +++ b/src/test/rpc/NoRippleCheck_test.cpp @@ -76,9 +76,9 @@ class NoRippleCheck_test : public beast::unit_test::Suite testInvalidAccountParam(1); testInvalidAccountParam(1.1); testInvalidAccountParam(true); - testInvalidAccountParam(json::Value(json::NullValue)); - testInvalidAccountParam(json::Value(json::ObjectValue)); - testInvalidAccountParam(json::Value(json::ArrayValue)); + testInvalidAccountParam(json::Value(json::ValueType::Null)); + testInvalidAccountParam(json::Value(json::ValueType::Object)); + testInvalidAccountParam(json::Value(json::ValueType::Array)); } { // invalid role field @@ -153,7 +153,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite json::Value params; params[jss::account] = Account{"nobody"}.human(); params[jss::role] = "user"; - params[jss::ledger] = json::ObjectValue; + params[jss::ledger] = json::ValueType::Object; auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result]; BEAST_EXPECT(result[jss::error] == "invalidParams"); BEAST_EXPECT( @@ -241,7 +241,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite result[jss::transactions][txs.size() - 1][jss::TransactionType] == jss::TrustSet); BEAST_EXPECT( result[jss::transactions][txs.size() - 1][jss::LimitAmount] == - gw["USD"](100).value().getJson(JsonOptions::KNone)); + gw["USD"](100).value().getJson(JsonOptions::Values::None)); } else { @@ -293,11 +293,11 @@ class NoRippleCheckLimits_test : public beast::unit_test::Suite Endpoint::fromString(test::getEnvLocalhostAddr())); // if we go above the warning threshold, reset - if (c.balance() > WarningThreshold) + if (c.balance() > kWARNING_THRESHOLD) { using ct = beast::AbstractClock; c.entry().local_balance = - DecayingSample{steady_clock::now()}; + DecayingSample{steady_clock::now()}; } }; diff --git a/src/test/rpc/OwnerInfo_test.cpp b/src/test/rpc/OwnerInfo_test.cpp index 5704138272..dc1e18f9d0 100644 --- a/src/test/rpc/OwnerInfo_test.cpp +++ b/src/test/rpc/OwnerInfo_test.cpp @@ -56,8 +56,8 @@ class OwnerInfo_test : public beast::unit_test::Suite json::Value params; params[jss::account] = Account{"bob"}.human(); auto const result = env.rpc("json", "owner_info", to_string(params))[jss::result]; - BEAST_EXPECT(result[jss::accepted] == json::ObjectValue); - BEAST_EXPECT(result[jss::current] == json::ObjectValue); + BEAST_EXPECT(result[jss::accepted] == json::ValueType::Object); + BEAST_EXPECT(result[jss::current] == json::ValueType::Object); BEAST_EXPECT(result[jss::status] == "success"); } } @@ -103,21 +103,23 @@ class OwnerInfo_test : public beast::unit_test::Suite BEAST_EXPECT( lines[0u][sfBalance.fieldName] == (STAmount{Issue{toCurrency("CNY"), noAccount()}, 0}.value().getJson( - JsonOptions::KNone))); + JsonOptions::Values::None))); BEAST_EXPECT( lines[0u][sfHighLimit.fieldName] == - alice["CNY"](1000).value().getJson(JsonOptions::KNone)); + alice["CNY"](1000).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( - lines[0u][sfLowLimit.fieldName] == gw["CNY"](0).value().getJson(JsonOptions::KNone)); + lines[0u][sfLowLimit.fieldName] == + gw["CNY"](0).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( lines[1u][sfBalance.fieldName] == (STAmount{Issue{toCurrency("USD"), noAccount()}, 0}.value().getJson( - JsonOptions::KNone))); + JsonOptions::Values::None))); BEAST_EXPECT( lines[1u][sfHighLimit.fieldName] == - alice["USD"](1000).value().getJson(JsonOptions::KNone)); - BEAST_EXPECT(lines[1u][sfLowLimit.fieldName] == usd(0).value().getJson(JsonOptions::KNone)); + alice["USD"](1000).value().getJson(JsonOptions::Values::None)); + BEAST_EXPECT( + lines[1u][sfLowLimit.fieldName] == usd(0).value().getJson(JsonOptions::Values::None)); if (!BEAST_EXPECT(result[jss::accepted].isMember(jss::offers))) return; @@ -127,9 +129,10 @@ class OwnerInfo_test : public beast::unit_test::Suite BEAST_EXPECT(offers[0u][jss::Account] == alice.human()); BEAST_EXPECT( - offers[0u][sfTakerGets.fieldName] == XRP(1000).value().getJson(JsonOptions::KNone)); + offers[0u][sfTakerGets.fieldName] == + XRP(1000).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( - offers[0u][sfTakerPays.fieldName] == usd(1).value().getJson(JsonOptions::KNone)); + offers[0u][sfTakerPays.fieldName] == usd(1).value().getJson(JsonOptions::Values::None)); // current ledger entry if (!BEAST_EXPECT(result[jss::current].isMember(jss::ripple_lines))) @@ -141,22 +144,24 @@ class OwnerInfo_test : public beast::unit_test::Suite BEAST_EXPECT( lines[0u][sfBalance.fieldName] == (STAmount{Issue{toCurrency("CNY"), noAccount()}, -50}.value().getJson( - JsonOptions::KNone))); + JsonOptions::Values::None))); BEAST_EXPECT( lines[0u][sfHighLimit.fieldName] == - alice["CNY"](1000).value().getJson(JsonOptions::KNone)); + alice["CNY"](1000).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( - lines[0u][sfLowLimit.fieldName] == gw["CNY"](0).value().getJson(JsonOptions::KNone)); + lines[0u][sfLowLimit.fieldName] == + gw["CNY"](0).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( lines[1u][sfBalance.fieldName] == (STAmount{Issue{toCurrency("USD"), noAccount()}, -50}.value().getJson( - JsonOptions::KNone))); + JsonOptions::Values::None))); BEAST_EXPECT( lines[1u][sfHighLimit.fieldName] == - alice["USD"](1000).value().getJson(JsonOptions::KNone)); + alice["USD"](1000).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( - lines[1u][sfLowLimit.fieldName] == gw["USD"](0).value().getJson(JsonOptions::KNone)); + lines[1u][sfLowLimit.fieldName] == + gw["USD"](0).value().getJson(JsonOptions::Values::None)); if (!BEAST_EXPECT(result[jss::current].isMember(jss::offers))) return; @@ -168,9 +173,10 @@ class OwnerInfo_test : public beast::unit_test::Suite BEAST_EXPECT(offers[1u] == result[jss::accepted][jss::offers][0u]); BEAST_EXPECT(offers[0u][jss::Account] == alice.human()); BEAST_EXPECT( - offers[0u][sfTakerGets.fieldName] == XRP(1000).value().getJson(JsonOptions::KNone)); + offers[0u][sfTakerGets.fieldName] == + XRP(1000).value().getJson(JsonOptions::Values::None)); BEAST_EXPECT( - offers[0u][sfTakerPays.fieldName] == cny(2).value().getJson(JsonOptions::KNone)); + offers[0u][sfTakerPays.fieldName] == cny(2).value().getJson(JsonOptions::Values::None)); } public: diff --git a/src/test/rpc/RPCHelpers_test.cpp b/src/test/rpc/RPCHelpers_test.cpp index 8896bd081b..1458c0aa80 100644 --- a/src/test/rpc/RPCHelpers_test.cpp +++ b/src/test/rpc/RPCHelpers_test.cpp @@ -18,7 +18,7 @@ public: testcase("ChooseLedgerEntryType"); // Test no type. - json::Value tx = json::ObjectValue; + json::Value tx = json::ValueType::Object; auto result = RPC::chooseLedgerEntryType(tx); BEAST_EXPECT(result.first == RPC::Status::kOK); BEAST_EXPECT(result.second == 0); diff --git a/src/test/rpc/RPCOverload_test.cpp b/src/test/rpc/RPCOverload_test.cpp index c483c2f694..b1030ebea5 100644 --- a/src/test/rpc/RPCOverload_test.cpp +++ b/src/test/rpc/RPCOverload_test.cpp @@ -40,7 +40,7 @@ public: std::unique_ptr client = useWS ? makeWSClient(env.app().config()) : makeJSONRPCClient(env.app().config()); - json::Value tx = json::ObjectValue; + json::Value tx = json::ValueType::Object; tx[jss::tx_json] = pay(alice, bob, XRP(1)); tx[jss::secret] = toBase58(generateSeed("alice")); diff --git a/src/test/rpc/RobustTransaction_test.cpp b/src/test/rpc/RobustTransaction_test.cpp index 03339e1a78..99668aff39 100644 --- a/src/test/rpc/RobustTransaction_test.cpp +++ b/src/test/rpc/RobustTransaction_test.cpp @@ -32,7 +32,7 @@ public: { // RPC subscribe to transactions stream json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams].append("transactions"); jv = wsc->invoke("subscribe", jv); BEAST_EXPECT(jv[jss::status] == "success"); @@ -123,7 +123,7 @@ public: { // RPC unsubscribe to transactions stream json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams].append("transactions"); jv = wsc->invoke("unsubscribe", jv); if (wsc->version() == 2) @@ -242,7 +242,7 @@ public: { // RPC subscribe to ledger stream json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams].append("ledger"); jv = wsc->invoke("subscribe", jv); if (wsc->version() == 2) @@ -276,7 +276,7 @@ public: { // RPC unsubscribe to ledger stream json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams].append("ledger"); jv = wsc->invoke("unsubscribe", jv); if (wsc->version() == 2) @@ -295,7 +295,7 @@ public: { // RPC subscribe to ledger stream json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams].append("ledger"); jv = wsc->invoke("subscribe", jv); if (wsc->version() == 2) @@ -329,7 +329,7 @@ public: { // RPC unsubscribe to ledger stream json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams].append("ledger"); jv = wsc->invoke("unsubscribe", jv); if (wsc->version() == 2) @@ -378,7 +378,7 @@ public: { // RPC subscribe to accounts_proposed stream json::Value jv; - jv[jss::accounts_proposed] = json::ArrayValue; + jv[jss::accounts_proposed] = json::ValueType::Array; jv[jss::accounts_proposed].append(Account("alice").human()); jv = wsc->invoke("subscribe", jv); if (wsc->version() == 2) @@ -416,7 +416,7 @@ public: { // RPC unsubscribe to accounts_proposed stream json::Value jv; - jv[jss::accounts_proposed] = json::ArrayValue; + jv[jss::accounts_proposed] = json::ValueType::Array; jv[jss::accounts_proposed].append(Account("alice").human()); jv = wsc->invoke("unsubscribe", jv); if (wsc->version() == 2) diff --git a/src/test/rpc/ServerDefinitions_test.cpp b/src/test/rpc/ServerDefinitions_test.cpp index d53c845726..bac1b4f7a5 100644 --- a/src/test/rpc/ServerDefinitions_test.cpp +++ b/src/test/rpc/ServerDefinitions_test.cpp @@ -8,6 +8,9 @@ #include #include +#include +#include + namespace xrpl::test { class ServerDefinitions_test : public beast::unit_test::Suite @@ -37,20 +40,23 @@ public: { auto const firstField = result[jss::result][jss::FIELDS][0u]; - BEAST_EXPECT(firstField[0u].asString() == "Generic"); + BEAST_EXPECT(firstField[0u].asString() == "Invalid"); BEAST_EXPECT(firstField[1][jss::isSerialized].asBool() == false); BEAST_EXPECT(firstField[1][jss::isSigningField].asBool() == false); BEAST_EXPECT(firstField[1][jss::isVLEncoded].asBool() == false); - BEAST_EXPECT(firstField[1][jss::nth].asUInt() == 0); + BEAST_EXPECT(firstField[1][jss::nth].asInt() == -1); BEAST_EXPECT(firstField[1][jss::type].asString() == "Unknown"); } - BEAST_EXPECT( - result[jss::result][jss::LEDGER_ENTRY_TYPES]["AccountRoot"].asUInt() == 97); - BEAST_EXPECT( - result[jss::result][jss::TRANSACTION_RESULTS]["tecDIR_FULL"].asUInt() == 121); - BEAST_EXPECT(result[jss::result][jss::TRANSACTION_TYPES]["Payment"].asUInt() == 0); - BEAST_EXPECT(result[jss::result][jss::TYPES]["AccountID"].asUInt() == 8); + { + auto const field = result[jss::result][jss::FIELDS][6u]; + BEAST_EXPECT(field[0u].asString() == "LedgerEntryType"); + BEAST_EXPECT(field[1][jss::isSerialized].asBool() == true); + BEAST_EXPECT(field[1][jss::isSigningField].asBool() == true); + BEAST_EXPECT(field[1][jss::isVLEncoded].asBool() == false); + BEAST_EXPECT(field[1][jss::nth].asUInt() == 1); + BEAST_EXPECT(field[1][jss::type].asString() == "UInt16"); + } // check exception SFields { @@ -74,17 +80,34 @@ public: BEAST_EXPECT(fieldExists("index")); } + // verify no duplicate field names in FIELDS array + { + std::set fieldNames; + for (auto const& field : result[jss::result][jss::FIELDS]) + { + auto const name = field[0u].asString(); + BEAST_EXPECT(fieldNames.insert(name).second); + } + } + // test that base_uint types are replaced with "Hash" prefix { auto const types = result[jss::result][jss::TYPES]; - BEAST_EXPECT(types["Hash128"].asUInt() == 4); - BEAST_EXPECT(types["Hash160"].asUInt() == 17); - BEAST_EXPECT(types["Hash192"].asUInt() == 21); - BEAST_EXPECT(types["Hash256"].asUInt() == 5); - BEAST_EXPECT(types["Hash384"].asUInt() == 22); - BEAST_EXPECT(types["Hash512"].asUInt() == 23); + BEAST_EXPECT(types.isMember("Hash128") && types["Hash128"].asUInt() == 4); + BEAST_EXPECT(types.isMember("Hash160") && types["Hash160"].asUInt() == 17); + BEAST_EXPECT(types.isMember("Hash192") && types["Hash192"].asUInt() == 21); + BEAST_EXPECT(types.isMember("Hash256") && types["Hash256"].asUInt() == 5); + BEAST_EXPECT(types.isMember("Hash384") && types["Hash384"].asUInt() == 22); + BEAST_EXPECT(types.isMember("Hash512") && types["Hash512"].asUInt() == 23); } + BEAST_EXPECT( + result[jss::result][jss::LEDGER_ENTRY_TYPES]["AccountRoot"].asUInt() == 97); + BEAST_EXPECT( + result[jss::result][jss::TRANSACTION_RESULTS]["tecDIR_FULL"].asUInt() == 121); + BEAST_EXPECT(result[jss::result][jss::TRANSACTION_TYPES]["Payment"].asUInt() == 0); + BEAST_EXPECT(result[jss::result][jss::TYPES]["AccountID"].asUInt() == 8); + // test the properties of the LEDGER_ENTRY_FLAGS section { BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS)); diff --git a/src/test/rpc/Simulate_test.cpp b/src/test/rpc/Simulate_test.cpp index ca5fa2133c..06a77647c4 100644 --- a/src/test/rpc/Simulate_test.cpp +++ b/src/test/rpc/Simulate_test.cpp @@ -66,7 +66,7 @@ class Simulate_test : public beast::unit_test::Suite { auto const unHexed = strUnHex(result[jss::tx_blob].asString()); SerialIter sitTrans(makeSlice(*unHexed)); // NOLINT(bugprone-unchecked-optional-access) - txJson = STObject(std::ref(sitTrans), kSF_GENERIC).getJson(JsonOptions::KNone); + txJson = STObject(std::ref(sitTrans), kSF_GENERIC).getJson(JsonOptions::Values::None); } BEAST_EXPECT(txJson[jss::TransactionType] == tx[jss::TransactionType]); BEAST_EXPECT(txJson[jss::Account] == tx[jss::Account]); @@ -162,7 +162,7 @@ class Simulate_test : public beast::unit_test::Suite { auto unHexed = strUnHex(txResult[jss::meta_blob].asString()); SerialIter sitTrans(makeSlice(*unHexed)); // NOLINT(bugprone-unchecked-optional-access) - return STObject(std::ref(sitTrans), kSF_GENERIC).getJson(JsonOptions::KNone); + return STObject(std::ref(sitTrans), kSF_GENERIC).getJson(JsonOptions::Values::None); } return txResult[jss::meta]; @@ -179,7 +179,7 @@ class Simulate_test : public beast::unit_test::Suite { // No params - json::Value const params = json::ObjectValue; + json::Value const params = json::ValueType::Object; auto const resp = env.rpc("json", "simulate", to_string(params)); BEAST_EXPECT( resp[jss::result][jss::error_message] == @@ -187,8 +187,8 @@ class Simulate_test : public beast::unit_test::Suite } { // Providing both `tx_json` and `tx_blob` - json::Value params = json::ObjectValue; - params[jss::tx_json] = json::ObjectValue; + json::Value params = json::ValueType::Object; + params[jss::tx_json] = json::ValueType::Object; params[jss::tx_blob] = "1200"; auto const resp = env.rpc("json", "simulate", to_string(params)); @@ -198,7 +198,7 @@ class Simulate_test : public beast::unit_test::Suite } { // `binary` isn't a boolean - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::tx_blob] = "1200"; params[jss::binary] = "100"; auto const resp = env.rpc("json", "simulate", to_string(params)); @@ -206,7 +206,7 @@ class Simulate_test : public beast::unit_test::Suite } { // Invalid `tx_blob` - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::tx_blob] = "12"; auto const resp = env.rpc("json", "simulate", to_string(params)); @@ -214,8 +214,8 @@ class Simulate_test : public beast::unit_test::Suite } { // Empty `tx_json` - json::Value params = json::ObjectValue; - params[jss::tx_json] = json::ObjectValue; + json::Value params = json::ValueType::Object; + params[jss::tx_json] = json::ValueType::Object; auto const resp = env.rpc("json", "simulate", to_string(params)); BEAST_EXPECT( @@ -223,8 +223,8 @@ class Simulate_test : public beast::unit_test::Suite } { // No tx.Account - json::Value params = json::ObjectValue; - json::Value txJson = json::ObjectValue; + json::Value params = json::ValueType::Object; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::Payment; params[jss::tx_json] = txJson; @@ -233,7 +233,7 @@ class Simulate_test : public beast::unit_test::Suite } { // Empty `tx_blob` - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::tx_blob] = ""; auto const resp = env.rpc("json", "simulate", to_string(params)); @@ -249,7 +249,7 @@ class Simulate_test : public beast::unit_test::Suite } { // Non-object `tx_json` - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::tx_json] = ""; auto const resp = env.rpc("json", "simulate", to_string(params)); @@ -258,9 +258,9 @@ class Simulate_test : public beast::unit_test::Suite } { // `seed` field included - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::seed] = "random_data"; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); params[jss::tx_json] = txJson; @@ -269,9 +269,9 @@ class Simulate_test : public beast::unit_test::Suite } { // `secret` field included - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::secret] = "random_data"; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); params[jss::tx_json] = txJson; @@ -280,9 +280,9 @@ class Simulate_test : public beast::unit_test::Suite } { // `seed_hex` field included - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::seed_hex] = "random_data"; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); params[jss::tx_json] = txJson; @@ -291,9 +291,9 @@ class Simulate_test : public beast::unit_test::Suite } { // `passphrase` field included - json::Value params = json::ObjectValue; + json::Value params = json::ValueType::Object; params[jss::passphrase] = "random_data"; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); params[jss::tx_json] = txJson; @@ -302,8 +302,8 @@ class Simulate_test : public beast::unit_test::Suite } { // Invalid transaction - json::Value params = json::ObjectValue; - json::Value txJson = json::ObjectValue; + json::Value params = json::ValueType::Object; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::Payment; txJson[jss::Account] = env.master.human(); params[jss::tx_json] = txJson; @@ -316,7 +316,7 @@ class Simulate_test : public beast::unit_test::Suite { // Bad account json::Value params; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = "badAccount"; params[jss::tx_json] = txJson; @@ -330,7 +330,7 @@ class Simulate_test : public beast::unit_test::Suite { // Account doesn't exist for Sequence autofill json::Value params; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = alice.human(); params[jss::tx_json] = txJson; @@ -341,7 +341,7 @@ class Simulate_test : public beast::unit_test::Suite { // Invalid Signers field json::Value params; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); txJson[sfSigners] = "1"; @@ -353,10 +353,10 @@ class Simulate_test : public beast::unit_test::Suite { // Invalid Signers field json::Value params; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); - txJson[sfSigners] = json::ArrayValue; + txJson[sfSigners] = json::ValueType::Array; txJson[sfSigners].append("1"); params[jss::tx_json] = txJson; @@ -366,7 +366,7 @@ class Simulate_test : public beast::unit_test::Suite { // Invalid transaction json::Value params; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); txJson["foo"] = "bar"; @@ -378,7 +378,7 @@ class Simulate_test : public beast::unit_test::Suite } { // non-`"binary"` second param for CLI - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = alice.human(); auto const resp = env.rpc("simulate", to_string(txJson), "1"); @@ -387,7 +387,7 @@ class Simulate_test : public beast::unit_test::Suite { // Signed transaction json::Value params; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); txJson[jss::TxnSignature] = "1200ABCD"; @@ -400,10 +400,10 @@ class Simulate_test : public beast::unit_test::Suite { // Signed multisig transaction json::Value params; - json::Value txJson = json::ObjectValue; + json::Value txJson = json::ValueType::Object; txJson[jss::TransactionType] = jss::AccountSet; txJson[jss::Account] = env.master.human(); - txJson[sfSigners] = json::ArrayValue; + txJson[sfSigners] = json::ValueType::Array; { json::Value signer; signer[jss::Account] = alice.human(); @@ -723,7 +723,7 @@ class Simulate_test : public beast::unit_test::Suite // test with autofill testTx(env, tx, validateOutput, false); - tx[sfSigners] = json::ArrayValue; + tx[sfSigners] = json::ValueType::Array; { json::Value signer; signer[jss::Account] = becky.human(); @@ -837,7 +837,7 @@ class Simulate_test : public beast::unit_test::Suite tx[sfDomain] = kNEW_DOMAIN; // master key is disabled, so this is invalid tx[jss::SigningPubKey] = strHex(env.master.pk().slice()); - tx[sfSigners] = json::ArrayValue; + tx[sfSigners] = json::ValueType::Array; { json::Value signer; signer[jss::Account] = becky.human(); @@ -900,7 +900,7 @@ class Simulate_test : public beast::unit_test::Suite tx[jss::Account] = alice.human(); tx[jss::TransactionType] = jss::AccountSet; tx[sfDomain] = kNEW_DOMAIN; - tx[sfSigners] = json::ArrayValue; + tx[sfSigners] = json::ValueType::Array; { json::Value signer; signer[jss::Account] = becky.human(); diff --git a/src/test/rpc/Submit_test.cpp b/src/test/rpc/Submit_test.cpp index fe86a6c550..8dff2d75ec 100644 --- a/src/test/rpc/Submit_test.cpp +++ b/src/test/rpc/Submit_test.cpp @@ -60,8 +60,8 @@ public: testInvalidFailHard(1); testInvalidFailHard(0); testInvalidFailHard(1.5); - testInvalidFailHard(json::Value(json::ObjectValue)); - testInvalidFailHard(json::Value(json::ArrayValue)); + testInvalidFailHard(json::Value(json::ValueType::Object)); + testInvalidFailHard(json::Value(json::ValueType::Array)); // Valid boolean values should work (not return invalidParams) { diff --git a/src/test/rpc/Subscribe_test.cpp b/src/test/rpc/Subscribe_test.cpp index 78dc7fcf30..3ce054a814 100644 --- a/src/test/rpc/Subscribe_test.cpp +++ b/src/test/rpc/Subscribe_test.cpp @@ -70,7 +70,7 @@ public: { // RPC subscribe to server stream - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("server"); auto jv = wsc->invoke("subscribe", stream); if (wsc->version() == 2) @@ -136,7 +136,7 @@ public: { // RPC subscribe to ledger stream - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("ledger"); auto jv = wsc->invoke("subscribe", stream); if (wsc->version() == 2) @@ -195,7 +195,7 @@ public: { // RPC subscribe to transactions stream - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("transactions"); auto jv = wsc->invoke("subscribe", stream); if (wsc->version() == 2) @@ -267,8 +267,8 @@ public: { // RPC subscribe to accounts stream - stream = json::ObjectValue; - stream[jss::accounts] = json::ArrayValue; + stream = json::ValueType::Object; + stream[jss::accounts] = json::ValueType::Array; stream[jss::accounts].append(Account("alice").human()); auto jv = wsc->invoke("subscribe", stream); if (wsc->version() == 2) @@ -326,12 +326,12 @@ public: return cfg; })); auto wsc = makeWSClient(env.app().config()); - json::Value stream{json::ObjectValue}; + json::Value stream{json::ValueType::Object}; { // RPC subscribe to transactions stream stream[jss::api_version] = 2; - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("transactions"); auto jv = wsc->invoke("subscribe", stream); if (wsc->version() == 2) @@ -401,7 +401,7 @@ public: { // RPC subscribe to manifests stream - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("manifests"); auto jv = wsc->invoke("subscribe", stream); if (wsc->version() == 2) @@ -447,7 +447,7 @@ public: { // RPC subscribe to validations stream - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("validations"); auto jv = wsc->invoke("subscribe", stream); if (wsc->version() == 2) @@ -546,7 +546,7 @@ public: jv[jss::url] = "http://localhost/events"; jv[jss::url_username] = "admin"; jv[jss::url_password] = "password"; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams][0u] = "validations"; auto jr = env.rpc("json", "subscribe", to_string(jv))[jss::result]; BEAST_EXPECT(jr[jss::status] == "success"); @@ -616,13 +616,13 @@ public: } std::initializer_list const nonArrays{ - json::NullValue, - json::IntValue, - json::UintValue, - json::RealValue, + json::ValueType::Null, + json::ValueType::Int, + json::ValueType::UInt, + json::ValueType::Real, "", - json::BooleanValue, - json::ObjectValue}; + json::ValueType::Boolean, + json::ValueType::Object}; for (auto const& f : {jss::accounts_proposed, jss::accounts}) { @@ -637,7 +637,7 @@ public: { json::Value jv; - jv[f] = json::ArrayValue; + jv[f] = json::ValueType::Array; auto const jr = wsc->invoke(method, jv)[jss::result]; BEAST_EXPECT(jr[jss::error] == "actMalformed"); BEAST_EXPECT(jr[jss::error_message] == "Account malformed."); @@ -655,7 +655,7 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; + jv[jss::books] = json::ValueType::Array; jv[jss::books][0u] = 1; auto const jr = wsc->invoke(method, jv)[jss::result]; BEAST_EXPECT(jr[jss::error] == "invalidParams"); @@ -664,10 +664,10 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; - jv[jss::books][0u][jss::taker_gets] = json::ObjectValue; - jv[jss::books][0u][jss::taker_pays] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_gets] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_pays] = json::ValueType::Object; auto const jr = wsc->invoke(method, jv)[jss::result]; BEAST_EXPECT(jr[jss::error] == "srcCurMalformed"); @@ -676,10 +676,10 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; - jv[jss::books][0u][jss::taker_gets] = json::ObjectValue; - jv[jss::books][0u][jss::taker_pays] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_gets] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_pays] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays][jss::currency] = "ZZZZ"; auto const jr = wsc->invoke(method, jv)[jss::result]; BEAST_EXPECT(jr[jss::error] == "srcCurMalformed"); @@ -688,10 +688,10 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; - jv[jss::books][0u][jss::taker_gets] = json::ObjectValue; - jv[jss::books][0u][jss::taker_pays] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_gets] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_pays] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays][jss::currency] = "USD"; jv[jss::books][0u][jss::taker_pays][jss::issuer] = 1; auto const jr = wsc->invoke(method, jv)[jss::result]; @@ -701,10 +701,10 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; - jv[jss::books][0u][jss::taker_gets] = json::ObjectValue; - jv[jss::books][0u][jss::taker_pays] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_gets] = json::ValueType::Object; + jv[jss::books][0u][jss::taker_pays] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays][jss::currency] = "USD"; jv[jss::books][0u][jss::taker_pays][jss::issuer] = Account{"gateway"}.human() + "DEAD"; auto const jr = wsc->invoke(method, jv)[jss::result]; @@ -714,11 +714,11 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); - jv[jss::books][0u][jss::taker_gets] = json::ObjectValue; + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); + jv[jss::books][0u][jss::taker_gets] = json::ValueType::Object; auto const jr = wsc->invoke(method, jv)[jss::result]; // NOTE: this error is slightly incongruous with the equivalent source currency error BEAST_EXPECT(jr[jss::error] == "dstAmtMalformed"); @@ -728,10 +728,10 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); jv[jss::books][0u][jss::taker_gets][jss::currency] = "ZZZZ"; auto const jr = wsc->invoke(method, jv)[jss::result]; // NOTE: this error is slightly incongruous with the @@ -743,10 +743,10 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); jv[jss::books][0u][jss::taker_gets][jss::currency] = "USD"; jv[jss::books][0u][jss::taker_gets][jss::issuer] = 1; auto const jr = wsc->invoke(method, jv)[jss::result]; @@ -756,10 +756,10 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); jv[jss::books][0u][jss::taker_gets][jss::currency] = "USD"; jv[jss::books][0u][jss::taker_gets][jss::issuer] = Account{"gateway"}.human() + "DEAD"; auto const jr = wsc->invoke(method, jv)[jss::result]; @@ -769,12 +769,12 @@ public: { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); jv[jss::books][0u][jss::taker_gets] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); auto const jr = wsc->invoke(method, jv)[jss::result]; BEAST_EXPECT(jr[jss::error] == "badMarket"); BEAST_EXPECT(jr[jss::error_message] == "No such market."); @@ -791,7 +791,7 @@ public: { json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams][0u] = 1; auto const jr = wsc->invoke(method, jv)[jss::result]; BEAST_EXPECT(jr[jss::error] == "malformedStream"); @@ -800,7 +800,7 @@ public: { json::Value jv; - jv[jss::streams] = json::ArrayValue; + jv[jss::streams] = json::ValueType::Array; jv[jss::streams][0u] = "not_a_stream"; auto const jr = wsc->invoke(method, jv)[jss::result]; BEAST_EXPECT(jr[jss::error] == "malformedStream"); @@ -812,10 +812,10 @@ public: // invalid taker - not a string { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); jv[jss::books][0u][jss::taker_gets][jss::currency] = "XRP"; jv[jss::books][0u][jss::taker] = 1; auto const jr = wsc->invoke(method, jv)[jss::result]; @@ -826,10 +826,10 @@ public: // invalid taker - malformed account string { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); jv[jss::books][0u][jss::taker_gets][jss::currency] = "XRP"; jv[jss::books][0u][jss::taker] = "not_an_account"; auto const jr = wsc->invoke(method, jv)[jss::result]; @@ -840,10 +840,10 @@ public: // invalid taker - account string with extra characters { json::Value jv; - jv[jss::books] = json::ArrayValue; - jv[jss::books][0u] = json::ObjectValue; + jv[jss::books] = json::ValueType::Array; + jv[jss::books][0u] = json::ValueType::Object; jv[jss::books][0u][jss::taker_pays] = - Account{"gateway"}["USD"](1).value().getJson(JsonOptions::KIncludeDate); + Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate); jv[jss::books][0u][jss::taker_gets][jss::currency] = "XRP"; jv[jss::books][0u][jss::taker] = Account{"alice"}.human() + "DEAD"; auto const jr = wsc->invoke(method, jv)[jss::result]; @@ -1033,7 +1033,7 @@ public: Env env(*this, singleThreadIo(envconfig())); auto wscTxHistory = makeWSClient(env.app().config()); json::Value request; - request[jss::account_history_tx_stream] = json::ObjectValue; + request[jss::account_history_tx_stream] = json::ValueType::Object; request[jss::account_history_tx_stream][jss::account] = alice.human(); auto jv = wscTxHistory->invoke("subscribe", request); if (!BEAST_EXPECT(goodSubRPC(jv))) @@ -1076,7 +1076,7 @@ public: Env env(*this, singleThreadIo(envconfig())); auto wscTxHistory = makeWSClient(env.app().config()); json::Value request; - request[jss::account_history_tx_stream] = json::ObjectValue; + request[jss::account_history_tx_stream] = json::ValueType::Object; request[jss::account_history_tx_stream][jss::account] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; auto jv = wscTxHistory->invoke("subscribe", request); @@ -1159,8 +1159,8 @@ public: BEAST_EXPECT(env.syncClose()); // subscribe account - json::Value stream = json::ObjectValue; - stream[jss::accounts] = json::ArrayValue; + json::Value stream = json::ValueType::Object; + stream[jss::accounts] = json::ValueType::Array; stream[jss::accounts].append(alice.human()); auto jv = wscAccount->invoke("subscribe", stream); @@ -1172,7 +1172,7 @@ public: // subscribe account tx history json::Value request; - request[jss::account_history_tx_stream] = json::ObjectValue; + request[jss::account_history_tx_stream] = json::ValueType::Object; request[jss::account_history_tx_stream][jss::account] = alice.human(); jv = wscTxHistory->invoke("subscribe", request); @@ -1236,7 +1236,7 @@ public: // subscribe json::Value request; - request[jss::account_history_tx_stream] = json::ObjectValue; + request[jss::account_history_tx_stream] = json::ValueType::Object; request[jss::account_history_tx_stream][jss::account] = carol.human(); auto ws = makeWSClient(env.app().config()); auto jv = ws->invoke("subscribe", request); @@ -1270,7 +1270,7 @@ public: // subscribe json::Value request; - request[jss::account_history_tx_stream] = json::ObjectValue; + request[jss::account_history_tx_stream] = json::ValueType::Object; request[jss::account_history_tx_stream][jss::account] = carol.human(); auto wscLong = makeWSClient(env.app().config()); auto jv = wscLong->invoke("subscribe", request); @@ -1324,7 +1324,7 @@ public: auto wsc = makeWSClient(env.app().config()); json::Value streams; - streams[jss::streams] = json::ArrayValue; + streams[jss::streams] = json::ValueType::Array; streams[jss::streams][0u] = "book_changes"; auto jv = wsc->invoke("subscribe", streams); @@ -1380,7 +1380,7 @@ public: auto wsc = test::makeWSClient(env.app().config()); json::Value stream; - stream[jss::streams] = json::ArrayValue; + stream[jss::streams] = json::ValueType::Array; stream[jss::streams].append("transactions"); auto jv = wsc->invoke("subscribe", stream); diff --git a/src/test/rpc/TransactionEntry_test.cpp b/src/test/rpc/TransactionEntry_test.cpp index ff0897f59a..c5f562b2b2 100644 --- a/src/test/rpc/TransactionEntry_test.cpp +++ b/src/test/rpc/TransactionEntry_test.cpp @@ -44,7 +44,7 @@ class TransactionEntry_test : public beast::unit_test::Suite } { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::ledger] = 20; auto const result = env.client().invoke("transaction_entry", params)[jss::result]; BEAST_EXPECT(result[jss::error] == "lgrNotFound"); @@ -52,7 +52,7 @@ class TransactionEntry_test : public beast::unit_test::Suite } { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::ledger] = "current"; params[jss::tx_hash] = "DEADBEEF"; auto const result = env.client().invoke("transaction_entry", params)[jss::result]; @@ -61,7 +61,7 @@ class TransactionEntry_test : public beast::unit_test::Suite } { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::ledger] = "closed"; params[jss::tx_hash] = "DEADBEEF"; auto const result = env.client().invoke("transaction_entry", params)[jss::result]; @@ -151,7 +151,7 @@ class TransactionEntry_test : public beast::unit_test::Suite std::string const closeTimeIso = "") { // first request using ledger_index to lookup json::Value const resIndex{[&env, index, &txhash, apiVersion]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::ledger_index] = index; params[jss::tx_hash] = txhash; params[jss::api_version] = apiVersion; @@ -206,7 +206,7 @@ class TransactionEntry_test : public beast::unit_test::Suite // second request using ledger_hash to lookup and verify // both responses match { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::ledger_hash] = resIndex[jss::ledger_hash]; params[jss::tx_hash] = txhash; params[jss::api_version] = apiVersion; diff --git a/src/test/rpc/TransactionHistory_test.cpp b/src/test/rpc/TransactionHistory_test.cpp index 8adf28fc9b..6227a1b75b 100644 --- a/src/test/rpc/TransactionHistory_test.cpp +++ b/src/test/rpc/TransactionHistory_test.cpp @@ -36,7 +36,7 @@ class TransactionHistory_test : public beast::unit_test::Suite { // test at 1 greater than the allowed non-admin limit - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::start] = 10001; // limited to <= 10000 for non admin auto const result = env.client().invoke("tx_history", params)[jss::result]; BEAST_EXPECT(result[jss::error] == "noPermission"); @@ -51,7 +51,7 @@ class TransactionHistory_test : public beast::unit_test::Suite using namespace test::jtx; Env env{*this, envconfig(noAdmin)}; - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::api_version] = 2; auto const result = env.client().invoke("tx_history", params)[jss::result]; BEAST_EXPECT(result[jss::error] == "unknownCmd"); @@ -86,7 +86,7 @@ class TransactionHistory_test : public beast::unit_test::Suite // verify the latest transaction in env (offer) // is available in tx_history. - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::start] = 0; auto result = env.client().invoke("tx_history", params)[jss::result]; if (!BEAST_EXPECT(result[jss::txs].isArray() && result[jss::txs].size() > 0)) @@ -94,7 +94,7 @@ class TransactionHistory_test : public beast::unit_test::Suite // search for a tx in history matching the last offer bool const txFound = [&] { - auto const toFind = env.tx()->getJson(JsonOptions::KNone); + auto const toFind = env.tx()->getJson(JsonOptions::Values::None); for (auto tx : result[jss::txs]) { tx.removeMember(jss::inLedger); @@ -113,7 +113,7 @@ class TransactionHistory_test : public beast::unit_test::Suite std::unordered_map typeCounts; while (start < 120) { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::start] = start; auto result = env.client().invoke("tx_history", params)[jss::result]; if (!BEAST_EXPECT(result[jss::txs].isArray() && result[jss::txs].size() > 0)) @@ -133,7 +133,7 @@ class TransactionHistory_test : public beast::unit_test::Suite // also, try a request with max non-admin start value { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::start] = 10000; // limited to <= 10000 for non admin auto const result = env.client().invoke("tx_history", params)[jss::result]; BEAST_EXPECT(result[jss::status] == "success"); diff --git a/src/test/rpc/Transaction_test.cpp b/src/test/rpc/Transaction_test.cpp index 8374abe445..47cc3687b0 100644 --- a/src/test/rpc/Transaction_test.cpp +++ b/src/test/rpc/Transaction_test.cpp @@ -697,7 +697,7 @@ class Transaction_test : public beast::unit_test::Suite json::Value params; params[jss::id] = 1; - auto const hash = env.tx()->getJson(JsonOptions::KNone)[jss::hash]; + auto const hash = env.tx()->getJson(JsonOptions::Values::None)[jss::hash]; params[jss::transaction] = hash; auto const jrr = env.rpc("json", "tx", to_string(params))[jss::result]; BEAST_EXPECT(jrr[jss::hash] == hash); @@ -771,7 +771,7 @@ class Transaction_test : public beast::unit_test::Suite std::shared_ptr const meta = env.closed()->txRead(env.tx()->getTransactionID()).second; - json::Value expected = txn->getJson(JsonOptions::KNone); + json::Value expected = txn->getJson(JsonOptions::Values::None); expected[jss::DeliverMax] = expected[jss::Amount]; if (apiVersion > 1) { @@ -780,7 +780,7 @@ class Transaction_test : public beast::unit_test::Suite } json::Value const result = {[&env, txn, apiVersion]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::transaction] = to_string(txn->getTransactionID()); params[jss::binary] = false; params[jss::api_version] = apiVersion; @@ -847,7 +847,7 @@ class Transaction_test : public beast::unit_test::Suite std::string const expectedMetaBlob = serializeHex(*meta); json::Value const result = [&env, txn, apiVersion]() { - json::Value params{json::ObjectValue}; + json::Value params{json::ValueType::Object}; params[jss::transaction] = to_string(txn->getTransactionID()); params[jss::binary] = true; params[jss::api_version] = apiVersion; diff --git a/src/test/rpc/Version_test.cpp b/src/test/rpc/Version_test.cpp index d465672aa7..0740672815 100644 --- a/src/test/rpc/Version_test.cpp +++ b/src/test/rpc/Version_test.cpp @@ -91,12 +91,12 @@ class Version_test : public beast::unit_test::Suite ? RPC::kAPI_INVALID_VERSION : RPC::kAPI_VERSION_IF_UNSPECIFIED; - json::Value const jArray = json::Value(json::ArrayValue); - json::Value const jNull = json::Value(json::NullValue); + json::Value const jArray = json::Value(json::ValueType::Array); + json::Value const jNull = json::Value(json::ValueType::Null); BEAST_EXPECT(RPC::getAPIVersionNumber(jArray, false) == versionIfUnspecified); BEAST_EXPECT(RPC::getAPIVersionNumber(jNull, false) == versionIfUnspecified); - json::Value jObject = json::Value(json::ObjectValue); + json::Value jObject = json::Value(json::ValueType::Object); BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == versionIfUnspecified); jObject[jss::api_version] = RPC::kAPI_VERSION_IF_UNSPECIFIED.value; BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == versionIfUnspecified); diff --git a/src/test/server/ServerStatus_test.cpp b/src/test/server/ServerStatus_test.cpp index 87f1d0e927..eba36462b6 100644 --- a/src/test/server/ServerStatus_test.cpp +++ b/src/test/server/ServerStatus_test.cpp @@ -246,14 +246,14 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En { json::Value jrr; - json::Value jp = json::ObjectValue; + json::Value jp = json::ValueType::Object; if (!user.empty()) { jp["admin_user"] = user; if (subobject) { // special case of bad password..passed as object - json::Value jpi = json::ObjectValue; + json::Value jpi = json::ValueType::Object; jpi["admin_password"] = password; jp["admin_password"] = jpi; } @@ -692,19 +692,19 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En auto sendAndParse = [&](std::string const& req) -> json::Value { ws.async_write_some(true, buffer(req), yield[ec]); if (!BEAST_EXPECT(!ec)) - return json::ObjectValue; + return json::ValueType::Object; boost::beast::multi_buffer sb; ws.async_read(sb, yield[ec]); if (!BEAST_EXPECT(!ec)) - return json::ObjectValue; + return json::ValueType::Object; json::Value resp; json::Reader jr; if (!BEAST_EXPECT(jr.parse( boost::lexical_cast(boost::beast::make_printable(sb.data())), resp))) - return json::ObjectValue; + return json::ValueType::Object; sb.consume(sb.size()); return resp; }; @@ -1021,7 +1021,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En { boost::beast::http::response resp; - json::Value jv(json::ArrayValue); + json::Value jv(json::ValueType::Array); jv.append("invalid"); doHTTPRequest(env, yield, false, resp, ec, to_string(jv)); BEAST_EXPECT(resp.result() == boost::beast::http::status::bad_request); @@ -1030,7 +1030,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En { boost::beast::http::response resp; - json::Value jv(json::ArrayValue); + json::Value jv(json::ValueType::Array); json::Value j; j["invalid"] = 1; jv.append(j); @@ -1053,7 +1053,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En boost::beast::http::response resp; json::Value jv; jv[jss::method] = "batch"; - jv[jss::params] = json::ObjectValue; + jv[jss::params] = json::ValueType::Object; jv[jss::params]["invalid"] = 3; doHTTPRequest(env, yield, false, resp, ec, to_string(jv)); BEAST_EXPECT(resp.result() == boost::beast::http::status::bad_request); @@ -1063,7 +1063,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En json::Value jv; { boost::beast::http::response resp; - jv[jss::method] = json::NullValue; + jv[jss::method] = json::ValueType::Null; doHTTPRequest(env, yield, false, resp, ec, to_string(jv)); BEAST_EXPECT(resp.result() == boost::beast::http::status::bad_request); BEAST_EXPECT(resp.body() == "Null method\r\n"); @@ -1096,7 +1096,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En { boost::beast::http::response resp; - jv[jss::params] = json::ArrayValue; + jv[jss::params] = json::ValueType::Array; jv[jss::params][0u] = "not an object"; doHTTPRequest(env, yield, false, resp, ec, to_string(jv)); BEAST_EXPECT(resp.result() == boost::beast::http::status::bad_request); diff --git a/src/test/server/Server_test.cpp b/src/test/server/Server_test.cpp index 3bddf489d6..1dc40f6337 100644 --- a/src/test/server/Server_test.cpp +++ b/src/test/server/Server_test.cpp @@ -81,12 +81,12 @@ public: public: explicit TestSink(beast::unit_test::Suite& suite) - : Sink(beast::severities::KWarning, false), suite_(suite) + : Sink(beast::Severity::Warning, false), suite_(suite) { } void - write(beast::severities::Severity level, std::string const& text) override + write(beast::Severity level, std::string const& text) override { if (level < threshold()) return; @@ -95,7 +95,7 @@ public: } void - writeAlways(beast::severities::Severity level, std::string const& text) override + writeAlways(beast::Severity level, std::string const& text) override { suite_.log << text << std::endl; } @@ -295,7 +295,7 @@ public: testcase("Basic client/server"); TestSink sink{*this}; TestThread thread; - sink.threshold(beast::severities::Severity::KAll); + sink.threshold(beast::Severity::All); beast::Journal const journal{sink}; TestHandler handler; auto s = makeServer(handler, thread.getIoContext(), journal); @@ -365,7 +365,7 @@ public: } }; - using namespace beast::severities; + using beast::Severity; SuiteJournal journal("Server_test", *this); NullHandler h; diff --git a/src/test/shamap/FetchPack_test.cpp b/src/test/shamap/FetchPack_test.cpp index 85cccfd6ab..31cb62daad 100644 --- a/src/test/shamap/FetchPack_test.cpp +++ b/src/test/shamap/FetchPack_test.cpp @@ -33,9 +33,8 @@ namespace xrpl::tests { class FetchPack_test : public beast::unit_test::Suite { public: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { TableItems = 100, TableItemsExtra = 20 }; + static constexpr auto kTABLE_ITEMS = 100; + static constexpr auto kTABLE_ITEMS_EXTRA = 20; using Map = hash_map; using Table = SHAMap; @@ -105,14 +104,14 @@ public: void onFetch(Map& map, SHAMapHash const& hash, Blob const& blob) { - BEAST_EXPECT(sha512Half(makeSlice(blob)) == hash.asUint256()); + BEAST_EXPECT(sha512Half(makeSlice(blob)) == hash.asUInt256()); map.emplace(hash, blob); } void run() override { - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("FetchPack_test", *this); TestNodeFamily f(journal); diff --git a/src/test/shamap/SHAMapSync_test.cpp b/src/test/shamap/SHAMapSync_test.cpp index 18ab73fc96..9e9a490977 100644 --- a/src/test/shamap/SHAMapSync_test.cpp +++ b/src/test/shamap/SHAMapSync_test.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -83,7 +84,7 @@ public: void run() override { - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("SHAMapSync_test", *this); TestNodeFamily f(journal), f2(journal); diff --git a/src/test/shamap/SHAMap_test.cpp b/src/test/shamap/SHAMap_test.cpp index 37def20f81..3b31459d8b 100644 --- a/src/test/shamap/SHAMap_test.cpp +++ b/src/test/shamap/SHAMap_test.cpp @@ -114,7 +114,7 @@ public: void run() override { - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("SHAMap_test", *this); run(true, journal); @@ -283,12 +283,12 @@ public: { BEAST_EXPECT(map.addItem( SHAMapNodeType::TnTransactionNm, makeShamapitem(kEYS[k], intToVuc(k)))); - BEAST_EXPECT(map.getHash().asUint256() == kHASHES[k]); + BEAST_EXPECT(map.getHash().asUInt256() == kHASHES[k]); map.invariants(); } for (int k = kEYS.size() - 1; k >= 0; --k) { - BEAST_EXPECT(map.getHash().asUint256() == kHASHES[k]); + BEAST_EXPECT(map.getHash().asUInt256() == kHASHES[k]); BEAST_EXPECT(map.delItem(kEYS[k])); map.invariants(); } @@ -373,7 +373,7 @@ class SHAMapPathProof_test : public beast::unit_test::Suite SHAMapNodeType::TnAccountState, makeShamapitem(k, Slice{k.data(), k.size()})); map.invariants(); - auto root = map.getHash().asUint256(); + auto root = map.getHash().asUInt256(); auto path = map.getProofPath(k); BEAST_EXPECT(path); if (!path) diff --git a/src/test/unit_test/SuiteJournal.h b/src/test/unit_test/SuiteJournal.h index 32b085ffe6..2ae8fd22a8 100644 --- a/src/test/unit_test/SuiteJournal.h +++ b/src/test/unit_test/SuiteJournal.h @@ -14,7 +14,7 @@ class SuiteJournalSink : public beast::Journal::Sink public: SuiteJournalSink( std::string const& partition, - beast::severities::Severity threshold, + beast::Severity threshold, beast::unit_test::Suite& suite) : Sink(threshold, false), partition_(partition + " "), suite_(suite) { @@ -22,20 +22,20 @@ public: // For unit testing, always generate logging text. [[nodiscard]] bool - active(beast::severities::Severity level) const override + active(beast::Severity level) const override { return true; } void - write(beast::severities::Severity level, std::string const& text) override; + write(beast::Severity level, std::string const& text) override; void - writeAlways(beast::severities::Severity level, std::string const& text) override; + writeAlways(beast::Severity level, std::string const& text) override; }; inline void -SuiteJournalSink::write(beast::severities::Severity level, std::string const& text) +SuiteJournalSink::write(beast::Severity level, std::string const& text) { // Only write the string if the level at least equals the threshold. if (level >= threshold()) @@ -43,26 +43,26 @@ SuiteJournalSink::write(beast::severities::Severity level, std::string const& te } inline void -SuiteJournalSink::writeAlways(beast::severities::Severity level, std::string const& text) +SuiteJournalSink::writeAlways(beast::Severity level, std::string const& text) { - using namespace beast::severities; + using beast::Severity; char const* const s = [level]() { switch (level) { - case KTrace: + case Severity::Trace: return "TRC:"; - case KDebug: + case Severity::Debug: return "DBG:"; - case KInfo: + case Severity::Info: return "INF:"; - case KWarning: + case Severity::Warning: return "WRN:"; - case KError: + case Severity::Error: return "ERR:"; default: break; - case KFatal: + case Severity::Fatal: break; } return "FTL:"; @@ -82,7 +82,7 @@ public: SuiteJournal( std::string const& partition, beast::unit_test::Suite& suite, - beast::severities::Severity threshold = beast::severities::KFatal) + beast::Severity threshold = beast::Severity::Fatal) : sink_(partition, threshold, suite), journal_(sink_) { } @@ -100,13 +100,12 @@ class StreamSink : public beast::Journal::Sink std::stringstream strm_; public: - StreamSink(beast::severities::Severity threshold = beast::severities::KDebug) - : Sink(threshold, false) + StreamSink(beast::Severity threshold = beast::Severity::Debug) : Sink(threshold, false) { } void - write(beast::severities::Severity level, std::string const& text) override + write(beast::Severity level, std::string const& text) override { if (level < threshold()) return; @@ -114,7 +113,7 @@ public: } void - writeAlways(beast::severities::Severity level, std::string const& text) override + writeAlways(beast::Severity level, std::string const& text) override { strm_ << text << std::endl; } diff --git a/src/test/unit_test/multi_runner.cpp b/src/test/unit_test/multi_runner.cpp index 86c075caf2..d21b7acc48 100644 --- a/src/test/unit_test/multi_runner.cpp +++ b/src/test/unit_test/multi_runner.cpp @@ -75,19 +75,19 @@ Results::add(SuiteResults const& r) if (iter != top.end()) { - if (top.size() == MaxTop && iter == top.end() - 1) + if (top.size() == kMAX_TOP && iter == top.end() - 1) { // avoid invalidating the iterator *iter = run_time{static_string{static_string::string_view_type{r.name}}, elapsed}; } else { - if (top.size() == MaxTop) + if (top.size() == kMAX_TOP) top.resize(top.size() - 1); top.emplace(iter, static_string{static_string::string_view_type{r.name}}, elapsed); } } - else if (top.size() < MaxTop) + else if (top.size() < kMAX_TOP) { top.emplace_back(static_string{static_string::string_view_type{r.name}}, elapsed); } @@ -103,14 +103,14 @@ Results::merge(Results const& r) failed += r.failed; // combine the two top collections - boost::container::static_vector topResult; + boost::container::static_vector topResult; topResult.resize(top.size() + r.top.size()); std::ranges::merge(top, r.top, topResult.begin(), [](run_time const& t1, run_time const& t2) { return t1.second > t2.second; }); - if (topResult.size() > MaxTop) - topResult.resize(MaxTop); + if (topResult.size() > kMAX_TOP) + topResult.resize(kMAX_TOP); top = topResult; } diff --git a/src/test/unit_test/multi_runner.h b/src/test/unit_test/multi_runner.h index 9c83c29141..241f9630f6 100644 --- a/src/test/unit_test/multi_runner.h +++ b/src/test/unit_test/multi_runner.h @@ -59,15 +59,13 @@ struct Results // pointers from different memory spaces do not co-mingle using run_time = std::pair; - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { MaxTop = 10 }; + static constexpr auto kMAX_TOP = 10; std::size_t suites = 0; std::size_t cases = 0; std::size_t total = 0; std::size_t failed = 0; - boost::container::static_vector top; + boost::container::static_vector top; typename clock_type::time_point start = clock_type::now(); void diff --git a/src/tests/libxrpl/basics/MallocTrim.cpp b/src/tests/libxrpl/basics/MallocTrim.cpp index b8e2c9fd30..6ac8957f0e 100644 --- a/src/tests/libxrpl/basics/MallocTrim.cpp +++ b/src/tests/libxrpl/basics/MallocTrim.cpp @@ -161,15 +161,15 @@ TEST(mallocTrim, with_debug_logging) { struct DebugSink : public beast::Journal::Sink { - DebugSink() : Sink(beast::severities::KDebug, false) + DebugSink() : Sink(beast::Severity::Debug, false) { } void - write(beast::severities::Severity, std::string const&) override + write(beast::Severity, std::string const&) override { } void - writeAlways(beast::severities::Severity, std::string const&) override + writeAlways(beast::Severity, std::string const&) override { } }; diff --git a/src/tests/libxrpl/helpers/TestServiceRegistry.h b/src/tests/libxrpl/helpers/TestServiceRegistry.h index bb92a71e5d..7070927842 100644 --- a/src/tests/libxrpl/helpers/TestServiceRegistry.h +++ b/src/tests/libxrpl/helpers/TestServiceRegistry.h @@ -23,12 +23,12 @@ namespace test { class TestLogs : public Logs { public: - explicit TestLogs(beast::severities::Severity level = beast::severities::KWarning) : Logs(level) + explicit TestLogs(beast::Severity level = beast::Severity::Warning) : Logs(level) { } std::unique_ptr - makeSink(std::string const&, beast::severities::Severity threshold) override + makeSink(std::string const&, beast::Severity threshold) override { return std::make_unique(threshold); } @@ -62,7 +62,7 @@ private: */ class TestServiceRegistry : public ServiceRegistry { - TestLogs logs_{beast::severities::KWarning}; + TestLogs logs_{beast::Severity::Warning}; boost::asio::io_context io_context_; TestFamily family_{logs_.journal("TestFamily")}; LoadFeeTrack feeTrack_{logs_.journal("LoadFeeTrack")}; diff --git a/src/tests/libxrpl/helpers/TestSink.cpp b/src/tests/libxrpl/helpers/TestSink.cpp index 403fd23392..af2c4bb280 100644 --- a/src/tests/libxrpl/helpers/TestSink.cpp +++ b/src/tests/libxrpl/helpers/TestSink.cpp @@ -18,12 +18,12 @@ namespace xrpl { -TestSink::TestSink(beast::severities::Severity threshold) : Sink(threshold, false) +TestSink::TestSink(beast::Severity threshold) : Sink(threshold, false) { } void -TestSink::write(beast::severities::Severity level, std::string const& text) +TestSink::write(beast::Severity level, std::string const& text) { if (level < threshold()) return; @@ -31,7 +31,7 @@ TestSink::write(beast::severities::Severity level, std::string const& text) } void -TestSink::writeAlways(beast::severities::Severity level, std::string const& text) +TestSink::writeAlways(beast::Severity level, std::string const& text) { auto supportsColor = [] { // 1. Check for "NO_COLOR" environment variable (Standard convention) @@ -64,17 +64,17 @@ TestSink::writeAlways(beast::severities::Severity level, std::string const& text auto color = [level]() { switch (level) { - case beast::severities::KTrace: + case beast::Severity::Trace: return "\033[34m"; // blue - case beast::severities::KDebug: + case beast::Severity::Debug: return "\033[32m"; // green - case beast::severities::KInfo: + case beast::Severity::Info: return "\033[36m"; // cyan - case beast::severities::KWarning: + case beast::Severity::Warning: return "\033[33m"; // yellow - case beast::severities::KError: + case beast::Severity::Error: return "\033[31m"; // red - case beast::severities::KFatal: + case beast::Severity::Fatal: default: break; } @@ -84,17 +84,17 @@ TestSink::writeAlways(beast::severities::Severity level, std::string const& text auto prefix = [level]() { switch (level) { - case beast::severities::KTrace: + case beast::Severity::Trace: return "TRC:"; - case beast::severities::KDebug: + case beast::Severity::Debug: return "DBG:"; - case beast::severities::KInfo: + case beast::Severity::Info: return "INF:"; - case beast::severities::KWarning: + case beast::Severity::Warning: return "WRN:"; - case beast::severities::KError: + case beast::Severity::Error: return "ERR:"; - case beast::severities::KFatal: + case beast::Severity::Fatal: default: break; } @@ -104,8 +104,8 @@ TestSink::writeAlways(beast::severities::Severity level, std::string const& text auto& stream = [level]() -> std::ostream& { switch (level) { - case beast::severities::KError: - case beast::severities::KFatal: + case beast::Severity::Error: + case beast::Severity::Fatal: return std::cerr; default: return std::cout; diff --git a/src/tests/libxrpl/helpers/TestSink.h b/src/tests/libxrpl/helpers/TestSink.h index a96000b04f..28c85f00e4 100644 --- a/src/tests/libxrpl/helpers/TestSink.h +++ b/src/tests/libxrpl/helpers/TestSink.h @@ -13,12 +13,12 @@ public: return sink; } - TestSink(beast::severities::Severity threshold = beast::severities::KDebug); + TestSink(beast::Severity threshold = beast::Severity::Debug); void - write(beast::severities::Severity level, std::string const& text) override; + write(beast::Severity level, std::string const& text) override; void - writeAlways(beast::severities::Severity level, std::string const& text) override; + writeAlways(beast::Severity level, std::string const& text) override; }; } // namespace xrpl diff --git a/src/tests/libxrpl/json/Value.cpp b/src/tests/libxrpl/json/Value.cpp index 994491b4db..809c2cf559 100644 --- a/src/tests/libxrpl/json/Value.cpp +++ b/src/tests/libxrpl/json/Value.cpp @@ -25,7 +25,7 @@ TEST(json_value, limits) using namespace json; static_assert(Value::kMIN_INT == Int(~(UInt(-1) / 2))); static_assert(Value::kMAX_INT == Int(UInt(-1) / 2)); - static_assert(Value::kMAX_U_INT == UInt(-1)); + static_assert(Value::kMAX_UINT == UInt(-1)); } TEST(json_value, construct_and_compare_Json_StaticString) @@ -64,7 +64,7 @@ TEST(json_value, different_types) return val; }; { - json::Value const nullV{testCopy(json::NullValue)}; + json::Value const nullV{testCopy(json::ValueType::Null)}; EXPECT_TRUE(nullV.isNull()); EXPECT_FALSE(nullV.isBool()); EXPECT_FALSE(nullV.isInt()); @@ -79,7 +79,7 @@ TEST(json_value, different_types) EXPECT_TRUE(nullV.isObjectOrNull()); } { - json::Value const intV{testCopy(json::IntValue)}; + json::Value const intV{testCopy(json::ValueType::Int)}; EXPECT_FALSE(intV.isNull()); EXPECT_FALSE(intV.isBool()); EXPECT_TRUE(intV.isInt()); @@ -94,7 +94,7 @@ TEST(json_value, different_types) EXPECT_FALSE(intV.isObjectOrNull()); } { - json::Value const uintV{testCopy(json::UintValue)}; + json::Value const uintV{testCopy(json::ValueType::UInt)}; EXPECT_FALSE(uintV.isNull()); EXPECT_FALSE(uintV.isBool()); EXPECT_FALSE(uintV.isInt()); @@ -109,7 +109,7 @@ TEST(json_value, different_types) EXPECT_FALSE(uintV.isObjectOrNull()); } { - json::Value const realV{testCopy(json::RealValue)}; + json::Value const realV{testCopy(json::ValueType::Real)}; EXPECT_FALSE(realV.isNull()); EXPECT_FALSE(realV.isBool()); EXPECT_FALSE(realV.isInt()); @@ -124,7 +124,7 @@ TEST(json_value, different_types) EXPECT_FALSE(realV.isObjectOrNull()); } { - json::Value const stringV{testCopy(json::StringValue)}; + json::Value const stringV{testCopy(json::ValueType::String)}; EXPECT_FALSE(stringV.isNull()); EXPECT_FALSE(stringV.isBool()); EXPECT_FALSE(stringV.isInt()); @@ -142,8 +142,8 @@ TEST(json_value, different_types) json::Value const staticStrV{kSTATIC_STR}; { json::Value const cpy{staticStrV}; - EXPECT_EQ(staticStrV.type(), json::StringValue); - EXPECT_EQ(cpy.type(), json::StringValue); + EXPECT_EQ(staticStrV.type(), json::ValueType::String); + EXPECT_EQ(cpy.type(), json::ValueType::String); } EXPECT_FALSE(staticStrV.isNull()); EXPECT_FALSE(staticStrV.isBool()); @@ -159,7 +159,7 @@ TEST(json_value, different_types) EXPECT_FALSE(staticStrV.isObjectOrNull()); } { - json::Value const boolV{testCopy(json::BooleanValue)}; + json::Value const boolV{testCopy(json::ValueType::Boolean)}; EXPECT_FALSE(boolV.isNull()); EXPECT_TRUE(boolV.isBool()); EXPECT_FALSE(boolV.isInt()); @@ -174,7 +174,7 @@ TEST(json_value, different_types) EXPECT_FALSE(boolV.isObjectOrNull()); } { - json::Value const arrayV{testCopy(json::ArrayValue)}; + json::Value const arrayV{testCopy(json::ValueType::Array)}; EXPECT_FALSE(arrayV.isNull()); EXPECT_FALSE(arrayV.isBool()); EXPECT_FALSE(arrayV.isInt()); @@ -189,7 +189,7 @@ TEST(json_value, different_types) EXPECT_FALSE(arrayV.isObjectOrNull()); } { - json::Value const objectV{testCopy(json::ObjectValue)}; + json::Value const objectV{testCopy(json::ValueType::Object)}; EXPECT_FALSE(objectV.isNull()); EXPECT_FALSE(objectV.isBool()); EXPECT_FALSE(objectV.isInt()); @@ -223,24 +223,24 @@ TEST(json_value, compare_strings) json::Value const null0; json::Value const intNeg1{-1}; - json::Value const int0{json::IntValue}; + json::Value const int0{json::ValueType::Int}; json::Value const intPos1{1}; - json::Value const uint0{json::UintValue}; + json::Value const uint0{json::ValueType::UInt}; json::Value const uint1{1u}; json::Value const realNeg1{-1.0}; - json::Value const real0{json::RealValue}; + json::Value const real0{json::ValueType::Real}; json::Value const realPos1{1.0}; - json::Value const str0{json::StringValue}; + json::Value const str0{json::ValueType::String}; json::Value const str1{"1"}; json::Value const boolF{false}; json::Value const boolT{true}; - json::Value const array0{json::ArrayValue}; + json::Value const array0{json::ValueType::Array}; json::Value const array1{[]() { json::Value array1; array1[0u] = 1; return array1; }()}; - json::Value const obj0{json::ObjectValue}; + json::Value const obj0{json::ValueType::Object}; json::Value const obj1{[]() { json::Value obj1; obj1["one"] = 1; @@ -571,12 +571,12 @@ TEST(json_value, bool) EXPECT_TRUE(bool(json::Value(0))); EXPECT_TRUE(bool(json::Value(1))); - json::Value array(json::ArrayValue); + json::Value array(json::ValueType::Array); EXPECT_FALSE(array); array.append(0); EXPECT_TRUE(bool(array)); - json::Value object(json::ObjectValue); + json::Value object(json::ValueType::Object); EXPECT_FALSE(object); object[""] = false; EXPECT_TRUE(bool(object)); @@ -594,19 +594,19 @@ TEST(json_value, bad_json) TEST(json_value, edge_cases) { - std::uint32_t const maxUint = std::numeric_limits::max(); + std::uint32_t const maxUInt = std::numeric_limits::max(); std::int32_t const maxInt = std::numeric_limits::max(); std::int32_t const minInt = std::numeric_limits::min(); - std::uint32_t const aUint = maxUint - 1978; + std::uint32_t const aUInt = maxUInt - 1978; std::int32_t const aLargeInt = maxInt - 1978; std::int32_t const aSmallInt = minInt + 1978; { - std::string json = "{\"max_uint\":" + std::to_string(maxUint); + std::string json = "{\"max_uint\":" + std::to_string(maxUInt); json += ",\"max_int\":" + std::to_string(maxInt); json += ",\"min_int\":" + std::to_string(minInt); - json += ",\"a_uint\":" + std::to_string(aUint); + json += ",\"a_uint\":" + std::to_string(aUInt); json += ",\"a_large_int\":" + std::to_string(aLargeInt); json += ",\"a_small_int\":" + std::to_string(aSmallInt); json += "}"; @@ -615,26 +615,26 @@ TEST(json_value, edge_cases) json::Reader r1; EXPECT_TRUE(r1.parse(json, j1)); - EXPECT_EQ(j1["max_uint"].asUInt(), maxUint); - EXPECT_EQ(j1["max_uint"].asAbsUInt(), maxUint); + EXPECT_EQ(j1["max_uint"].asUInt(), maxUInt); + EXPECT_EQ(j1["max_uint"].asAbsUInt(), maxUInt); EXPECT_EQ(j1["max_int"].asInt(), maxInt); EXPECT_EQ(j1["max_int"].asAbsUInt(), maxInt); EXPECT_EQ(j1["min_int"].asInt(), minInt); EXPECT_EQ(j1["min_int"].asAbsUInt(), static_cast(minInt) * -1); - EXPECT_EQ(j1["a_uint"].asUInt(), aUint); - EXPECT_EQ(j1["a_uint"].asAbsUInt(), aUint); + EXPECT_EQ(j1["a_uint"].asUInt(), aUInt); + EXPECT_EQ(j1["a_uint"].asAbsUInt(), aUInt); EXPECT_GT(j1["a_uint"], aLargeInt); EXPECT_GT(j1["a_uint"], aSmallInt); EXPECT_EQ(j1["a_large_int"].asInt(), aLargeInt); EXPECT_EQ(j1["a_large_int"].asAbsUInt(), aLargeInt); EXPECT_EQ(j1["a_large_int"].asUInt(), aLargeInt); - EXPECT_LT(j1["a_large_int"], aUint); + EXPECT_LT(j1["a_large_int"], aUInt); EXPECT_EQ(j1["a_small_int"].asInt(), aSmallInt); EXPECT_EQ(j1["a_small_int"].asAbsUInt(), static_cast(aSmallInt) * -1); - EXPECT_LT(j1["a_small_int"], aUint); + EXPECT_LT(j1["a_small_int"], aUInt); } - std::uint64_t const overflow = std::uint64_t(maxUint) + 1; + std::uint64_t const overflow = std::uint64_t(maxUInt) + 1; { std::string json = "{\"overflow\":"; json += std::to_string(overflow); @@ -859,9 +859,7 @@ TEST(json_value, compact) TEST(json_value, conversions) { - // We have json::Int, but not json::Double or json::Real. - // We have json::Int, json::Value::Int, and json::ValueType::intValue. - // We have json::ValueType::realValue but json::Value::asDouble. + // We have json::ValueType::Real but json::Value::asDouble. // TODO: What's the thinking here? { // null @@ -875,14 +873,14 @@ TEST(json_value, conversions) EXPECT_EQ(val.asDouble(), 0.0); EXPECT_FALSE(val.asBool()); - EXPECT_TRUE(val.isConvertibleTo(json::NullValue)); - EXPECT_TRUE(val.isConvertibleTo(json::IntValue)); - EXPECT_TRUE(val.isConvertibleTo(json::UintValue)); - EXPECT_TRUE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_TRUE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_TRUE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Object)); } { // int @@ -896,14 +894,14 @@ TEST(json_value, conversions) EXPECT_EQ(val.asDouble(), -1234.0); EXPECT_TRUE(val.asBool()); - EXPECT_FALSE(val.isConvertibleTo(json::NullValue)); - EXPECT_TRUE(val.isConvertibleTo(json::IntValue)); - EXPECT_FALSE(val.isConvertibleTo(json::UintValue)); - EXPECT_TRUE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // uint @@ -917,14 +915,14 @@ TEST(json_value, conversions) EXPECT_EQ(val.asDouble(), 1234.0); EXPECT_TRUE(val.asBool()); - EXPECT_FALSE(val.isConvertibleTo(json::NullValue)); - EXPECT_TRUE(val.isConvertibleTo(json::IntValue)); - EXPECT_TRUE(val.isConvertibleTo(json::UintValue)); - EXPECT_TRUE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // real @@ -938,14 +936,14 @@ TEST(json_value, conversions) EXPECT_EQ(val.asDouble(), 2.0); EXPECT_TRUE(val.asBool()); - EXPECT_FALSE(val.isConvertibleTo(json::NullValue)); - EXPECT_TRUE(val.isConvertibleTo(json::IntValue)); - EXPECT_TRUE(val.isConvertibleTo(json::UintValue)); - EXPECT_TRUE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // numeric string @@ -959,18 +957,18 @@ TEST(json_value, conversions) EXPECT_THROW([&] { return val.asDouble(); }(), json::Error); EXPECT_TRUE(val.asBool()); - EXPECT_FALSE(val.isConvertibleTo(json::NullValue)); - EXPECT_FALSE(val.isConvertibleTo(json::IntValue)); - EXPECT_FALSE(val.isConvertibleTo(json::UintValue)); - EXPECT_FALSE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // non-numeric string - json::Value const val(json::StringValue); + json::Value const val(json::ValueType::String); EXPECT_TRUE(val.isString()); EXPECT_EQ(val.asCString(), nullptr); EXPECT_EQ(val.asString(), ""); @@ -980,14 +978,14 @@ TEST(json_value, conversions) EXPECT_THROW([&] { return val.asDouble(); }(), std::exception); EXPECT_TRUE(val.asBool() == false); - EXPECT_TRUE(val.isConvertibleTo(json::NullValue)); - EXPECT_FALSE(val.isConvertibleTo(json::IntValue)); - EXPECT_FALSE(val.isConvertibleTo(json::UintValue)); - EXPECT_FALSE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // bool false @@ -1001,14 +999,14 @@ TEST(json_value, conversions) EXPECT_EQ(val.asDouble(), 0.0); EXPECT_FALSE(val.asBool()); - EXPECT_TRUE(val.isConvertibleTo(json::NullValue)); - EXPECT_TRUE(val.isConvertibleTo(json::IntValue)); - EXPECT_TRUE(val.isConvertibleTo(json::UintValue)); - EXPECT_TRUE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // bool true @@ -1022,18 +1020,18 @@ TEST(json_value, conversions) EXPECT_EQ(val.asDouble(), 1.0); EXPECT_TRUE(val.asBool()); - EXPECT_FALSE(val.isConvertibleTo(json::NullValue)); - EXPECT_TRUE(val.isConvertibleTo(json::IntValue)); - EXPECT_TRUE(val.isConvertibleTo(json::UintValue)); - EXPECT_TRUE(val.isConvertibleTo(json::RealValue)); - EXPECT_TRUE(val.isConvertibleTo(json::StringValue)); - EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // array type - json::Value const val(json::ArrayValue); + json::Value const val(json::ValueType::Array); EXPECT_TRUE(val.isArray()); // val.asCString should trigger an assertion failure EXPECT_THROW([&] { return val.asString(); }(), json::Error); @@ -1043,18 +1041,18 @@ TEST(json_value, conversions) EXPECT_THROW([&] { return val.asDouble(); }(), json::Error); EXPECT_FALSE(val.asBool()); // empty or not - EXPECT_TRUE(val.isConvertibleTo(json::NullValue)); - EXPECT_FALSE(val.isConvertibleTo(json::IntValue)); - EXPECT_FALSE(val.isConvertibleTo(json::UintValue)); - EXPECT_FALSE(val.isConvertibleTo(json::RealValue)); - EXPECT_FALSE(val.isConvertibleTo(json::StringValue)); - EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_TRUE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object)); } { // object type - json::Value const val(json::ObjectValue); + json::Value const val(json::ValueType::Object); EXPECT_TRUE(val.isObject()); // val.asCString should trigger an assertion failure EXPECT_THROW([&] { return val.asString(); }(), json::Error); @@ -1064,29 +1062,29 @@ TEST(json_value, conversions) EXPECT_THROW([&] { return val.asDouble(); }(), json::Error); EXPECT_FALSE(val.asBool()); // empty or not - EXPECT_TRUE(val.isConvertibleTo(json::NullValue)); - EXPECT_FALSE(val.isConvertibleTo(json::IntValue)); - EXPECT_FALSE(val.isConvertibleTo(json::UintValue)); - EXPECT_FALSE(val.isConvertibleTo(json::RealValue)); - EXPECT_FALSE(val.isConvertibleTo(json::StringValue)); - EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue)); - EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue)); - EXPECT_TRUE(val.isConvertibleTo(json::ObjectValue)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::String)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean)); + EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array)); + EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Object)); } } TEST(json_value, access_members) { json::Value val; - EXPECT_EQ(val.type(), json::NullValue); + EXPECT_EQ(val.type(), json::ValueType::Null); EXPECT_EQ(val.size(), 0); EXPECT_FALSE(val.isValidIndex(0)); EXPECT_FALSE(val.isMember("key")); { json::Value const constVal = val; - EXPECT_EQ(constVal[7u].type(), json::NullValue); + EXPECT_EQ(constVal[7u].type(), json::ValueType::Null); EXPECT_FALSE(constVal.isMember("key")); - EXPECT_EQ(constVal["key"].type(), json::NullValue); + EXPECT_EQ(constVal["key"].type(), json::ValueType::Null); EXPECT_TRUE(constVal.getMemberNames().empty()); EXPECT_EQ(constVal.get(1u, "default0"), "default0"); EXPECT_EQ(constVal.get(std::string("not"), "oh"), "oh"); @@ -1094,37 +1092,37 @@ TEST(json_value, access_members) } val = -7; - EXPECT_EQ(val.type(), json::IntValue); + EXPECT_EQ(val.type(), json::ValueType::Int); EXPECT_EQ(val.size(), 0); EXPECT_FALSE(val.isValidIndex(0)); EXPECT_FALSE(val.isMember("key")); val = 42u; - EXPECT_EQ(val.type(), json::UintValue); + EXPECT_EQ(val.type(), json::ValueType::UInt); EXPECT_EQ(val.size(), 0); EXPECT_FALSE(val.isValidIndex(0)); EXPECT_FALSE(val.isMember("key")); val = std::numbers::pi; - EXPECT_EQ(val.type(), json::RealValue); + EXPECT_EQ(val.type(), json::ValueType::Real); EXPECT_EQ(val.size(), 0); EXPECT_FALSE(val.isValidIndex(0)); EXPECT_FALSE(val.isMember("key")); val = true; - EXPECT_EQ(val.type(), json::BooleanValue); + EXPECT_EQ(val.type(), json::ValueType::Boolean); EXPECT_EQ(val.size(), 0); EXPECT_FALSE(val.isValidIndex(0)); EXPECT_FALSE(val.isMember("key")); val = "string"; - EXPECT_EQ(val.type(), json::StringValue); + EXPECT_EQ(val.type(), json::ValueType::String); EXPECT_EQ(val.size(), 0); EXPECT_FALSE(val.isValidIndex(0)); EXPECT_FALSE(val.isMember("key")); - val = json::Value(json::ObjectValue); - EXPECT_EQ(val.type(), json::ObjectValue); + val = json::Value(json::ValueType::Object); + EXPECT_EQ(val.type(), json::ValueType::Object); EXPECT_EQ(val.size(), 0); static json::StaticString const kSTATIC_THREE("three"); val[kSTATIC_THREE] = 3; @@ -1139,7 +1137,7 @@ TEST(json_value, access_members) { json::Value const constVal = val; EXPECT_EQ(constVal["two"], 2); - EXPECT_EQ(constVal["four"].type(), json::NullValue); + EXPECT_EQ(constVal["four"].type(), json::ValueType::Null); EXPECT_EQ(constVal[kSTATIC_THREE], 3); EXPECT_TRUE(constVal.isMember("two")); EXPECT_TRUE(constVal.isMember(kSTATIC_THREE)); @@ -1148,20 +1146,20 @@ TEST(json_value, access_members) EXPECT_EQ(val.get("missing", "default2"), "default2"); } - val = json::Value(json::ArrayValue); - EXPECT_EQ(val.type(), json::ArrayValue); + val = json::Value(json::ValueType::Array); + EXPECT_EQ(val.type(), json::ValueType::Array); EXPECT_EQ(val.size(), 0); val[0u] = "zero"; val[1u] = "one"; EXPECT_EQ(val.size(), 2); EXPECT_TRUE(val.isValidIndex(1)); EXPECT_FALSE(val.isValidIndex(2)); - EXPECT_EQ(val[20u].type(), json::NullValue); + EXPECT_EQ(val[20u].type(), json::ValueType::Null); EXPECT_FALSE(val.isMember("key")); { json::Value const constVal = val; EXPECT_EQ(constVal[0u], "zero"); - EXPECT_EQ(constVal[2u].type(), json::NullValue); + EXPECT_EQ(constVal[2u].type(), json::ValueType::Null); EXPECT_FALSE(constVal.isMember("key")); EXPECT_EQ(val.get(1u, "default0"), "one"); EXPECT_EQ(val.get(3u, "default1"), "default1"); @@ -1171,27 +1169,27 @@ TEST(json_value, access_members) TEST(json_value, remove_members) { json::Value val; - EXPECT_EQ(val.removeMember(std::string("member")).type(), json::NullValue); + EXPECT_EQ(val.removeMember(std::string("member")).type(), json::ValueType::Null); - val = json::Value(json::ObjectValue); + val = json::Value(json::ValueType::Object); static json::StaticString const kSTATIC_THREE("three"); val[kSTATIC_THREE] = 3; val["two"] = 2; EXPECT_EQ(val.size(), 2); - EXPECT_EQ(val.removeMember(std::string("six")).type(), json::NullValue); + EXPECT_EQ(val.removeMember(std::string("six")).type(), json::ValueType::Null); EXPECT_EQ(val.size(), 2); EXPECT_EQ(val.removeMember(kSTATIC_THREE), 3); EXPECT_EQ(val.size(), 1); - EXPECT_EQ(val.removeMember(kSTATIC_THREE).type(), json::NullValue); + EXPECT_EQ(val.removeMember(kSTATIC_THREE).type(), json::ValueType::Null); EXPECT_EQ(val.size(), 1); EXPECT_EQ(val.removeMember(std::string("two")), 2); EXPECT_EQ(val.size(), 0); - EXPECT_EQ(val.removeMember(std::string("two")).type(), json::NullValue); + EXPECT_EQ(val.removeMember(std::string("two")).type(), json::ValueType::Null); EXPECT_EQ(val.size(), 0); } @@ -1199,7 +1197,7 @@ TEST(json_value, iterator) { { // Iterating an array. - json::Value arr{json::ArrayValue}; + json::Value arr{json::ValueType::Array}; arr[0u] = "zero"; arr[1u] = "one"; arr[2u] = "two"; @@ -1237,7 +1235,7 @@ TEST(json_value, iterator) { // Iterating a const object. json::Value const obj{[]() { - json::Value obj{json::ObjectValue}; + json::Value obj{json::ValueType::Object}; obj["0"] = 0; obj["1"] = 1; obj["2"] = 2; @@ -1334,27 +1332,27 @@ TEST(json_value, memory_leak) { json::Value a; a[0u] = 1; - EXPECT_EQ(a.type(), json::ArrayValue); - EXPECT_EQ(a[0u].type(), json::IntValue); + EXPECT_EQ(a.type(), json::ValueType::Array); + EXPECT_EQ(a[0u].type(), json::ValueType::Int); a = std::move(a[0u]); - EXPECT_EQ(a.type(), json::IntValue); + EXPECT_EQ(a.type(), json::ValueType::Int); } { json::Value b; json::Value temp; temp["a"] = "Probably avoids the small string optimization"; temp["b"] = "Also probably avoids the small string optimization"; - EXPECT_EQ(temp.type(), json::ObjectValue); + EXPECT_EQ(temp.type(), json::ValueType::Object); b.append(temp); - EXPECT_EQ(temp.type(), json::ObjectValue); + EXPECT_EQ(temp.type(), json::ValueType::Object); EXPECT_EQ(b.size(), 1); b.append(std::move(temp)); EXPECT_EQ(b.size(), 2); - // Note that the type() == nullValue check is implementation + // Note that the type() == ValueType::Null check is implementation // specific and not guaranteed to be valid in the future. - EXPECT_EQ(temp.type(), json::NullValue); // NOLINT(bugprone-use-after-move) + EXPECT_EQ(temp.type(), json::ValueType::Null); // NOLINT(bugprone-use-after-move) } } diff --git a/src/tests/libxrpl/json/Writer.cpp b/src/tests/libxrpl/json/Writer.cpp index 772428ecb5..25218f81f0 100644 --- a/src/tests/libxrpl/json/Writer.cpp +++ b/src/tests/libxrpl/json/Writer.cpp @@ -164,7 +164,7 @@ TEST_F(WriterFixture, complex_object) TEST_F(WriterFixture, json_value) { - json::Value value(json::ObjectValue); + json::Value value(json::ValueType::Object); value["foo"] = 23; writer_->startRoot(Writer::CollectionType::Object); writer_->set("hello", value); diff --git a/src/tests/libxrpl/protocol_autogen/TestHelpers.h b/src/tests/libxrpl/protocol_autogen/TestHelpers.h index dbc5aac40a..3cd5f298ea 100644 --- a/src/tests/libxrpl/protocol_autogen/TestHelpers.h +++ b/src/tests/libxrpl/protocol_autogen/TestHelpers.h @@ -28,60 +28,60 @@ namespace xrpl { // Typed field canonical values -using Uint8Value = std::decay_t; -inline Uint8Value +using UInt8Value = std::decay_t; +inline UInt8Value canonical_UINT8() { - return Uint8Value{1}; + return UInt8Value{1}; } -using Uint16Value = std::decay_t; -inline Uint16Value +using UInt16Value = std::decay_t; +inline UInt16Value canonical_UINT16() { - return Uint16Value{1}; + return UInt16Value{1}; } -using Uint32Value = std::decay_t; -inline Uint32Value +using UInt32Value = std::decay_t; +inline UInt32Value canonical_UINT32() { - return Uint32Value{1}; + return UInt32Value{1}; } -using Uint64Value = std::decay_t; -inline Uint64Value +using UInt64Value = std::decay_t; +inline UInt64Value canonical_UINT64() { - return Uint64Value{1}; + return UInt64Value{1}; } -using Uint128Value = std::decay_t; -inline Uint128Value +using UInt128Value = std::decay_t; +inline UInt128Value canonical_UINT128() { - return Uint128Value{1}; + return UInt128Value{1}; } -using Uint160Value = std::decay_t; -inline Uint160Value +using UInt160Value = std::decay_t; +inline UInt160Value canonical_UINT160() { - return Uint160Value{1}; + return UInt160Value{1}; } -using Uint192Value = std::decay_t; -inline Uint192Value +using UInt192Value = std::decay_t; +inline UInt192Value canonical_UINT192() { - return Uint192Value{1}; + return UInt192Value{1}; } -using Uint256Value = std::decay_t; -inline Uint256Value +using UInt256Value = std::decay_t; +inline UInt256Value canonical_UINT256() { - return Uint256Value{1}; + return UInt256Value{1}; } using Int32Value = std::decay_t; diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp index b5a643568b..77561f9f79 100644 --- a/src/xrpld/app/consensus/RCLConsensus.cpp +++ b/src/xrpld/app/consensus/RCLConsensus.cpp @@ -400,7 +400,7 @@ RCLConsensus::Adaptor::onClose( } // Needed because of the move below. - auto const setHash = initialSet->getHash().asUint256(); + auto const setHash = initialSet->getHash().asUInt256(); return Result{ std::move(initialSet), @@ -499,7 +499,7 @@ RCLConsensus::Adaptor::doAccept( // we use the hash of the set. // // FIXME: Use a std::vector and a custom sorter instead of CanonicalTXSet? - CanonicalTXSet retriableTxs{result.txns.map->getHash().asUint256()}; + CanonicalTXSet retriableTxs{result.txns.map->getHash().asUInt256()}; JLOG(j_.debug()) << "Building canonical tx set: " << retriableTxs.key(); @@ -1090,7 +1090,7 @@ RclConsensusLogger::~RclConsensusLogger() std::stringstream outSs; outSs << header_ << "duration " << (duration.count() / 1000) << '.' << std::setw(3) << std::setfill('0') << (duration.count() % 1000) << "s. " << ss_->str(); - j_.sink().writeAlways(beast::severities::KInfo, outSs.str()); + j_.sink().writeAlways(beast::Severity::Info, outSs.str()); } } // namespace xrpl diff --git a/src/xrpld/app/consensus/RCLCxTx.h b/src/xrpld/app/consensus/RCLCxTx.h index 634b8ca915..52637d32b3 100644 --- a/src/xrpld/app/consensus/RCLCxTx.h +++ b/src/xrpld/app/consensus/RCLCxTx.h @@ -131,7 +131,7 @@ public: [[nodiscard]] ID id() const { - return map->getHash().asUint256(); + return map->getHash().asUInt256(); } /** Find transactions not in common between this and another transaction diff --git a/src/xrpld/app/ledger/AccountStateSF.cpp b/src/xrpld/app/ledger/AccountStateSF.cpp index c12c2864ec..a0c3e3600d 100644 --- a/src/xrpld/app/ledger/AccountStateSF.cpp +++ b/src/xrpld/app/ledger/AccountStateSF.cpp @@ -19,13 +19,13 @@ AccountStateSF::gotNode( Blob&& nodeData, SHAMapNodeType) const { - db_.store(NodeObjectType::AccountNode, std::move(nodeData), nodeHash.asUint256(), ledgerSeq); + db_.store(NodeObjectType::AccountNode, std::move(nodeData), nodeHash.asUInt256(), ledgerSeq); } std::optional AccountStateSF::getNode(SHAMapHash const& nodeHash) const { - return fp_.getFetchPack(nodeHash.asUint256()); + return fp_.getFetchPack(nodeHash.asUInt256()); } } // namespace xrpl diff --git a/src/xrpld/app/ledger/ConsensusTransSetSF.cpp b/src/xrpld/app/ledger/ConsensusTransSetSF.cpp index 029c16e7e4..7c74c10b1b 100644 --- a/src/xrpld/app/ledger/ConsensusTransSetSF.cpp +++ b/src/xrpld/app/ledger/ConsensusTransSetSF.cpp @@ -53,7 +53,7 @@ ConsensusTransSetSF::gotNode( SerialIter sit(s.slice()); auto stx = std::make_shared(std::ref(sit)); XRPL_ASSERT( - stx->getTransactionID() == nodeHash.asUint256(), + stx->getTransactionID() == nodeHash.asUInt256(), "xrpl::ConsensusTransSetSF::gotNode : transaction hash " "match"); auto const pap = &app_; @@ -75,7 +75,7 @@ ConsensusTransSetSF::getNode(SHAMapHash const& nodeHash) const if (nodeCache_.retrieve(nodeHash, nodeData)) return nodeData; - auto txn = app_.getMasterTransaction().fetchFromCache(nodeHash.asUint256()); + auto txn = app_.getMasterTransaction().fetchFromCache(nodeHash.asUInt256()); if (txn) { @@ -85,7 +85,7 @@ ConsensusTransSetSF::getNode(SHAMapHash const& nodeHash) const s.add32(HashPrefix::TransactionId); txn->getSTransaction()->add(s); XRPL_ASSERT( - sha512Half(s.slice()) == nodeHash.asUint256(), + sha512Half(s.slice()) == nodeHash.asUInt256(), "xrpl::ConsensusTransSetSF::getNode : transaction hash match"); nodeData = s.peekData(); return nodeData; diff --git a/src/xrpld/app/ledger/InboundLedger.h b/src/xrpld/app/ledger/InboundLedger.h index 5f27c0c2c4..d155c5902c 100644 --- a/src/xrpld/app/ledger/InboundLedger.h +++ b/src/xrpld/app/ledger/InboundLedger.h @@ -78,7 +78,7 @@ public: using neededHash_t = std::pair; - /** Return a json::objectValue. */ + /** Return a json::ValueType::Object. */ json::Value getJson(int); diff --git a/src/xrpld/app/ledger/LedgerHistory.cpp b/src/xrpld/app/ledger/LedgerHistory.cpp index 76bf4122e1..f251f25620 100644 --- a/src/xrpld/app/ledger/LedgerHistory.cpp +++ b/src/xrpld/app/ledger/LedgerHistory.cpp @@ -164,7 +164,7 @@ logOne(ReadView const& ledger, uint256 const& tx, char const* msg, beast::Journa { JLOG(j.debug()) << "MISMATCH on TX " << tx << ": " << msg << " is missing this transaction:\n" - << metaData->getJson(JsonOptions::KNone); + << metaData->getJson(JsonOptions::Values::None); } else { @@ -245,38 +245,38 @@ logMetadataDifference( { JLOG(j.debug()) << "MISMATCH on TX " << tx << ": Different result, index and nodes!"; - JLOG(j.debug()) << " Built:\n" << builtMetaData->getJson(JsonOptions::KNone); - JLOG(j.debug()) << " Valid:\n" << validMetaData->getJson(JsonOptions::KNone); + JLOG(j.debug()) << " Built:\n" << builtMetaData->getJson(JsonOptions::Values::None); + JLOG(j.debug()) << " Valid:\n" << validMetaData->getJson(JsonOptions::Values::None); } else if (resultDiff) { JLOG(j.debug()) << "MISMATCH on TX " << tx << ": Different result and nodes!"; JLOG(j.debug()) << " Built:" << " Result: " << builtMetaData->getResult() << " Nodes:\n" - << builtNodes.getJson(JsonOptions::KNone); + << builtNodes.getJson(JsonOptions::Values::None); JLOG(j.debug()) << " Valid:" << " Result: " << validMetaData->getResult() << " Nodes:\n" - << validNodes.getJson(JsonOptions::KNone); + << validNodes.getJson(JsonOptions::Values::None); } else if (indexDiff) { JLOG(j.debug()) << "MISMATCH on TX " << tx << ": Different index and nodes!"; JLOG(j.debug()) << " Built:" << " Index: " << builtMetaData->getIndex() << " Nodes:\n" - << builtNodes.getJson(JsonOptions::KNone); + << builtNodes.getJson(JsonOptions::Values::None); JLOG(j.debug()) << " Valid:" << " Index: " << validMetaData->getIndex() << " Nodes:\n" - << validNodes.getJson(JsonOptions::KNone); + << validNodes.getJson(JsonOptions::Values::None); } else // nodes_diff { JLOG(j.debug()) << "MISMATCH on TX " << tx << ": Different nodes!"; JLOG(j.debug()) << " Built:" << " Nodes:\n" - << builtNodes.getJson(JsonOptions::KNone); + << builtNodes.getJson(JsonOptions::Values::None); JLOG(j.debug()) << " Valid:" << " Nodes:\n" - << validNodes.getJson(JsonOptions::KNone); + << validNodes.getJson(JsonOptions::Values::None); } } @@ -286,13 +286,13 @@ logMetadataDifference( if (validMetaData) { JLOG(j.error()) << "MISMATCH on TX " << tx << ": Metadata Difference. Valid=\n" - << validMetaData->getJson(JsonOptions::KNone); + << validMetaData->getJson(JsonOptions::Values::None); } if (builtMetaData) { JLOG(j.error()) << "MISMATCH on TX " << tx << ": Metadata Difference. Built=\n" - << builtMetaData->getJson(JsonOptions::KNone); + << builtMetaData->getJson(JsonOptions::Values::None); } } diff --git a/src/xrpld/app/ledger/LedgerToJson.h b/src/xrpld/app/ledger/LedgerToJson.h index 981af07a0e..853d4468cd 100644 --- a/src/xrpld/app/ledger/LedgerToJson.h +++ b/src/xrpld/app/ledger/LedgerToJson.h @@ -23,9 +23,7 @@ struct LedgerFill closeTime = context->ledgerMaster.getCloseTimeBySeq(ledger.seq()); } - // Bitwise bitmask - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum Options { + enum class Options { DumpTxrp = 1, DumpState = 2, Expand = 4, diff --git a/src/xrpld/app/ledger/TransactionStateSF.cpp b/src/xrpld/app/ledger/TransactionStateSF.cpp index fc57c567eb..52c761aa10 100644 --- a/src/xrpld/app/ledger/TransactionStateSF.cpp +++ b/src/xrpld/app/ledger/TransactionStateSF.cpp @@ -24,13 +24,13 @@ TransactionStateSF::gotNode( XRPL_ASSERT( type != SHAMapNodeType::TnTransactionNm, "xrpl::TransactionStateSF::gotNode : valid input"); db_.store( - NodeObjectType::TransactionNode, std::move(nodeData), nodeHash.asUint256(), ledgerSeq); + NodeObjectType::TransactionNode, std::move(nodeData), nodeHash.asUInt256(), ledgerSeq); } std::optional TransactionStateSF::getNode(SHAMapHash const& nodeHash) const { - return fp_.getFetchPack(nodeHash.asUint256()); + return fp_.getFetchPack(nodeHash.asUInt256()); } } // namespace xrpl diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp index b4082485d3..52cff26356 100644 --- a/src/xrpld/app/ledger/detail/InboundLedger.cpp +++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp @@ -55,36 +55,14 @@ namespace xrpl { using namespace std::chrono_literals; -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - // Number of peers to start with - PeerCountStart = 5 - - // Number of peers to add on a timeout - , - PeerCountAdd = 3 - - // how many timeouts before we give up - , - LedgerTimeoutRetriesMax = 6 - - // how many timeouts before we get aggressive - , - LedgerBecomeAggressiveThreshold = 4 - - // Number of nodes to find initially - , - MissingNodesFind = 256 - - // Number of nodes to request for a reply - , - ReqNodesReply = 128 - - // Number of nodes to request blindly - , - ReqNodes = 12 -}; +static constexpr auto kPEER_COUNT_START = 5; // Number of peers to start with +static constexpr auto kPEER_COUNT_ADD = 3; // Number of peers to add on a timeout +static constexpr auto kLEDGER_TIMEOUT_RETRIES_MAX = 6; // how many timeouts before we give up +static constexpr auto kLEDGER_BECOME_AGGRESSIVE_THRESHOLD = + 4; // how many timeouts before we get aggressive +static constexpr auto kMISSING_NODES_FIND = 256; // Number of nodes to find initially +static constexpr auto kREQ_NODES_REPLY = 128; // Number of nodes to request for a reply +static constexpr auto kREQ_NODES = 12; // Number of nodes to request blindly // millisecond for each ledger timeout auto constexpr kLEDGER_ACQUIRE_TIMEOUT = 3000ms; @@ -372,7 +350,7 @@ InboundLedger::onTimer(bool wasProgress, ScopedLockType&) return; } - if (timeouts_ > LedgerTimeoutRetriesMax) + if (timeouts_ > kLEDGER_TIMEOUT_RETRIES_MAX) { if (seq_ != 0) { @@ -413,7 +391,7 @@ void InboundLedger::addPeers() { peerSet_->addPeers( - (getPeerCount() == 0) ? PeerCountStart : PeerCountAdd, + (getPeerCount() == 0) ? kPEER_COUNT_START : kPEER_COUNT_ADD, [this](auto peer) { return peer->hasLedger(hash_, seq_); }, [this](auto peer) { // For historical nodes, do not trigger too soon @@ -527,7 +505,7 @@ InboundLedger::trigger(std::shared_ptr const& peer, TriggerReason reason) // Be more aggressive if we've timed out at least once tmGL.set_querytype(protocol::qtINDIRECT); - if (!progress_ && !failed_ && byHash_ && (timeouts_ > LedgerBecomeAggressiveThreshold)) + if (!progress_ && !failed_ && byHash_ && (timeouts_ > kLEDGER_BECOME_AGGRESSIVE_THRESHOLD)) { auto need = getNeededHashes(); @@ -637,7 +615,7 @@ InboundLedger::trigger(std::shared_ptr const& peer, TriggerReason reason) // Release the lock while we process the large state map sl.unlock(); - auto nodes = ledger_->stateMap().getMissingNodes(MissingNodesFind, &filter); + auto nodes = ledger_->stateMap().getMissingNodes(kMISSING_NODES_FIND, &filter); sl.lock(); // Make sure nothing happened while we released the lock @@ -706,7 +684,7 @@ InboundLedger::trigger(std::shared_ptr const& peer, TriggerReason reason) { TransactionStateSF filter(ledger_->txMap().family().db(), app_.getLedgerMaster()); - auto nodes = ledger_->txMap().getMissingNodes(MissingNodesFind, &filter); + auto nodes = ledger_->txMap().getMissingNodes(kMISSING_NODES_FIND, &filter); if (nodes.empty()) { @@ -783,7 +761,7 @@ InboundLedger::filterNodes( nodes.erase(dup.begin(), dup.end()); } - std::size_t const limit = (reason == TriggerReason::Reply) ? ReqNodesReply : ReqNodes; + std::size_t const limit = (reason == TriggerReason::Reply) ? kREQ_NODES_REPLY : kREQ_NODES; if (nodes.size() > limit) nodes.resize(limit); @@ -1269,7 +1247,7 @@ InboundLedger::runData() json::Value InboundLedger::getJson(int) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ScopedLockType const sl(mtx_); @@ -1296,7 +1274,7 @@ InboundLedger::getJson(int) if (haveHeader_ && !haveState_) { - json::Value hv(json::ArrayValue); + json::Value hv(json::ValueType::Array); for (auto const& h : neededStateHashes(16, nullptr)) { hv.append(to_string(h)); @@ -1306,7 +1284,7 @@ InboundLedger::getJson(int) if (haveHeader_ && !haveTransactions_) { - json::Value hv(json::ArrayValue); + json::Value hv(json::ValueType::Array); for (auto const& h : neededTxHashes(16, nullptr)) { hv.append(to_string(h)); diff --git a/src/xrpld/app/ledger/detail/InboundLedgers.cpp b/src/xrpld/app/ledger/detail/InboundLedgers.cpp index a175528978..86f5b1a50a 100644 --- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp +++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp @@ -264,7 +264,7 @@ public: newNode->serializeWithPrefix(s); app_.getLedgerMaster().addFetchPack( - newNode->getHash().asUint256(), std::make_shared(s.begin(), s.end())); + newNode->getHash().asUInt256(), std::make_shared(s.begin(), s.end())); } } catch (std::exception const&) // NOLINT(bugprone-empty-catch) @@ -300,7 +300,7 @@ public: json::Value getInfo() override { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); std::vector>> acqs; diff --git a/src/xrpld/app/ledger/detail/InboundTransactions.cpp b/src/xrpld/app/ledger/detail/InboundTransactions.cpp index 598a8b5c4c..0ae0b81820 100644 --- a/src/xrpld/app/ledger/detail/InboundTransactions.cpp +++ b/src/xrpld/app/ledger/detail/InboundTransactions.cpp @@ -28,14 +28,8 @@ namespace xrpl { // Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - // Ideal number of peers to start with - StartPeers = 2, - - // How many rounds to keep a set - SetKeepRounds = 3, -}; +static constexpr auto kSTART_PEERS = 2; // ideal number of peers to start with +static constexpr auto kSET_KEEP_ROUNDS = 3; // how many rounds to keep a set class InboundTransactionSet { @@ -120,7 +114,7 @@ public: obj.seq = seq_; } - ta->init(StartPeers); + ta->init(kSTART_PEERS); return {}; } @@ -214,8 +208,8 @@ public: auto it = map_.begin(); - std::uint32_t const minSeq = (seq < SetKeepRounds) ? 0 : (seq - SetKeepRounds); - std::uint32_t const maxSeq = seq + SetKeepRounds; + std::uint32_t const minSeq = (seq < kSET_KEEP_ROUNDS) ? 0 : (seq - kSET_KEEP_ROUNDS); + std::uint32_t const maxSeq = seq + kSET_KEEP_ROUNDS; while (it != map_.end()) { diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp index 34ded1d14f..78470eca22 100644 --- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp +++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp @@ -2035,7 +2035,7 @@ populateFetchPack( s.erase(); n.serializeWithPrefix(s); - auto const& hash = n.getHash().asUint256(); + auto const& hash = n.getHash().asUInt256(); protocol::TMIndexedObject* obj = into->add_objects(); obj->set_ledgerseq(seq); diff --git a/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp b/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp index 3df1e99cae..07738d99f4 100644 --- a/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp +++ b/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp @@ -56,8 +56,8 @@ LedgerReplayMsgHandler::processProofPathRequest( reply.set_ledgerhash(packet.ledgerhash()); reply.set_type(packet.type()); - uint256 const key(packet.key()); - uint256 const ledgerHash(packet.ledgerhash()); + uint256 const key = uint256::fromRaw(packet.key()); + uint256 const ledgerHash = uint256::fromRaw(packet.ledgerhash()); auto ledger = app_.getLedgerMaster().getLedgerByHash(ledgerHash); if (!ledger) { @@ -107,7 +107,8 @@ LedgerReplayMsgHandler::processProofPathResponse( { protocol::TMProofPathResponse const& reply = *msg; if (reply.has_error() || !reply.has_key() || !reply.has_ledgerhash() || !reply.has_type() || - !reply.has_ledgerheader() || reply.path_size() == 0) + !reply.has_ledgerheader() || reply.path_size() == 0 || + reply.ledgerhash().size() != uint256::size() || reply.key().size() != uint256::size()) { JLOG(journal_.debug()) << "Bad message: Error reply"; return false; @@ -121,7 +122,7 @@ LedgerReplayMsgHandler::processProofPathResponse( // deserialize the header auto info = deserializeHeader({reply.ledgerheader().data(), reply.ledgerheader().size()}); - uint256 const replyHash(reply.ledgerhash()); + uint256 const replyHash = uint256::fromRaw(reply.ledgerhash()); if (calculateLedgerHash(info) != replyHash) { JLOG(journal_.debug()) << "Bad message: Hash mismatch"; @@ -129,7 +130,7 @@ LedgerReplayMsgHandler::processProofPathResponse( } info.hash = replyHash; - uint256 const key(reply.key()); + uint256 const key = uint256::fromRaw(reply.key()); if (key != keylet::skip().key) { JLOG(journal_.debug()) << "Bad message: we only support the short skip list for now. " @@ -185,7 +186,7 @@ LedgerReplayMsgHandler::processReplayDeltaRequest( } reply.set_ledgerhash(packet.ledgerhash()); - uint256 const ledgerHash{packet.ledgerhash()}; + uint256 const ledgerHash = uint256::fromRaw(packet.ledgerhash()); auto ledger = app_.getLedgerMaster().getLedgerByHash(ledgerHash); if (!ledger || !ledger->isImmutable()) { @@ -205,7 +206,7 @@ LedgerReplayMsgHandler::processReplayDeltaRequest( }); JLOG(journal_.debug()) << "getReplayDelta for ledger " << ledgerHash << " txMap hash " - << txMap.getHash().asUint256(); + << txMap.getHash().asUInt256(); return reply; } @@ -214,14 +215,15 @@ LedgerReplayMsgHandler::processReplayDeltaResponse( std::shared_ptr const& msg) { protocol::TMReplayDeltaResponse const& reply = *msg; - if (reply.has_error() || !reply.has_ledgerheader()) + if (reply.has_error() || !reply.has_ledgerheader() || !reply.has_ledgerhash() || + reply.ledgerhash().size() != uint256::size()) { JLOG(journal_.debug()) << "Bad message: Error reply"; return false; } auto info = deserializeHeader({reply.ledgerheader().data(), reply.ledgerheader().size()}); - uint256 const replyHash(reply.ledgerhash()); + uint256 const replyHash = uint256::fromRaw(reply.ledgerhash()); if (calculateLedgerHash(info) != replyHash) { JLOG(journal_.debug()) << "Bad message: Hash mismatch"; @@ -271,7 +273,7 @@ LedgerReplayMsgHandler::processReplayDeltaResponse( return false; } - if (txMap.getHash().asUint256() != info.txHash) + if (txMap.getHash().asUInt256() != info.txHash) { JLOG(journal_.debug()) << "Bad message: Transactions verify failed"; return false; diff --git a/src/xrpld/app/ledger/detail/LedgerToJson.cpp b/src/xrpld/app/ledger/detail/LedgerToJson.cpp index 5248c3621a..7c03e22580 100644 --- a/src/xrpld/app/ledger/detail/LedgerToJson.cpp +++ b/src/xrpld/app/ledger/detail/LedgerToJson.cpp @@ -38,19 +38,19 @@ namespace { bool isFull(LedgerFill const& fill) { - return (fill.options & LedgerFill::Full) != 0; + return (fill.options & static_cast(LedgerFill::Options::Full)) != 0; } bool isExpanded(LedgerFill const& fill) { - return isFull(fill) || ((fill.options & LedgerFill::Expand) != 0); + return isFull(fill) || ((fill.options & static_cast(LedgerFill::Options::Expand)) != 0); } bool isBinary(LedgerFill const& fill) { - return (fill.options & LedgerFill::Binary) != 0; + return (fill.options & static_cast(LedgerFill::Options::Binary)) != 0; } void @@ -119,7 +119,7 @@ fillJsonTx( if (!bExpanded) return to_string(txn->getTransactionID()); - json::Value txJson{json::ObjectValue}; + json::Value txJson{json::ValueType::Object}; auto const txnType = txn->getTxnType(); if (bBinary) { @@ -133,13 +133,13 @@ fillJsonTx( } else if (fill.context->apiVersion > 1) { - copyFrom(txJson[jss::tx_json], txn->getJson(JsonOptions::KDisableApiPriorV2, false)); + copyFrom(txJson[jss::tx_json], txn->getJson(JsonOptions::Values::DisableApiPriorV2, false)); txJson[jss::hash] = to_string(txn->getTransactionID()); RPC::insertDeliverMax(txJson[jss::tx_json], txnType, fill.context->apiVersion); if (stMeta) { - txJson[jss::meta] = stMeta->getJson(JsonOptions::KNone); + txJson[jss::meta] = stMeta->getJson(JsonOptions::Values::None); // If applicable, insert delivered amount if (txnType == ttPAYMENT || txnType == ttCHECK_CASH) @@ -171,11 +171,11 @@ fillJsonTx( } else { - copyFrom(txJson, txn->getJson(JsonOptions::KNone)); + copyFrom(txJson, txn->getJson(JsonOptions::Values::None)); RPC::insertDeliverMax(txJson, txnType, fill.context->apiVersion); if (stMeta) { - txJson[jss::metaData] = stMeta->getJson(JsonOptions::KNone); + txJson[jss::metaData] = stMeta->getJson(JsonOptions::Values::None); // If applicable, insert delivered amount if (txnType == ttPAYMENT || txnType == ttCHECK_CASH) @@ -193,7 +193,8 @@ fillJsonTx( } } - if (((fill.options & LedgerFill::OwnerFunds) != 0) && txn->getTxnType() == ttOFFER_CREATE) + if (((fill.options & static_cast(LedgerFill::Options::OwnerFunds)) != 0) && + txn->getTxnType() == ttOFFER_CREATE) { auto const account = txn->getAccountID(sfAccount); auto const amount = txn->getFieldAmount(sfTakerGets); @@ -218,7 +219,7 @@ fillJsonTx( void fillJsonTx(json::Value& json, LedgerFill const& fill) { - auto& txns = json[jss::transactions] = json::ArrayValue; + auto& txns = json[jss::transactions] = json::ValueType::Array; auto bBinary = isBinary(fill); auto bExpanded = isExpanded(fill); @@ -247,7 +248,7 @@ void fillJsonState(json::Value& json, LedgerFill const& fill) { auto& ledger = fill.ledger; - auto& array = json[jss::accountState] = json::ArrayValue; + auto& array = json[jss::accountState] = json::ValueType::Array; auto expanded = isExpanded(fill); auto binary = isBinary(fill); @@ -255,13 +256,13 @@ fillJsonState(json::Value& json, LedgerFill const& fill) { if (binary) { - auto& obj = array.append(json::ObjectValue); + auto& obj = array.append(json::ValueType::Object); obj[jss::hash] = to_string(sle->key()); obj[jss::tx_blob] = serializeHex(*sle); } else if (expanded) { - array.append(sle->getJson(JsonOptions::KNone)); + array.append(sle->getJson(JsonOptions::Values::None)); } else { @@ -273,13 +274,13 @@ fillJsonState(json::Value& json, LedgerFill const& fill) void fillJsonQueue(json::Value& json, LedgerFill const& fill) { - auto& queueData = json[jss::queue_data] = json::ArrayValue; + auto& queueData = json[jss::queue_data] = json::ValueType::Array; auto bBinary = isBinary(fill); auto bExpanded = isExpanded(fill); for (auto const& tx : fill.txQueue) { - auto& txJson = queueData.append(json::ObjectValue); + auto& txJson = queueData.append(json::ValueType::Object); txJson[jss::fee_level] = to_string(tx.feeLevel); if (tx.lastValid) txJson[jss::LastLedgerSequence] = *tx.lastValid; @@ -296,13 +297,24 @@ fillJsonQueue(json::Value& json, LedgerFill const& fill) txJson["last_result"] = transToken(*tx.lastResult); auto&& temp = fillJsonTx(fill, bBinary, bExpanded, tx.txn, nullptr); - if (fill.context->apiVersion > 1) + if (temp.isObject()) { - copyFrom(txJson, temp); + if (fill.context->apiVersion > 1) + { + copyFrom(txJson, temp); + } + else + { + copyFrom(txJson[jss::tx], temp); + } + } + else if (fill.context->apiVersion > 1) + { + txJson[jss::hash] = temp; } else { - copyFrom(txJson[jss::tx], temp); + txJson[jss::tx] = temp; } } } @@ -328,10 +340,10 @@ fillJson(json::Value& json, LedgerFill const& fill) : RPC::kAPI_MAXIMUM_SUPPORTED_VERSION)); } - if (bFull || ((fill.options & LedgerFill::DumpTxrp) != 0)) + if (bFull || ((fill.options & static_cast(LedgerFill::Options::DumpTxrp)) != 0)) fillJsonTx(json, fill); - if (bFull || ((fill.options & LedgerFill::DumpState) != 0)) + if (bFull || ((fill.options & static_cast(LedgerFill::Options::DumpState)) != 0)) fillJsonState(json, fill); } @@ -340,11 +352,14 @@ fillJson(json::Value& json, LedgerFill const& fill) void addJson(json::Value& json, LedgerFill const& fill) { - auto& object = json[jss::ledger] = json::ObjectValue; + auto& object = json[jss::ledger] = json::ValueType::Object; fillJson(object, fill); - if (((fill.options & LedgerFill::DumpQueue) != 0) && !fill.txQueue.empty()) + if (((fill.options & static_cast(LedgerFill::Options::DumpQueue)) != 0) && + !fill.txQueue.empty()) + { fillJsonQueue(json, fill); + } } json::Value diff --git a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp index f79620f99d..e3104ffb5d 100644 --- a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp +++ b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp @@ -31,12 +31,8 @@ using namespace std::chrono_literals; // Timeout interval in milliseconds auto constexpr kTX_ACQUIRE_TIMEOUT = 250ms; -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - NormTimeouts = 4, - MaxTimeouts = 20, -}; +static constexpr auto kNORM_TIMEOUTS = 4; +static constexpr auto kMAX_TIMEOUTS = 20; TransactionAcquire::TransactionAcquire( Application& app, @@ -85,14 +81,14 @@ TransactionAcquire::done() void TransactionAcquire::onTimer(bool progress, ScopedLockType& psl) { - if (timeouts_ > MaxTimeouts) + if (timeouts_ > kMAX_TIMEOUTS) { failed_ = true; done(); return; } - if (timeouts_ >= NormTimeouts) + if (timeouts_ >= kNORM_TIMEOUTS) trigger(nullptr); addPeers(1); @@ -259,7 +255,7 @@ TransactionAcquire::stillNeed() { ScopedLockType const sl(mtx_); - timeouts_ = std::min(timeouts_, NormTimeouts); + timeouts_ = std::min(timeouts_, kNORM_TIMEOUTS); failed_ = false; } diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp index 800d398eca..20a81f6768 100644 --- a/src/xrpld/app/main/Application.cpp +++ b/src/xrpld/app/main/Application.cpp @@ -141,16 +141,16 @@ fixConfigPorts(Config& config, Endpoints const& endpoints); class ApplicationImp : public Application, public BasicApp { private: - class IoLatencySampler + class IOLatencySampler { private: beast::insight::Event event_; beast::Journal journal_; - beast::IoLatencyProbe probe_; + beast::IOLatencyProbe probe_; std::atomic lastSample_; public: - IoLatencySampler( + IOLatencySampler( beast::insight::Event ev, beast::Journal journal, std::chrono::milliseconds interval, @@ -272,7 +272,7 @@ public: std::unique_ptr resolver_; - IoLatencySampler io_latency_sampler_; + IOLatencySampler io_latency_sampler_; std::unique_ptr grpcServer_; // NOLINTEND(readability-identifier-naming) @@ -1176,9 +1176,9 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) if (!logs_->open(debugLog)) std::cerr << "Can't open log file " << debugLog << '\n'; - using namespace beast::severities; - if (logs_->threshold() > KDebug) - logs_->threshold(KDebug); + using beast::Severity; + if (logs_->threshold() > Severity::Debug) + logs_->threshold(Severity::Debug); } JLOG(journal_.info()) << "Process starting: " << BuildInfo::getFullVersionString() @@ -1357,7 +1357,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) // if (!config_.standalone()) overlay_ = makeOverlay( *this, - setupOverlay(*config_), + setupOverlay(*config_, journal_), *serverHandler_, *resourceManager_, *resolver_, @@ -1713,7 +1713,7 @@ ApplicationImp::getLastFullLedger() { stream << "Failed on ledger"; json::Value p; - addJson(p, {*ledger, nullptr, LedgerFill::Full}); + addJson(p, {*ledger, nullptr, static_cast(LedgerFill::Options::Full)}); stream << p; } diff --git a/src/xrpld/app/main/GRPCServer.cpp b/src/xrpld/app/main/GRPCServer.cpp index e0f0798dbc..e851a8f583 100644 --- a/src/xrpld/app/main/GRPCServer.cpp +++ b/src/xrpld/app/main/GRPCServer.cpp @@ -361,7 +361,7 @@ GRPCServerImpl::GRPCServerImpl(Application& app) Throw("Error setting grpc server address"); } - auto const optSecureGateway = section.get("secureGateway"); + auto const optSecureGateway = section.get("secure_gateway"); if (optSecureGateway) { try @@ -376,8 +376,8 @@ GRPCServerImpl::GRPCServerImpl(Application& app) if (addr.is_unspecified()) { JLOG(journal_.error()) << "Can't pass unspecified IP in " - << "secureGateway section of port_grpc"; - Throw("Unspecified IP in secureGateway section"); + << "secure_gateway section of port_grpc"; + Throw("Unspecified IP in secure_gateway section"); } secureGatewayIPs_.emplace_back(addr); @@ -386,7 +386,7 @@ GRPCServerImpl::GRPCServerImpl(Application& app) catch (std::exception const&) { JLOG(journal_.error()) << "Error parsing secure gateway IPs for grpc server"; - Throw("Error parsing secureGateway section"); + Throw("Error parsing secure_gateway section"); } } @@ -526,6 +526,7 @@ GRPCServerImpl::handleRpcs() std::vector> GRPCServerImpl::setupListeners() { + using RPC::Condition; std::vector> requests; auto addToRequests = [&requests](auto callData) { requests.push_back(std::move(callData)); }; @@ -542,7 +543,7 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedger, doLedgerGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedger, - RPC::NoCondition, + Condition::NoCondition, Resource::kFEE_MEDIUM_BURDEN_RPC, secureGatewayIPs_)); } @@ -559,7 +560,7 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedgerData, doLedgerDataGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedgerData, - RPC::NoCondition, + Condition::NoCondition, Resource::kFEE_MEDIUM_BURDEN_RPC, secureGatewayIPs_)); } @@ -576,7 +577,7 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedgerDiff, doLedgerDiffGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedgerDiff, - RPC::NoCondition, + Condition::NoCondition, Resource::kFEE_MEDIUM_BURDEN_RPC, secureGatewayIPs_)); } @@ -593,7 +594,7 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedgerEntry, doLedgerEntryGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedgerEntry, - RPC::NoCondition, + Condition::NoCondition, Resource::kFEE_MEDIUM_BURDEN_RPC, secureGatewayIPs_)); } diff --git a/src/xrpld/app/main/Main.cpp b/src/xrpld/app/main/Main.cpp index 167cd2b023..ed1d3333d8 100644 --- a/src/xrpld/app/main/Main.cpp +++ b/src/xrpld/app/main/Main.cpp @@ -768,16 +768,16 @@ run(int argc, char** argv) } // Construct the logs object at the configured severity - using namespace beast::severities; - Severity thresh = KInfo; + using beast::Severity; + Severity thresh = Severity::Info; if (vm.contains("quiet")) { - thresh = KFatal; + thresh = Severity::Fatal; } else if (vm.contains("verbose")) { - thresh = KTrace; + thresh = Severity::Trace; } auto logs = std::make_unique(thresh); @@ -802,7 +802,7 @@ run(int argc, char** argv) return -1; if (vm.contains("debug")) - setDebugLogSink(logs->makeSink("Debug", beast::severities::KTrace)); + setDebugLogSink(logs->makeSink("Debug", beast::Severity::Trace)); auto app = makeApplication(std::move(config), std::move(logs), std::make_unique()); diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp index 638489a9fa..c1ce5b9803 100644 --- a/src/xrpld/app/misc/NetworkOPs.cpp +++ b/src/xrpld/app/misc/NetworkOPs.cpp @@ -1733,7 +1733,7 @@ NetworkOPsImp::apply(std::unique_lock& batchLock) json::Value NetworkOPsImp::getOwnerInfo(std::shared_ptr lpLedger, AccountID const& account) { - json::Value jvObjects(json::ObjectValue); + json::Value jvObjects(json::ValueType::Object); auto root = keylet::ownerDir(account); auto sleNode = lpLedger->read(keylet::page(root)); if (sleNode) @@ -1751,18 +1751,19 @@ NetworkOPsImp::getOwnerInfo(std::shared_ptr lpLedger, AccountID { case ltOFFER: if (!jvObjects.isMember(jss::offers)) - jvObjects[jss::offers] = json::Value(json::ArrayValue); + jvObjects[jss::offers] = json::Value(json::ValueType::Array); - jvObjects[jss::offers].append(sleCur->getJson(JsonOptions::KNone)); + jvObjects[jss::offers].append(sleCur->getJson(JsonOptions::Values::None)); break; case ltRIPPLE_STATE: if (!jvObjects.isMember(jss::ripple_lines)) { - jvObjects[jss::ripple_lines] = json::Value(json::ArrayValue); + jvObjects[jss::ripple_lines] = json::Value(json::ValueType::Array); } - jvObjects[jss::ripple_lines].append(sleCur->getJson(JsonOptions::KNone)); + jvObjects[jss::ripple_lines].append( + sleCur->getJson(JsonOptions::Values::None)); break; case ltACCOUNT_ROOT: @@ -2113,7 +2114,7 @@ NetworkOPsImp::mapComplete(std::shared_ptr const& map, bool fromAcquire) // We now have an additional transaction set // Inform peers we have this set protocol::TMHaveTransactionSet msg; - msg.set_hash(map->getHash().asUint256().begin(), 256 / 8); + msg.set_hash(map->getHash().asUInt256().begin(), 256 / 8); msg.set_status(protocol::tsHAVE); registry_.get().getOverlay().foreach( SendAlways(std::make_shared(msg, protocol::mtHAVE_SET))); @@ -2195,7 +2196,7 @@ NetworkOPsImp::pubManifest(Manifest const& mo) if (!streamMaps_[SManifests].empty()) { - json::Value jvObj(json::ObjectValue); + json::Value jvObj(json::ValueType::Object); jvObj[jss::type] = "manifestReceived"; jvObj[jss::master_key] = toBase58(TokenType::NodePublic, mo.masterKey); @@ -2273,7 +2274,7 @@ NetworkOPsImp::pubServer() if (!streamMaps_[SServer].empty()) { - json::Value jvObj(json::ObjectValue); + json::Value jvObj(json::ValueType::Object); ServerFeeSummary f{ registry_.get().getOpenLedger().current()->fees().base, @@ -2333,7 +2334,7 @@ NetworkOPsImp::pubConsensus(ConsensusPhase phase) auto& streamMap = streamMaps_[SConsensusPhase]; if (!streamMap.empty()) { - json::Value jvObj(json::ObjectValue); + json::Value jvObj(json::ValueType::Object); jvObj[jss::type] = "consensusPhase"; jvObj[jss::consensus] = to_string(phase); @@ -2360,7 +2361,7 @@ NetworkOPsImp::pubValidation(std::shared_ptr const& val) if (!streamMaps_[SValidations].empty()) { - json::Value jvObj(json::ObjectValue); + json::Value jvObj(json::ValueType::Object); auto const signerPublic = val->getSignerPublic(); @@ -2395,7 +2396,7 @@ NetworkOPsImp::pubValidation(std::shared_ptr const& val) if (val->isFieldPresent(sfAmendments)) { - jvObj[jss::amendments] = json::Value(json::ArrayValue); + jvObj[jss::amendments] = json::Value(json::ValueType::Array); for (auto const& amendment : val->getFieldV256(sfAmendments)) jvObj[jss::amendments].append(to_string(amendment)); } @@ -2582,14 +2583,14 @@ NetworkOPsImp::getConsensusInfo() json::Value NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) { - json::Value info = json::ObjectValue; + json::Value info = json::ValueType::Object; // System-level warnings { - json::Value warnings{json::ArrayValue}; + json::Value warnings{json::ValueType::Array}; if (isAmendmentBlocked()) { - json::Value& w = warnings.append(json::ObjectValue); + json::Value& w = warnings.append(json::ValueType::Object); w[jss::id] = WarnRpcAmendmentBlocked; w[jss::message] = "This server is amendment blocked, and must be updated to be " @@ -2597,7 +2598,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) } if (isUNLBlocked()) { - json::Value& w = warnings.append(json::ObjectValue); + json::Value& w = warnings.append(json::ValueType::Object); w[jss::id] = WarnRpcExpiredValidatorList; w[jss::message] = "This server has an expired validator list. validators.txt " @@ -2606,7 +2607,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) } if (admin && isAmendmentWarned()) { - json::Value& w = warnings.append(json::ObjectValue); + json::Value& w = warnings.append(json::ValueType::Object); w[jss::id] = WarnRpcUnsupportedMajority; w[jss::message] = "One or more unsupported amendments have reached majority. " @@ -2615,7 +2616,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) if (auto const expected = registry_.get().getAmendmentTable().firstUnsupportedExpected()) { - auto& d = w[jss::details] = json::ObjectValue; + auto& d = w[jss::details] = json::ValueType::Object; d[jss::expected_date] = expected->time_since_epoch().count(); d[jss::expected_date_UTC] = to_string(*expected); } @@ -2686,7 +2687,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) } else { - auto& x = (info[jss::validator_list] = json::ObjectValue); + auto& x = (info[jss::validator_list] = json::ValueType::Object); x[jss::count] = static_cast(registry_.get().getValidators().count()); @@ -2720,7 +2721,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) if (!xrpl::git::getCommitHash().empty() || !xrpl::git::getBuildBranch().empty()) { - auto& x = (info[jss::git] = json::ObjectValue); + auto& x = (info[jss::git] = json::ValueType::Object); if (!xrpl::git::getCommitHash().empty()) x[jss::hash] = xrpl::git::getCommitHash(); if (!xrpl::git::getBuildBranch().empty()) @@ -2747,7 +2748,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) { info[jss::counters] = registry_.get().getPerfLog().countersJson(); - json::Value nodestore(json::ObjectValue); + json::Value nodestore(json::ValueType::Object); registry_.get().getNodeStore().getCountsJson(nodestore); info[jss::counters][jss::nodestore] = nodestore; info[jss::current_activities] = registry_.get().getPerfLog().currentJson(); @@ -2768,7 +2769,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) info[jss::peers] = json::UInt(registry_.get().getOverlay().size()); - json::Value lastClose = json::ObjectValue; + json::Value lastClose = json::ValueType::Object; lastClose[jss::proposers] = json::UInt(consensus_.prevProposers()); if (human) @@ -2872,7 +2873,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) if (lpClosed) { XRPAmount const baseFee = lpClosed->fees().base; - json::Value l(json::ObjectValue); + json::Value l(json::ValueType::Object); l[jss::seq] = json::UInt(lpClosed->header().seq); l[jss::hash] = to_string(lpClosed->header().hash); @@ -2946,7 +2947,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) "http", "https", "peer", "ws", "ws2", "wss", "wss2"}; static_assert(std::ranges::is_sorted(kPROTOCOLS)); { - json::Value ports{json::ArrayValue}; + json::Value ports{json::ValueType::Array}; for (auto const& port : registry_.get().getServerHandler().setup().ports) { // Don't publish admin ports for non-admin users @@ -2964,9 +2965,9 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) std::back_inserter(proto)); if (!proto.empty()) { - auto& jv = ports.append(json::Value(json::ObjectValue)); + auto& jv = ports.append(json::Value(json::ValueType::Object)); jv[jss::port] = std::to_string(port.port); - jv[jss::protocol] = json::Value{json::ArrayValue}; + jv[jss::protocol] = json::Value{json::ValueType::Array}; for (auto const& p : proto) jv[jss::protocol].append(p); } @@ -2978,9 +2979,9 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) auto const optPort = grpcSection.get("port"); if (optPort && grpcSection.get("ip")) { - auto& jv = ports.append(json::Value(json::ObjectValue)); + auto& jv = ports.append(json::Value(json::ValueType::Object)); jv[jss::port] = *optPort; - jv[jss::protocol] = json::Value{json::ArrayValue}; + jv[jss::protocol] = json::Value{json::ValueType::Array}; jv[jss::protocol].append("grpc"); } } @@ -3069,7 +3070,7 @@ NetworkOPsImp::pubLedger(std::shared_ptr const& lpAccepted) if (!streamMaps_[SLedger].empty()) { - json::Value jvObj(json::ObjectValue); + json::Value jvObj(json::ValueType::Object); jvObj[jss::type] = "ledgerClosed"; jvObj[jss::ledger_index] = lpAccepted->header().seq; @@ -3200,7 +3201,7 @@ NetworkOPsImp::transJson( std::shared_ptr const& ledger, std::optional> meta) { - json::Value jvObj(json::ObjectValue); + json::Value jvObj(json::ValueType::Object); std::string sToken; std::string sHuman; @@ -3210,11 +3211,11 @@ NetworkOPsImp::transJson( // NOTE jvObj is not a finished object for either API version. After // it's populated, we need to finish it for a specific API version. This is // done in a loop, near the end of this function. - jvObj[jss::transaction] = transaction->getJson(JsonOptions::KDisableApiPriorV2, false); + jvObj[jss::transaction] = transaction->getJson(JsonOptions::Values::DisableApiPriorV2, false); if (meta) { - jvObj[jss::meta] = meta->get().getJson(JsonOptions::KNone); + jvObj[jss::meta] = meta->get().getJson(JsonOptions::Values::None); RPC::insertDeliveredAmount(jvObj[jss::meta], *ledger, transaction, meta->get()); RPC::insertNFTSyntheticInJson(jvObj, transaction, meta->get()); RPC::insertMPTokenIssuanceID(jvObj[jss::meta], transaction, meta->get()); @@ -4292,7 +4293,7 @@ NetworkOPsImp::getBookPage( json::Value const& jvMarker, json::Value& jvResult) { // CAUTION: This is the old get book page logic - json::Value& jvOffers = (jvResult[jss::offers] = json::Value(json::ArrayValue)); + json::Value& jvOffers = (jvResult[jss::offers] = json::Value(json::ValueType::Array)); std::unordered_map umBalance; uint256 const uBookBase = getBookBase(book); @@ -4413,7 +4414,7 @@ NetworkOPsImp::getBookPage( } } - json::Value jvOffer = sleOffer->getJson(JsonOptions::KNone); + json::Value jvOffer = sleOffer->getJson(JsonOptions::Values::None); STAmount saTakerGetsFunded; STAmount saOwnerFundsLimit = saOwnerFunds; @@ -4477,8 +4478,8 @@ NetworkOPsImp::getBookPage( } } - // jvResult[jss::marker] = json::Value(json::arrayValue); - // jvResult[jss::nodes] = json::Value(json::arrayValue); + // jvResult[jss::marker] = json::Value(json::ValueType::Array); + // jvResult[jss::nodes] = json::Value(json::ValueType::Array); } #else @@ -4496,7 +4497,7 @@ NetworkOPsImp::getBookPage( json::Value const& jvMarker, json::Value& jvResult) { - auto& jvOffers = (jvResult[jss::offers] = json::Value(json::arrayValue)); + auto& jvOffers = (jvResult[jss::offers] = json::Value(json::ValueType::Array)); std::map umBalance; @@ -4559,7 +4560,7 @@ NetworkOPsImp::getBookPage( } } - json::Value jvOffer = sleOffer->getJson(JsonOptions::KNone); + json::Value jvOffer = sleOffer->getJson(JsonOptions::Values::None); STAmount saTakerGetsFunded; STAmount saOwnerFundsLimit = saOwnerFunds; @@ -4610,8 +4611,8 @@ NetworkOPsImp::getBookPage( } } - // jvResult[jss::marker] = json::Value(json::arrayValue); - // jvResult[jss::nodes] = json::Value(json::arrayValue); + // jvResult[jss::marker] = json::Value(json::ValueType::Array); + // jvResult[jss::nodes] = json::Value(json::ValueType::Array); } #endif @@ -4674,12 +4675,12 @@ NetworkOPsImp::StateAccounting::json(json::Value& obj) const std::chrono::steady_clock::now() - start); counters[static_cast(mode)].dur += current; - obj[jss::state_accounting] = json::ObjectValue; + obj[jss::state_accounting] = json::ValueType::Object; for (std::size_t i = static_cast(OperatingMode::DISCONNECTED); i <= static_cast(OperatingMode::FULL); ++i) { - obj[jss::state_accounting][kSTATES[i]] = json::ObjectValue; + obj[jss::state_accounting][kSTATES[i]] = json::ValueType::Object; auto& state = obj[jss::state_accounting][kSTATES[i]]; state[jss::transitions] = std::to_string(counters[i].transitions); state[jss::duration_us] = std::to_string(counters[i].dur.count()); diff --git a/src/xrpld/app/misc/SHAMapStoreImp.cpp b/src/xrpld/app/misc/SHAMapStoreImp.cpp index 6fa1fbda61..1fa7558d21 100644 --- a/src/xrpld/app/misc/SHAMapStoreImp.cpp +++ b/src/xrpld/app/misc/SHAMapStoreImp.cpp @@ -237,7 +237,7 @@ SHAMapStoreImp::copyNode(std::uint64_t& nodeCount, SHAMapTreeNode const& node) { // Copy a single record from node to dbRotating_ dbRotating_->fetchNodeObject( - node.getHash().asUint256(), 0, NodeStore::FetchType::Synchronous, true); + node.getHash().asUInt256(), 0, NodeStore::FetchType::Synchronous, true); if ((++nodeCount % checkHealthInterval_) == 0u) { if (healthWait() == HealthResult::Stopping) diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp index 56b97d3f7e..30fea32373 100644 --- a/src/xrpld/app/misc/detail/AmendmentTable.cpp +++ b/src/xrpld/app/misc/detail/AmendmentTable.cpp @@ -24,7 +24,7 @@ #include #include -#include +#include // IWYU pragma: keep #include #include #include @@ -983,13 +983,17 @@ AmendmentTableImpl::injectJson( json::Value AmendmentTableImpl::getJson(bool isAdmin) const { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); { std::scoped_lock const lock(mutex_); for (auto const& e : amendmentMap_) { injectJson( - ret[to_string(e.first)] = json::ObjectValue, e.first, e.second, isAdmin, lock); + ret[to_string(e.first)] = json::ValueType::Object, + e.first, + e.second, + isAdmin, + lock); } } return ret; @@ -998,14 +1002,14 @@ AmendmentTableImpl::getJson(bool isAdmin) const json::Value AmendmentTableImpl::getJson(uint256 const& amendmentID, bool isAdmin) const { - json::Value ret = json::ObjectValue; + json::Value ret = json::ValueType::Object; { std::scoped_lock const lock(mutex_); AmendmentState const* a = get(amendmentID, lock); if (a != nullptr) { - json::Value& jAmendment = (ret[to_string(amendmentID)] = json::ObjectValue); + json::Value& jAmendment = (ret[to_string(amendmentID)] = json::ValueType::Object); injectJson(jAmendment, amendmentID, *a, isAdmin, lock); } } diff --git a/src/xrpld/app/misc/detail/Transaction.cpp b/src/xrpld/app/misc/detail/Transaction.cpp index 2975a5f622..425a5723fb 100644 --- a/src/xrpld/app/misc/detail/Transaction.cpp +++ b/src/xrpld/app/misc/detail/Transaction.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include // IWYU pragma: keep #include #include @@ -150,12 +150,14 @@ json::Value Transaction::getJson(JsonOptions options, bool binary) const { // Note, we explicitly suppress `include_date` option here - json::Value ret(transaction_->getJson(options & ~JsonOptions::KIncludeDate, binary)); + json::Value ret(transaction_->getJson( + options & ~static_cast(JsonOptions::Values::IncludeDate), + binary)); // NOTE Binary STTx::getJson output might not be a JSON object if (ret.isObject() && (ledgerIndex_ != 0u)) { - if (!(options & JsonOptions::KDisableApiPriorV2)) + if (!(options & JsonOptions::Values::DisableApiPriorV2)) { // Behaviour before API version 2 ret[jss::inLedger] = ledgerIndex_; @@ -165,7 +167,7 @@ Transaction::getJson(JsonOptions options, bool binary) const // `ledger_index` elements (taking precedence over include_date) ret[jss::ledger_index] = ledgerIndex_; - if (options & JsonOptions::KIncludeDate) + if (options & JsonOptions::Values::IncludeDate) { auto ct = app_.getLedgerMaster().getCloseTimeBySeq(ledgerIndex_); if (ct) diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp index 8b478f964e..c270ddbe2d 100644 --- a/src/xrpld/app/misc/detail/TxQ.cpp +++ b/src/xrpld/app/misc/detail/TxQ.cpp @@ -744,6 +744,9 @@ TxQ::apply( if (auto directApplied = tryDirectApply(app, view, tx, flags, j)) return *directApplied; + if ((flags & TapDryRun) != 0u) + return {telCAN_NOT_QUEUE, false}; + // If we get past tryDirectApply() without returning then we expect // one of the following to occur: // @@ -1825,9 +1828,9 @@ TxQ::doRPC(Application& app) const auto const metrics = getMetrics(*view); - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); - auto& levels = ret[jss::levels] = json::ObjectValue; + auto& levels = ret[jss::levels] = json::ValueType::Object; ret[jss::ledger_current_index] = view->header().seq; ret[jss::expected_ledger_size] = std::to_string(metrics.txPerLedger); diff --git a/src/xrpld/app/misc/detail/ValidatorList.cpp b/src/xrpld/app/misc/detail/ValidatorList.cpp index 1576d398f8..415557ae48 100644 --- a/src/xrpld/app/misc/detail/ValidatorList.cpp +++ b/src/xrpld/app/misc/detail/ValidatorList.cpp @@ -312,7 +312,7 @@ ValidatorList::buildFileData( std::optional forceVersion, beast::Journal j) { - json::Value value(json::ObjectValue); + json::Value value(json::ValueType::Object); XRPL_ASSERT( pubCollection.rawVersion == 2 || pubCollection.remaining.empty(), @@ -336,11 +336,11 @@ ValidatorList::buildFileData( break; } case 2: { - json::Value blobs(json::ArrayValue); + json::Value blobs(json::ValueType::Array); auto add = [&blobs, &outerManifest = pubCollection.rawManifest](PublisherList const& pubList) { - auto& blob = blobs.append(json::ObjectValue); + auto& blob = blobs.append(json::ValueType::Object); blob[jss::blob] = pubList.rawBlob; blob[jss::signature] = pubList.rawSignature; if (pubList.rawManifest && *pubList.rawManifest != outerManifest) @@ -359,7 +359,7 @@ ValidatorList::buildFileData( } default: JLOG(j.trace()) << "Invalid VL version provided: " << effectiveVersion; - value = json::NullValue; + value = json::ValueType::Null; } return value; @@ -1605,14 +1605,14 @@ ValidatorList::expires() const json::Value ValidatorList::getJson() const { - json::Value res(json::ObjectValue); + json::Value res(json::ValueType::Object); std::shared_lock const readLock{mutex_}; res[jss::validation_quorum] = static_cast(quorum_); { - auto& x = (res[jss::validator_list] = json::ObjectValue); + auto& x = (res[jss::validator_list] = json::ValueType::Object); x[jss::count] = static_cast(count(readLock)); @@ -1647,16 +1647,16 @@ ValidatorList::getJson() const } // Validator keys listed in the local config file - json::Value& jLocalStaticKeys = (res[jss::local_static_keys] = json::ArrayValue); + json::Value& jLocalStaticKeys = (res[jss::local_static_keys] = json::ValueType::Array); for (auto const& key : localPublisherList_.list) jLocalStaticKeys.append(toBase58(TokenType::NodePublic, key)); // Publisher lists - json::Value& jPublisherLists = (res[jss::publisher_lists] = json::ArrayValue); + json::Value& jPublisherLists = (res[jss::publisher_lists] = json::ValueType::Array); for (auto const& [publicKey, pubCollection] : publisherLists_) { - json::Value& curr = jPublisherLists.append(json::ObjectValue); + json::Value& curr = jPublisherLists.append(json::ValueType::Object); curr[jss::pubkey_publisher] = strHex(publicKey); curr[jss::available] = pubCollection.status == PublisherStatus::Available; @@ -1669,7 +1669,7 @@ ValidatorList::getJson() const } if (publisherList.validFrom != TimeKeeper::time_point{}) target[jss::effective] = to_string(publisherList.validFrom); - json::Value& keys = (target[jss::list] = json::ArrayValue); + json::Value& keys = (target[jss::list] = json::ValueType::Array); for (auto const& key : publisherList.list) { keys.append(toBase58(TokenType::NodePublic, key)); @@ -1684,13 +1684,13 @@ ValidatorList::getJson() const } } - json::Value remaining(json::ArrayValue); + json::Value remaining(json::ValueType::Array); for (auto const& [sequence, future] : pubCollection.remaining) { using namespace std::chrono_literals; (void)sequence; - json::Value& r = remaining.append(json::ObjectValue); + json::Value& r = remaining.append(json::ValueType::Object); appendList(future, r); // Race conditions can happen, so make this check "fuzzy" XRPL_ASSERT( @@ -1702,14 +1702,14 @@ ValidatorList::getJson() const } // Trusted validator keys - json::Value& jValidatorKeys = (res[jss::trusted_validator_keys] = json::ArrayValue); + json::Value& jValidatorKeys = (res[jss::trusted_validator_keys] = json::ValueType::Array); for (auto const& k : trustedMasterKeys_) { jValidatorKeys.append(toBase58(TokenType::NodePublic, k)); } // signing keys - json::Value& jSigningKeys = (res[jss::signing_keys] = json::ObjectValue); + json::Value& jSigningKeys = (res[jss::signing_keys] = json::ValueType::Object); validatorManifests_.forEachManifest([&jSigningKeys, this](Manifest const& manifest) { auto it = keyListings_.find(manifest.masterKey); if (it != keyListings_.end() && manifest.signingKey) @@ -1722,7 +1722,7 @@ ValidatorList::getJson() const // Negative UNL if (!negativeUNL_.empty()) { - json::Value& jNegativeUNL = (res[jss::NegativeUNL] = json::ArrayValue); + json::Value& jNegativeUNL = (res[jss::NegativeUNL] = json::ValueType::Array); for (auto const& k : negativeUNL_) { jNegativeUNL.append(toBase58(TokenType::NodePublic, k)); diff --git a/src/xrpld/app/misc/detail/ValidatorSite.cpp b/src/xrpld/app/misc/detail/ValidatorSite.cpp index 57734ef956..534429307a 100644 --- a/src/xrpld/app/misc/detail/ValidatorSite.cpp +++ b/src/xrpld/app/misc/detail/ValidatorSite.cpp @@ -670,13 +670,13 @@ ValidatorSite::getJson() const using namespace std::chrono; using Int = json::Value::Int; - json::Value jrr(json::ObjectValue); - json::Value& jSites = (jrr[jss::validator_sites] = json::ArrayValue); + json::Value jrr(json::ValueType::Object); + json::Value& jSites = (jrr[jss::validator_sites] = json::ValueType::Array); { std::scoped_lock const lock{sites_mutex_}; for (Site const& site : sites_) { - json::Value& v = jSites.append(json::ObjectValue); + json::Value& v = jSites.append(json::ValueType::Object); std::stringstream uri; uri << site.loadedResource->uri; if (site.loadedResource != site.startingResource) diff --git a/src/xrpld/app/rdb/backend/detail/Node.cpp b/src/xrpld/app/rdb/backend/detail/Node.cpp index 8530fb2e65..ad7f44c98d 100644 --- a/src/xrpld/app/rdb/backend/detail/Node.cpp +++ b/src/xrpld/app/rdb/backend/detail/Node.cpp @@ -39,7 +39,7 @@ #include #include -#include +#include // IWYU pragma: keep #include #include @@ -87,7 +87,7 @@ toString(TableType type) return "AccountTransactions"; // LCOV_EXCL_START default: - UNREACHABLE("xrpl::detail::to_string : invalid TableType"); + UNREACHABLE("xrpl::detail::toString : invalid TableType"); return "Unknown"; // LCOV_EXCL_STOP } @@ -230,7 +230,7 @@ saveValidatedLedger( // LCOV_EXCL_STOP } - if (ledger->header().accountHash != ledger->stateMap().getHash().asUint256()) + if (ledger->header().accountHash != ledger->stateMap().getHash().asUInt256()) { // LCOV_EXCL_START JLOG(j.fatal()) << "sAL: " << ledger->header().accountHash @@ -241,7 +241,7 @@ saveValidatedLedger( } XRPL_ASSERT( - ledger->header().txHash == ledger->txMap().getHash().asUint256(), + ledger->header().txHash == ledger->txMap().getHash().asUInt256(), "xrpl::detail::saveValidatedLedger : transaction hash match"); // Save the ledger header in the hashed object store @@ -358,7 +358,7 @@ saveValidatedLedger( // It's okay for pseudo transactions to not affect any // accounts. But otherwise... JLOG(j.warn()) << "Transaction in ledger " << seq << " affects no accounts"; - JLOG(j.warn()) << sleTxn->getJson(JsonOptions::KNone); + JLOG(j.warn()) << sleTxn->getJson(JsonOptions::Values::None); } *db diff --git a/src/xrpld/app/rdb/detail/PeerFinder.cpp b/src/xrpld/app/rdb/detail/PeerFinder.cpp index 7227c65663..2481b63d2b 100644 --- a/src/xrpld/app/rdb/detail/PeerFinder.cpp +++ b/src/xrpld/app/rdb/detail/PeerFinder.cpp @@ -9,7 +9,7 @@ #include #include -#include +#include // IWYU pragma: keep #include #include diff --git a/src/xrpld/consensus/Consensus.h b/src/xrpld/consensus/Consensus.h index e5c06bd1c8..d2c5faca22 100644 --- a/src/xrpld/consensus/Consensus.h +++ b/src/xrpld/consensus/Consensus.h @@ -932,7 +932,7 @@ Consensus::getJson(bool full) const using std::to_string; using Int = json::Value::Int; - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret["proposing"] = (mode_.get() == ConsensusMode::Proposing); ret["proposers"] = static_cast(currPeerPositions_.size()); @@ -968,7 +968,7 @@ Consensus::getJson(bool full) const if (!currPeerPositions_.empty()) { - json::Value ppj(json::ObjectValue); + json::Value ppj(json::ValueType::Object); for (auto const& [nodeId, peerPos] : currPeerPositions_) { @@ -979,7 +979,7 @@ Consensus::getJson(bool full) const if (!acquired_.empty()) { - json::Value acq(json::ArrayValue); + json::Value acq(json::ValueType::Array); for (auto const& at : acquired_) { acq.append(to_string(at.first)); @@ -989,7 +989,7 @@ Consensus::getJson(bool full) const if (result_ && !result_->disputes.empty()) { - json::Value dsj(json::ObjectValue); + json::Value dsj(json::ValueType::Object); for (auto const& [txId, dispute] : result_->disputes) { dsj[to_string(txId)] = dispute.getJson(); @@ -999,7 +999,7 @@ Consensus::getJson(bool full) const if (!rawCloseTimes_.peers.empty()) { - json::Value ctj(json::ObjectValue); + json::Value ctj(json::ValueType::Object); for (auto const& ct : rawCloseTimes_.peers) { ctj[std::to_string(ct.first.time_since_epoch().count())] = ct.second; @@ -1009,7 +1009,7 @@ Consensus::getJson(bool full) const if (!deadNodes_.empty()) { - json::Value dnj(json::ArrayValue); + json::Value dnj(json::ValueType::Array); for (auto const& dn : deadNodes_) { dnj.append(to_string(dn)); diff --git a/src/xrpld/consensus/ConsensusProposal.h b/src/xrpld/consensus/ConsensusProposal.h index ebfe61711a..24a31b3820 100644 --- a/src/xrpld/consensus/ConsensusProposal.h +++ b/src/xrpld/consensus/ConsensusProposal.h @@ -195,7 +195,7 @@ public: { using std::to_string; - json::Value ret = json::ObjectValue; + json::Value ret = json::ValueType::Object; ret[jss::previous_ledger] = to_string(prevLedger()); if (!isBowOut()) diff --git a/src/xrpld/consensus/DisputedTx.h b/src/xrpld/consensus/DisputedTx.h index 795f399d1f..e888b95ed6 100644 --- a/src/xrpld/consensus/DisputedTx.h +++ b/src/xrpld/consensus/DisputedTx.h @@ -320,7 +320,7 @@ DisputedTx::getJson() const { using std::to_string; - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret["yays"] = yays_; ret["nays"] = nays_; @@ -328,7 +328,7 @@ DisputedTx::getJson() const if (!votes_.empty()) { - json::Value votes(json::ObjectValue); + json::Value votes(json::ValueType::Object); for (auto const& [nodeId, vote] : votes_) votes[to_string(nodeId)] = vote; ret["votes"] = std::move(votes); diff --git a/src/xrpld/consensus/LedgerTrie.h b/src/xrpld/consensus/LedgerTrie.h index 022219f822..9d76c7f283 100644 --- a/src/xrpld/consensus/LedgerTrie.h +++ b/src/xrpld/consensus/LedgerTrie.h @@ -232,7 +232,7 @@ struct Node res["branchSupport"] = branchSupport; if (!children.empty()) { - json::Value& cs = (res["children"] = json::ArrayValue); + json::Value& cs = (res["children"] = json::ValueType::Array); for (auto const& child : children) { cs.append(child->getJson()); @@ -779,7 +779,7 @@ public: { json::Value res; res["trie"] = root_->getJson(); - res["seq_support"] = json::ObjectValue; + res["seq_support"] = json::ValueType::Object; for (auto const& [seq, sup] : seqSupport_) res["seq_support"][to_string(seq)] = sup; return res; diff --git a/src/xrpld/core/Config.h b/src/xrpld/core/Config.h index 10fbadaae7..4936906a9a 100644 --- a/src/xrpld/core/Config.h +++ b/src/xrpld/core/Config.h @@ -51,10 +51,10 @@ struct FeeSetup XRPAmount reference_fee{10}; /** The account reserve requirement in drops. */ - XRPAmount account_reserve{10 * kDROPS_PER_XRP}; + XRPAmount account_reserve{1'000'000}; // 1 XRP /** The per-owned item reserve requirement in drops. */ - XRPAmount owner_reserve{2 * kDROPS_PER_XRP}; + XRPAmount owner_reserve{200'000}; // 0.2 XRP /* (Remember to update the example cfg files when changing any of these * values.) */ diff --git a/src/xrpld/overlay/Overlay.h b/src/xrpld/overlay/Overlay.h index 80430293d8..ef97ea7f24 100644 --- a/src/xrpld/overlay/Overlay.h +++ b/src/xrpld/overlay/Overlay.h @@ -47,6 +47,7 @@ public: std::uint32_t crawlOptions = 0; std::optional networkID; bool vlEnabled = true; + bool verifyEndpoints = true; }; using PeerSequence = std::vector>; diff --git a/src/xrpld/overlay/detail/Handshake.cpp b/src/xrpld/overlay/detail/Handshake.cpp index af0585f8ad..b32d5280e2 100644 --- a/src/xrpld/overlay/detail/Handshake.cpp +++ b/src/xrpld/overlay/detail/Handshake.cpp @@ -132,7 +132,7 @@ makeFeaturesResponseHeader( this topic, see https://github.com/openssl/openssl/issues/5509 and https://github.com/XRPLF/rippled/issues/2413. */ -static std::optional> +static std::optional> hashLastMessage(SSL const* ssl, size_t (*get)(const SSL*, void*, size_t)) { constexpr std::size_t kSSL_MINIMUM_FINISHED_LENGTH = 12; @@ -145,7 +145,7 @@ hashLastMessage(SSL const* ssl, size_t (*get)(const SSL*, void*, size_t)) sha512_hasher const h; - BaseUint<512> cookie; + BaseUInt<512> cookie; SHA512(buf, len, cookie.data()); return cookie; } diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp index e21d00a1e7..770df6e43a 100644 --- a/src/xrpld/overlay/detail/OverlayImpl.cpp +++ b/src/xrpld/overlay/detail/OverlayImpl.cpp @@ -92,15 +92,11 @@ namespace xrpl { namespace CrawlOptions { -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - Disabled = 0, - Overlay = (1 << 0), - ServerInfo = (1 << 1), - ServerCounts = (1 << 2), - Unl = (1 << 3) -}; +static constexpr auto kDISABLED = 0; +static constexpr auto kOVERLAY = (1 << 0); +static constexpr auto kSERVER_INFO = (1 << 1); +static constexpr auto kSERVER_COUNTS = (1 << 2); +static constexpr auto kUNL = (1 << 3); } // namespace CrawlOptions //------------------------------------------------------------------------------ @@ -157,7 +153,7 @@ OverlayImpl::Timer::onTimer(error_code ec) if (overlay_.app_.config().TX_REDUCE_RELAY_ENABLE) overlay_.sendTxQueue(); - if ((++overlay_.timer_count_ % Tuning::CheckIdlePeers) == 0) + if ((++overlay_.timer_count_ % Tuning::kCHECK_IDLE_PEERS) == 0) overlay_.deleteIdlePeers(); asyncWait(); @@ -396,9 +392,9 @@ OverlayImpl::makeRedirectResponse( } msg.insert("Content-Type", "application/json"); msg.insert(boost::beast::http::field::connection, "close"); - msg.body() = json::ObjectValue; + msg.body() = json::ValueType::Object; { - json::Value& ips = (msg.body()["peer-ips"] = json::ArrayValue); + json::Value& ips = (msg.body()["peer-ips"] = json::ValueType::Array); for (auto const& _ : peerFinder_->redirect(slot)) ips.append(_.address.toString()); } @@ -475,14 +471,14 @@ OverlayImpl::addActive(std::shared_ptr const& peer) { auto const result = peers_.emplace(peer->slot(), peer); - XRPL_ASSERT(result.second, "xrpl::OverlayImpl::add_active : peer is inserted"); + XRPL_ASSERT(result.second, "xrpl::OverlayImpl::addActive : peer is inserted"); (void)result.second; } { auto const result = ids_.emplace( std::piecewise_construct, std::make_tuple(peer->id()), std::make_tuple(peer)); - XRPL_ASSERT(result.second, "xrpl::OverlayImpl::add_active : peer ID is inserted"); + XRPL_ASSERT(result.second, "xrpl::OverlayImpl::addActive : peer ID is inserted"); (void)result.second; } @@ -512,7 +508,8 @@ OverlayImpl::start() app_.config(), serverHandler_.setup().overlay.port(), app_.getValidationPublicKey().has_value(), - setup_.ipLimit); + setup_.ipLimit, + setup_.verifyEndpoints); peerFinder_->setConfig(config); peerFinder_->start(); @@ -749,10 +746,10 @@ OverlayImpl::getOverlayInfo() const { using namespace std::chrono; json::Value jv; - auto& av = jv[jss::active] = json::Value(json::ArrayValue); + auto& av = jv[jss::active] = json::Value(json::ValueType::Array); forEach([&](std::shared_ptr const& sp) { - auto& pv = av.append(json::Value(json::ObjectValue)); + auto& pv = av.append(json::Value(json::ValueType::Object)); pv[jss::public_key] = base64Encode(sp->getNodePublic().data(), sp->getNodePublic().size()); pv[jss::type] = sp->slot()->inbound() ? jss::in : jss::out; pv[jss::uptime] = static_cast(duration_cast(sp->uptime()).count()); @@ -865,7 +862,7 @@ OverlayImpl::json() bool OverlayImpl::processCrawl(http_request_type const& req, Handoff& handoff) { - if (req.target() != "/crawl" || setup_.crawlOptions == CrawlOptions::Disabled) + if (req.target() != "/crawl" || setup_.crawlOptions == CrawlOptions::kDISABLED) return false; boost::beast::http::response msg; @@ -876,19 +873,19 @@ OverlayImpl::processCrawl(http_request_type const& req, Handoff& handoff) msg.insert("Connection", "close"); msg.body()["version"] = json::Value(2u); - if ((setup_.crawlOptions & CrawlOptions::Overlay) != 0u) + if ((setup_.crawlOptions & CrawlOptions::kOVERLAY) != 0u) { msg.body()["overlay"] = getOverlayInfo(); } - if ((setup_.crawlOptions & CrawlOptions::ServerInfo) != 0u) + if ((setup_.crawlOptions & CrawlOptions::kSERVER_INFO) != 0u) { msg.body()["server"] = getServerInfo(); } - if ((setup_.crawlOptions & CrawlOptions::ServerCounts) != 0u) + if ((setup_.crawlOptions & CrawlOptions::kSERVER_COUNTS) != 0u) { msg.body()["counts"] = getServerCounts(); } - if ((setup_.crawlOptions & CrawlOptions::Unl) != 0u) + if ((setup_.crawlOptions & CrawlOptions::kUNL) != 0u) { msg.body()["unl"] = getUnlInfo(); } @@ -920,7 +917,7 @@ OverlayImpl::processValidatorList(http_request_type const& req, Handoff& handoff msg.result(status); msg.insert("Content-Length", "0"); - msg.body() = json::NullValue; + msg.body() = json::ValueType::Null; msg.prepare_payload(); handoff.response = std::make_shared(msg); @@ -989,7 +986,7 @@ OverlayImpl::processHealth(http_request_type const& req, Handoff& handoff) auto health = HealthState::Healthy; auto setHealth = [&health](HealthState state) { health = std::max(health, state); }; - msg.body()[jss::info] = json::ObjectValue; + msg.body()[jss::info] = json::ValueType::Object; if (lastValidatedLedgerAge >= 7 || lastValidatedLedgerAge < 0) { msg.body()[jss::info][jss::validated_ledger] = lastValidatedLedgerAge; @@ -1514,7 +1511,7 @@ OverlayImpl::deleteIdlePeers() //------------------------------------------------------------------------------ Overlay::Setup -setupOverlay(BasicConfig const& config) +setupOverlay(BasicConfig const& config, beast::Journal j) { Overlay::Setup setup; @@ -1532,9 +1529,17 @@ setupOverlay(BasicConfig const& config) { boost::system::error_code ec; setup.publicIp = boost::asio::ip::make_address(ip, ec); - if (ec || beast::IP::isPrivate(setup.publicIp)) + if (ec || !beast::IP::isPublic(setup.publicIp)) Throw("Configured public IP is invalid"); } + + set(setup.verifyEndpoints, true, "verify_endpoints", section); + if (!setup.verifyEndpoints) + { + JLOG(j.warn()) << "Endpoint verification is disabled. This is a " + "security risk and should only be used for " + "testing."; + } } { @@ -1566,19 +1571,19 @@ setupOverlay(BasicConfig const& config) { if (get(section, "overlay", true)) { - setup.crawlOptions |= CrawlOptions::Overlay; + setup.crawlOptions |= CrawlOptions::kOVERLAY; } if (get(section, "server", true)) { - setup.crawlOptions |= CrawlOptions::ServerInfo; + setup.crawlOptions |= CrawlOptions::kSERVER_INFO; } if (get(section, "counts", false)) { - setup.crawlOptions |= CrawlOptions::ServerCounts; + setup.crawlOptions |= CrawlOptions::kSERVER_COUNTS; } if (get(section, "unl", true)) { - setup.crawlOptions |= CrawlOptions::Unl; + setup.crawlOptions |= CrawlOptions::kUNL; } } } diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp index fa65cb604a..7d1dd27528 100644 --- a/src/xrpld/overlay/detail/PeerImp.cpp +++ b/src/xrpld/overlay/detail/PeerImp.cpp @@ -193,7 +193,7 @@ PeerImp::~PeerImp() // Helper function to check for valid uint256 values in protobuf buffers static bool -stringIsUint256Sized(std::string const& pBuffStr) +stringIsUInt256Sized(std::string const& pBuffStr) { return pBuffStr.size() == uint256::size(); } @@ -212,7 +212,7 @@ PeerImp::run() return ret; if (auto const s = base64Decode(value); s.size() == uint256::size()) - return uint256{s}; + return uint256::fromRaw(s); return std::nullopt; }; @@ -322,14 +322,14 @@ PeerImp::send(std::shared_ptr const& m) auto sendqSize = sendQueue_.size(); - if (sendqSize < Tuning::TargetSendQueue) + if (sendqSize < Tuning::kTARGET_SEND_QUEUE) { // To detect a peer that does not read from their // side of the connection, we expect a peer to have // a small senq periodically largeSendq_ = 0; } - else if (auto sink = journal_.debug(); sink && (sendqSize % Tuning::SendQueueLogFreq) == 0) + else if (auto sink = journal_.debug(); sink && (sendqSize % Tuning::kSEND_QUEUE_LOG_FREQ) == 0) { std::string const n = name(); sink << n << " sendq: " << sendqSize; @@ -445,7 +445,7 @@ PeerImp::getVersion() const json::Value PeerImp::json() { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret[jss::public_key] = toBase58(TokenType::NodePublic, publicKey_); ret[jss::address] = remoteAddress_.toString(); @@ -547,7 +547,7 @@ PeerImp::json() } } - ret[jss::metrics] = json::Value(json::ObjectValue); + ret[jss::metrics] = json::Value(json::ValueType::Object); ret[jss::metrics][jss::total_bytes_recv] = std::to_string(metrics_.recv.totalBytes()); ret[jss::metrics][jss::total_bytes_sent] = std::to_string(metrics_.sent.totalBytes()); ret[jss::metrics][jss::avg_bps_recv] = std::to_string(metrics_.recv.averageBytes()); @@ -651,7 +651,7 @@ PeerImp::fail(std::string const& reason) return; // Call to name() locks, log only if the message will be outputted - if (journal_.active(beast::severities::KWarning)) + if (journal_.active(beast::Severity::Warning)) { std::string const n = name(); JLOG(journal_.warn()) << n << " failed: " << reason; @@ -802,7 +802,7 @@ PeerImp::onTimer(error_code const& ec) return; } - if (largeSendq_++ >= Tuning::SendqIntervals) + if (largeSendq_++ >= Tuning::kSENDQ_INTERVALS) { fail("Large send queue"); return; @@ -1590,7 +1590,7 @@ PeerImp::onMessage(std::shared_ptr const& m) } // Verify ledger hash - if (m->has_ledgerhash() && !stringIsUint256Sized(m->ledgerhash())) + if (m->has_ledgerhash() && !stringIsUInt256Sized(m->ledgerhash())) { badData("Invalid ledger hash"); return; @@ -1640,7 +1640,7 @@ PeerImp::onMessage(std::shared_ptr const& m) // Verify query depth if (m->has_querydepth()) { - if (m->querydepth() > Tuning::MaxQueryDepth || itype == protocol::liBASE) + if (m->querydepth() > Tuning::kMAX_QUERY_DEPTH || itype == protocol::liBASE) { badData("Invalid query depth"); return; @@ -1764,7 +1764,7 @@ PeerImp::onMessage(std::shared_ptr const& m) }; // Verify ledger hash - if (!stringIsUint256Sized(m->ledgerhash())) + if (!stringIsUInt256Sized(m->ledgerhash())) { badData("Invalid ledger hash"); return; @@ -1810,7 +1810,7 @@ PeerImp::onMessage(std::shared_ptr const& m) } // Verify ledger nodes. - if (m->nodes_size() <= 0 || m->nodes_size() > Tuning::HardMaxReplyNodes) + if (m->nodes_size() <= 0 || m->nodes_size() > Tuning::kHARD_MAX_REPLY_NODES) { badData("Invalid Ledger/TXset nodes " + std::to_string(m->nodes_size())); return; @@ -1831,7 +1831,7 @@ PeerImp::onMessage(std::shared_ptr const& m) return; } - uint256 const ledgerHash{m->ledgerhash()}; + uint256 const ledgerHash = uint256::fromRaw(m->ledgerhash()); // Otherwise check if received data for a candidate transaction set if (m->type() == protocol::liTS_CANDIDATE) @@ -1867,7 +1867,7 @@ PeerImp::onMessage(std::shared_ptr const& m) return; } - if (!stringIsUint256Sized(set.currenttxhash()) || !stringIsUint256Sized(set.previousledger())) + if (!stringIsUInt256Sized(set.currenttxhash()) || !stringIsUInt256Sized(set.previousledger())) { JLOG(pJournal_.warn()) << "Proposal: malformed"; fee_.update(Resource::kFEE_MALFORMED_REQUEST, "bad hashes"); @@ -1893,8 +1893,8 @@ PeerImp::onMessage(std::shared_ptr const& m) return; } - uint256 const proposeHash{set.currenttxhash()}; - uint256 const prevLedger{set.previousledger()}; + uint256 const proposeHash = uint256::fromRaw(set.currenttxhash()); + uint256 const prevLedger = uint256::fromRaw(set.previousledger()); NetClock::time_point const closeTime{NetClock::duration{set.closetime()}}; @@ -2001,7 +2001,7 @@ PeerImp::onMessage(std::shared_ptr const& m) { uint256 closedLedgerHash{}; - bool const peerChangedLedgers{m->has_ledgerhash() && stringIsUint256Sized(m->ledgerhash())}; + bool const peerChangedLedgers{m->has_ledgerhash() && stringIsUInt256Sized(m->ledgerhash())}; { // Operations on closedLedgerHash_ and previousLedgerHash_ must be @@ -2018,7 +2018,7 @@ PeerImp::onMessage(std::shared_ptr const& m) closedLedgerHash_.zero(); } - if (m->has_ledgerhashprevious() && stringIsUint256Sized(m->ledgerhashprevious())) + if (m->has_ledgerhashprevious() && stringIsUInt256Sized(m->ledgerhashprevious())) { previousLedgerHash_ = m->ledgerhashprevious(); addLedger(previousLedgerHash_, sl); @@ -2055,7 +2055,7 @@ PeerImp::onMessage(std::shared_ptr const& m) } app_.getOPs().pubPeerStatus([m, this]() -> json::Value { - json::Value j = json::ObjectValue; + json::Value j = json::ValueType::Object; if (m->has_newstatus()) { @@ -2152,13 +2152,13 @@ PeerImp::checkTracking(std::uint32_t seq1, std::uint32_t seq2) { int const diff = std::max(seq1, seq2) - std::min(seq1, seq2); - if (diff < Tuning::ConvergedLedgerLimit) + if (diff < Tuning::kCONVERGED_LEDGER_LIMIT) { // The peer's ledger sequence is close to the validation's tracking_ = Tracking::Converged; } - if ((diff > Tuning::DivergedLedgerLimit) && (tracking_.load() != Tracking::Diverged)) + if ((diff > Tuning::kDIVERGED_LEDGER_LIMIT) && (tracking_.load() != Tracking::Diverged)) { // The peer's ledger sequence is way off the validation's std::scoped_lock const sl(recentLock_); @@ -2171,13 +2171,13 @@ PeerImp::checkTracking(std::uint32_t seq1, std::uint32_t seq2) void PeerImp::onMessage(std::shared_ptr const& m) { - if (!stringIsUint256Sized(m->hash())) + if (!stringIsUInt256Sized(m->hash())) { fee_.update(Resource::kFEE_MALFORMED_REQUEST, "bad hash"); return; } - uint256 const hash{m->hash()}; + uint256 const hash = uint256::fromRaw(m->hash()); if (m->status() == protocol::tsHAVE) { @@ -2563,7 +2563,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (packet.query()) { // this is a query - if (sendQueue_.size() >= Tuning::DropSendQueue) + if (sendQueue_.size() >= Tuning::kDROP_SEND_QUEUE) { JLOG(pJournal_.debug()) << "GetObject: Large send queue"; return; @@ -2600,7 +2600,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (packet.has_ledgerhash()) { - if (!stringIsUint256Sized(packet.ledgerhash())) + if (!stringIsUInt256Sized(packet.ledgerhash())) { fee_.update(Resource::kFEE_MALFORMED_REQUEST, "ledger hash"); return; @@ -2615,9 +2615,9 @@ PeerImp::onMessage(std::shared_ptr const& m) for (int i = 0; i < packet.objects_size(); ++i) { auto const& obj = packet.objects(i); - if (obj.has_hash() && stringIsUint256Sized(obj.hash())) + if (obj.has_hash() && stringIsUInt256Sized(obj.hash())) { - uint256 const hash{obj.hash()}; + uint256 const hash = uint256::fromRaw(obj.hash()); // VFALCO TODO Move this someplace more sensible so we dont // need to inject the NodeStore interfaces. std::uint32_t const seq{obj.has_ledgerseq() ? obj.ledgerseq() : 0}; @@ -2635,7 +2635,7 @@ PeerImp::onMessage(std::shared_ptr const& m) // Check if by adding this object, reply has reached its // limit - if (reply.objects_size() >= Tuning::HardMaxReplyNodes) + if (reply.objects_size() >= Tuning::kHARD_MAX_REPLY_NODES) { fee_.update( Resource::kFEE_MODERATE_BURDEN_PEER, @@ -2661,7 +2661,7 @@ PeerImp::onMessage(std::shared_ptr const& m) { protocol::TMIndexedObject const& obj = packet.objects(i); - if (obj.has_hash() && stringIsUint256Sized(obj.hash())) + if (obj.has_hash() && stringIsUInt256Sized(obj.hash())) { if (obj.has_ledgerseq()) { @@ -2687,7 +2687,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (pLDo) { - uint256 const hash{obj.hash()}; + uint256 const hash = uint256::fromRaw(obj.hash()); app_.getLedgerMaster().addFetchPack( hash, std::make_shared(obj.data().begin(), obj.data().end())); @@ -2732,14 +2732,14 @@ PeerImp::handleHaveTransactions(std::shared_ptr co for (std::uint32_t i = 0; i < m->hashes_size(); i++) { - if (!stringIsUint256Sized(m->hashes(i))) + if (!stringIsUInt256Sized(m->hashes(i))) { JLOG(pJournal_.error()) << "TMHaveTransactions with invalid hash size"; fee_.update(Resource::kFEE_MALFORMED_REQUEST, "hash size"); return; } - uint256 hash(m->hashes(i)); + uint256 hash = uint256::fromRaw(m->hashes(i)); auto txn = app_.getMasterTransaction().fetchFromCache(hash); @@ -2864,7 +2864,7 @@ PeerImp::doFetchPack(std::shared_ptr const& packet) return; } - if (!stringIsUint256Sized(packet->ledgerhash())) + if (!stringIsUInt256Sized(packet->ledgerhash())) { JLOG(pJournal_.warn()) << "FetchPack hash size malformed"; fee_.update(Resource::kFEE_MALFORMED_REQUEST, "hash size"); @@ -2873,7 +2873,7 @@ PeerImp::doFetchPack(std::shared_ptr const& packet) fee_.fee = Resource::kFEE_HEAVY_BURDEN_PEER; - uint256 const hash{packet->ledgerhash()}; + uint256 const hash = uint256::fromRaw(packet->ledgerhash()); std::weak_ptr const weak = shared_from_this(); auto elapsed = UptimeClock::now(); @@ -2902,13 +2902,13 @@ PeerImp::doTransactions(std::shared_ptr const& pack { auto const& obj = packet->objects(i); - if (!stringIsUint256Sized(obj.hash())) + if (!stringIsUInt256Sized(obj.hash())) { fee_.update(Resource::kFEE_MALFORMED_REQUEST, "hash size"); return; } - uint256 hash(obj.hash()); + uint256 hash = uint256::fromRaw(obj.hash()); auto txn = app_.getMasterTransaction().fetchFromCache(hash); @@ -3254,7 +3254,7 @@ PeerImp::getLedger(std::shared_ptr const& m) if (m->has_ledgerhash()) { // Attempt to find ledger by hash - uint256 const ledgerHash{m->ledgerhash()}; + uint256 const ledgerHash = uint256::fromRaw(m->ledgerhash()); ledger = app_.getLedgerMaster().getLedgerByHash(ledgerHash); if (!ledger) { @@ -3333,7 +3333,7 @@ PeerImp::getTxSet(std::shared_ptr const& m) const { JLOG(pJournal_.trace()) << "getTxSet: TX set"; - uint256 const txSetHash{m->ledgerhash()}; + uint256 const txSetHash = uint256::fromRaw(m->ledgerhash()); std::shared_ptr shaMap{app_.getInboundTransactions().getSet(txSetHash, false)}; if (!shaMap) { @@ -3392,7 +3392,7 @@ PeerImp::processLedgerRequest(std::shared_ptr const& m) } else { - if (sendQueue_.size() >= Tuning::DropSendQueue) + if (sendQueue_.size() >= Tuning::kDROP_SEND_QUEUE) { JLOG(pJournal_.debug()) << "processLedgerRequest: Large send queue"; return; @@ -3454,13 +3454,13 @@ PeerImp::processLedgerRequest(std::shared_ptr const& m) std::vector> data; for (int i = 0; - i < m->nodeids_size() && ledgerData.nodes_size() < Tuning::SoftMaxReplyNodes; + i < m->nodeids_size() && ledgerData.nodes_size() < Tuning::kSOFT_MAX_REPLY_NODES; ++i) { auto const shaMapNodeId{deserializeSHAMapNodeID(m->nodeids(i))}; data.clear(); - data.reserve(Tuning::SoftMaxReplyNodes); + data.reserve(Tuning::kSOFT_MAX_REPLY_NODES); try { @@ -3472,7 +3472,7 @@ PeerImp::processLedgerRequest(std::shared_ptr const& m) for (auto const& d : data) { - if (ledgerData.nodes_size() >= Tuning::HardMaxReplyNodes) + if (ledgerData.nodes_size() >= Tuning::kHARD_MAX_REPLY_NODES) break; protocol::TMLedgerNode* node{ledgerData.add_nodes()}; node->set_nodeid(d.first.getRawString()); diff --git a/src/xrpld/overlay/detail/PeerReservationTable.cpp b/src/xrpld/overlay/detail/PeerReservationTable.cpp index ec0f914dd6..2ca85c3fd7 100644 --- a/src/xrpld/overlay/detail/PeerReservationTable.cpp +++ b/src/xrpld/overlay/detail/PeerReservationTable.cpp @@ -18,7 +18,7 @@ namespace xrpl { auto PeerReservation::toJson() const -> json::Value { - json::Value result{json::ObjectValue}; + json::Value result{json::ValueType::Object}; result[jss::node] = toBase58(TokenType::NodePublic, nodeId); if (!description.empty()) { diff --git a/src/xrpld/overlay/detail/Tuning.h b/src/xrpld/overlay/detail/Tuning.h index c54fa24498..9913dd4371 100644 --- a/src/xrpld/overlay/detail/Tuning.h +++ b/src/xrpld/overlay/detail/Tuning.h @@ -1,45 +1,38 @@ #pragma once -#include - namespace xrpl::Tuning { -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - /** How many ledgers off a server can be and we will - still consider it converged */ - ConvergedLedgerLimit = 24, +/** How many ledgers off a server can be and we will + still consider it converged */ +static constexpr auto kCONVERGED_LEDGER_LIMIT = 24; - /** How many ledgers off a server has to be before we - consider it diverged */ - DivergedLedgerLimit = 128, +/** How many ledgers off a server has to be before we + consider it diverged */ +static constexpr auto kDIVERGED_LEDGER_LIMIT = 128; - /** The soft cap on the number of ledger entries in a single reply. */ - SoftMaxReplyNodes = 8192, +/** The soft cap on the number of ledger entries in a single reply. */ +static constexpr auto kSOFT_MAX_REPLY_NODES = 8192; - /** The hard cap on the number of ledger entries in a single reply. */ - HardMaxReplyNodes = 12288, +/** The hard cap on the number of ledger entries in a single reply. */ +static constexpr auto kHARD_MAX_REPLY_NODES = 12288; - /** How many timer intervals a sendq has to stay large before we disconnect - */ - SendqIntervals = 4, +/** How many timer intervals a sendq has to stay large before we disconnect */ +static constexpr auto kSENDQ_INTERVALS = 4; - /** How many messages on a send queue before we refuse queries */ - DropSendQueue = 192, +/** How many messages on a send queue before we refuse queries */ +static constexpr auto kDROP_SEND_QUEUE = 192; - /** How many messages we consider reasonable sustained on a send queue */ - TargetSendQueue = 128, +/** How many messages we consider reasonable sustained on a send queue */ +static constexpr auto kTARGET_SEND_QUEUE = 128; - /** How often to log send queue size */ - SendQueueLogFreq = 64, +/** How often to log send queue size */ +static constexpr auto kSEND_QUEUE_LOG_FREQ = 64; - /** How often we check for idle peers (seconds) */ - CheckIdlePeers = 4, +/** How often we check for idle peers (seconds) */ +static constexpr auto kCHECK_IDLE_PEERS = 4; - /** The maximum number of levels to search */ - MaxQueryDepth = 3, -}; +/** The maximum number of levels to search */ +static constexpr auto kMAX_QUERY_DEPTH = 3; /** Size of buffer used to read from the socket. */ std::size_t constexpr kREAD_BUFFER_BYTES = 16384; diff --git a/src/xrpld/overlay/detail/TxMetrics.cpp b/src/xrpld/overlay/detail/TxMetrics.cpp index c1a336b11e..2df072ef0c 100644 --- a/src/xrpld/overlay/detail/TxMetrics.cpp +++ b/src/xrpld/overlay/detail/TxMetrics.cpp @@ -101,7 +101,7 @@ TxMetrics::json() const { std::scoped_lock const l(mutex); - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret[jss::txr_tx_cnt] = std::to_string(tx.m1.rollingAvg); ret[jss::txr_tx_sz] = std::to_string(tx.m2.rollingAvg); diff --git a/src/xrpld/overlay/make_Overlay.h b/src/xrpld/overlay/make_Overlay.h index 94d1110f4b..acd477deec 100644 --- a/src/xrpld/overlay/make_Overlay.h +++ b/src/xrpld/overlay/make_Overlay.h @@ -10,7 +10,7 @@ namespace xrpl { Overlay::Setup -setupOverlay(BasicConfig const& config); +setupOverlay(BasicConfig const& config, beast::Journal j); /** Creates the implementation of Overlay. */ std::unique_ptr diff --git a/src/xrpld/peerfinder/PeerfinderManager.h b/src/xrpld/peerfinder/PeerfinderManager.h index 072750efe7..083abf92c6 100644 --- a/src/xrpld/peerfinder/PeerfinderManager.h +++ b/src/xrpld/peerfinder/PeerfinderManager.h @@ -27,7 +27,7 @@ struct Config This includes both inbound and outbound, but does not include fixed peers. */ - std::size_t maxPeers{Tuning::DefaultMaxPeers}; + std::size_t maxPeers{Tuning::kDEFAULT_MAX_PEERS}; /** The number of automatic outbound connections to maintain. Outbound connections are only maintained if autoConnect @@ -59,6 +59,9 @@ struct Config /** Limit how many incoming connections we allow per IP */ int ipLimit{0}; + /** `true` if we want to verify endpoints in TMEndpoints messages */ + bool verifyEndpoints = true; + //-------------------------------------------------------------------------- /** Create a configuration with default values. */ @@ -81,6 +84,8 @@ struct Config * @param port server's listening port * @param validationPublicKey true if validation public key is not empty * @param ipLimit limit of incoming connections per IP + * @param verifyEndpoints `true` if we want to verify endpoints in + * TMEndpoints messages * @return PeerFinder::Config */ static Config @@ -88,10 +93,11 @@ struct Config xrpl::Config const& config, std::uint16_t port, bool validationPublicKey, - int ipLimit); + int ipLimit, + bool verifyEndpoints); friend bool - operator==(Config const& lhs, Config const& rhs); + operator==(Config const& lhs, Config const& rhs) = default; }; //------------------------------------------------------------------------------ diff --git a/src/xrpld/peerfinder/detail/Bootcache.cpp b/src/xrpld/peerfinder/detail/Bootcache.cpp index 140d0f01c6..269b6cc757 100644 --- a/src/xrpld/peerfinder/detail/Bootcache.cpp +++ b/src/xrpld/peerfinder/detail/Bootcache.cpp @@ -143,7 +143,7 @@ Bootcache::onSuccess(beast::IP::Endpoint const& endpoint) ++entry.valence(); map_.erase(result.first); result = map_.insert(value_type(endpoint, entry)); - XRPL_ASSERT(result.second, "xrpl::PeerFinder::Bootcache::on_success : endpoint inserted"); + XRPL_ASSERT(result.second, "xrpl::PeerFinder::Bootcache::onSuccess : endpoint inserted"); } Entry const& entry(result.first->right); JLOG(journal_.info()) << beast::Leftw(18) << "Bootcache connect " << endpoint << " with " @@ -166,7 +166,7 @@ Bootcache::onFailure(beast::IP::Endpoint const& endpoint) --entry.valence(); map_.erase(result.first); result = map_.insert(value_type(endpoint, entry)); - XRPL_ASSERT(result.second, "xrpl::PeerFinder::Bootcache::on_failure : endpoint inserted"); + XRPL_ASSERT(result.second, "xrpl::PeerFinder::Bootcache::onFailure : endpoint inserted"); } Entry const& entry(result.first->right); auto const n(std::abs(entry.valence())); @@ -199,11 +199,11 @@ Bootcache::onWrite(beast::PropertyStream::Map& map) void Bootcache::prune() { - if (size() <= Tuning::BootcacheSize) + if (size() <= Tuning::kBOOTCACHE_SIZE) return; // Calculate the amount to remove - auto count((size() * Tuning::BootcachePrunePercent) / 100); + auto count((size() * Tuning::kBOOTCACHE_PRUNE_PERCENT) / 100); decltype(count) pruned(0); // Work backwards because bimap doesn't handle diff --git a/src/xrpld/peerfinder/detail/Counts.h b/src/xrpld/peerfinder/detail/Counts.h index e859b09d21..9fee2efadb 100644 --- a/src/xrpld/peerfinder/detail/Counts.h +++ b/src/xrpld/peerfinder/detail/Counts.h @@ -51,9 +51,9 @@ public: [[nodiscard]] std::size_t attemptsNeeded() const { - if (attempts_ >= Tuning::MaxConnectAttempts) + if (attempts_ >= Tuning::kMAX_CONNECT_ATTEMPTS) return 0; - return Tuning::MaxConnectAttempts - attempts_; + return Tuning::kMAX_CONNECT_ATTEMPTS - attempts_; } /** Returns the number of outbound connection attempts. */ diff --git a/src/xrpld/peerfinder/detail/Handouts.h b/src/xrpld/peerfinder/detail/Handouts.h index f4c7483e3f..b26a44015d 100644 --- a/src/xrpld/peerfinder/detail/Handouts.h +++ b/src/xrpld/peerfinder/detail/Handouts.h @@ -23,7 +23,7 @@ template std::size_t handoutOne(Target& t, HopContainer& h) { - XRPL_ASSERT(!t.full(), "xrpl::PeerFinder::detail::handout_one : target is not full"); + XRPL_ASSERT(!t.full(), "xrpl::PeerFinder::detail::handoutOne : target is not full"); for (auto it = h.begin(); it != h.end(); ++it) { auto const& e = *it; diff --git a/src/xrpld/peerfinder/detail/Livecache.h b/src/xrpld/peerfinder/detail/Livecache.h index 063fb622cf..3222a13d60 100644 --- a/src/xrpld/peerfinder/detail/Livecache.h +++ b/src/xrpld/peerfinder/detail/Livecache.h @@ -499,7 +499,7 @@ Livecache::HopsT::insert(Element& e) { XRPL_ASSERT( e.endpoint.hops <= Tuning::kMAX_HOPS + 1, - "xrpl::PeerFinder::Livecache::hops_t::insert : maximum input hops"); + "xrpl::PeerFinder::Livecache::HopsT::insert : maximum input hops"); // This has security implications without a shuffle lists_[e.endpoint.hops].push_front(e); ++hist_[e.endpoint.hops]; @@ -511,7 +511,7 @@ Livecache::HopsT::reinsert(Element& e, std::uint32_t numHops) { XRPL_ASSERT( numHops <= Tuning::kMAX_HOPS + 1, - "xrpl::PeerFinder::Livecache::hops_t::reinsert : maximum hops input"); + "xrpl::PeerFinder::Livecache::HopsT::reinsert : maximum hops input"); auto& list = lists_[e.endpoint.hops]; list.erase(list.iterator_to(e)); diff --git a/src/xrpld/peerfinder/detail/Logic.h b/src/xrpld/peerfinder/detail/Logic.h index 89e7336a33..4d0cc9cf29 100644 --- a/src/xrpld/peerfinder/detail/Logic.h +++ b/src/xrpld/peerfinder/detail/Logic.h @@ -696,7 +696,7 @@ public: } // Discard invalid addresses - if (!isValidAddress(ep.address)) + if (config_.verifyEndpoints && !isValidAddress(ep.address)) { JLOG(journal.debug()) << beast::Leftw(18) << "Endpoints drop " << ep.address << " as invalid"; @@ -745,12 +745,12 @@ public: // The object must exist in our table XRPL_ASSERT( slots.contains(slot->remoteEndpoint()), - "xrpl::PeerFinder::Logic::on_endpoints : valid slot input"); + "xrpl::PeerFinder::Logic::onEndpoints : valid slot input"); // Must be handshaked! XRPL_ASSERT( slot->state() == Slot::State::Active, - "xrpl::PeerFinder::Logic::on_endpoints : valid slot state"); + "xrpl::PeerFinder::Logic::onEndpoints : valid slot state"); clock_type::time_point const now(clock.now()); @@ -762,7 +762,7 @@ public: for (auto const& ep : list) { - XRPL_ASSERT(ep.hops, "xrpl::PeerFinder::Logic::on_endpoints : nonzero hops"); + XRPL_ASSERT(ep.hops, "xrpl::PeerFinder::Logic::onEndpoints : nonzero hops"); slot->recent.insert(ep.address, ep.hops); @@ -1088,6 +1088,8 @@ public: { if (isUnspecified(address)) return false; + if (isLoopback(address)) + return false; if (!isPublic(address)) return false; if (address.port() == 0) @@ -1205,7 +1207,7 @@ Logic::onRedirects( { std::scoped_lock const _(lock); std::size_t n = 0; - for (; first != last && n < Tuning::MaxRedirects; ++first, ++n) + for (; first != last && n < Tuning::kMAX_REDIRECTS; ++first, ++n) bootcache.insert(beast::IPAddressConversion::fromAsio(*first)); if (n > 0) { diff --git a/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp b/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp index ed9bba0ee4..a8323f6239 100644 --- a/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp +++ b/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp @@ -15,20 +15,11 @@ Config::Config() : outPeers(calcOutPeers()) { } -bool -operator==(Config const& lhs, Config const& rhs) -{ - return lhs.autoConnect == rhs.autoConnect && lhs.peerPrivate == rhs.peerPrivate && - lhs.wantIncoming == rhs.wantIncoming && lhs.inPeers == rhs.inPeers && - lhs.maxPeers == rhs.maxPeers && lhs.outPeers == rhs.outPeers && - lhs.features == rhs.features && lhs.ipLimit == rhs.ipLimit && - lhs.listeningPort == rhs.listeningPort; -} - std::size_t Config::calcOutPeers() const { - return std::max((maxPeers * Tuning::OutPercent + 50) / 100, std::size_t(Tuning::MinOutCount)); + return std::max( + (maxPeers * Tuning::kOUT_PERCENT + 50) / 100, std::size_t(Tuning::kMIN_OUT_COUNT)); } void @@ -41,8 +32,8 @@ Config::applyTuning() // IP addresses. ipLimit = 2; - if (inPeers > Tuning::DefaultMaxPeers) - ipLimit += std::min(5, static_cast(inPeers / Tuning::DefaultMaxPeers)); + if (inPeers > Tuning::kDEFAULT_MAX_PEERS) + ipLimit += std::min(5, static_cast(inPeers / Tuning::kDEFAULT_MAX_PEERS)); } // We don't allow a single IP to consume all incoming slots, @@ -60,6 +51,7 @@ Config::onWrite(beast::PropertyStream::Map& map) const map["port"] = listeningPort; map["features"] = features; map["ip_limit"] = ipLimit; + map["verify_endpoints"] = verifyEndpoints; } Config @@ -67,7 +59,8 @@ Config::makeConfig( xrpl::Config const& cfg, std::uint16_t port, bool validationPublicKey, - int ipLimit) + int ipLimit, + bool verifyEndpoints) { PeerFinder::Config config; @@ -81,7 +74,7 @@ Config::makeConfig( if (cfg.PEERS_MAX != 0) config.maxPeers = cfg.PEERS_MAX; - config.maxPeers = std::max(config.maxPeers, Tuning::MinOutCount); + config.maxPeers = std::max(config.maxPeers, Tuning::kMIN_OUT_COUNT); config.outPeers = config.calcOutPeers(); // Calculate the number of outbound peers we want. If we dont want @@ -120,6 +113,7 @@ Config::makeConfig( config.listeningPort = port; config.features = ""; config.ipLimit = ipLimit; + config.verifyEndpoints = verifyEndpoints; // Enforce business rules config.applyTuning(); diff --git a/src/xrpld/peerfinder/detail/StoreSqdb.h b/src/xrpld/peerfinder/detail/StoreSqdb.h index 13338cbd73..1239818ba3 100644 --- a/src/xrpld/peerfinder/detail/StoreSqdb.h +++ b/src/xrpld/peerfinder/detail/StoreSqdb.h @@ -15,12 +15,7 @@ private: soci::session sqlDb_; public: - // Need to be named before converting - // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) - enum { - // This determines the on-database format of the data - CurrentSchemaVersion = 4 - }; + static constexpr auto kCURRENT_SCHEMA_VERSION = 4; // on-database format version explicit StoreSqdb(beast::Journal journal = beast::Journal{beast::Journal::getNullSink()}) : journal_(journal) @@ -73,7 +68,7 @@ public: void update() { - updatePeerFinderDB(sqlDb_, CurrentSchemaVersion, journal_); + updatePeerFinderDB(sqlDb_, kCURRENT_SCHEMA_VERSION, journal_); } private: diff --git a/src/xrpld/peerfinder/detail/Tuning.h b/src/xrpld/peerfinder/detail/Tuning.h index 4fc57a69a0..92d71ff8d8 100644 --- a/src/xrpld/peerfinder/detail/Tuning.h +++ b/src/xrpld/peerfinder/detail/Tuning.h @@ -6,48 +6,39 @@ /** @{ */ namespace xrpl::PeerFinder::Tuning { -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - //--------------------------------------------------------- - // - // Automatic Connection Policy - // - //--------------------------------------------------------- +//--------------------------------------------------------- +// +// Automatic Connection Policy +// +//--------------------------------------------------------- - /** Time to wait between making batches of connection attempts */ - SecondsPerConnect = 10 +/** Time to wait between making batches of connection attempts */ +static constexpr auto kSECONDS_PER_CONNECT = 10; - /** Maximum number of simultaneous connection attempts. */ - , - MaxConnectAttempts = 20 +/** Maximum number of simultaneous connection attempts. */ +static constexpr auto kMAX_CONNECT_ATTEMPTS = 20; - /** The percentage of total peer slots that are outbound. - The number of outbound peers will be the larger of the - minOutCount and outPercent * Config::maxPeers specially - rounded. - */ - , - OutPercent = 15 +/** The percentage of total peer slots that are outbound. + The number of outbound peers will be the larger of the + minOutCount and outPercent * Config::maxPeers specially + rounded. +*/ +static constexpr auto kOUT_PERCENT = 15; - /** A hard minimum on the number of outgoing connections. - This is enforced outside the Logic, so that the unit test - can use any settings it wants. - */ - , - MinOutCount = 10 +/** A hard minimum on the number of outgoing connections. + This is enforced outside the Logic, so that the unit test + can use any settings it wants. +*/ +static constexpr auto kMIN_OUT_COUNT = 10; - /** The default value of Config::maxPeers. */ - , - DefaultMaxPeers = 21 +/** The default value of Config::maxPeers. */ +static constexpr auto kDEFAULT_MAX_PEERS = 21; - /** Max redirects we will accept from one connection. - Redirects are limited for security purposes, to prevent - the address caches from getting flooded. - */ - , - MaxRedirects = 30 -}; +/** Max redirects we will accept from one connection. + Redirects are limited for security purposes, to prevent + the address caches from getting flooded. +*/ +static constexpr auto kMAX_REDIRECTS = 30; //------------------------------------------------------------------------------ // @@ -63,16 +54,11 @@ static std::array const kCONNECTION_BACKOFF{{1, 1, 2, 3, 5, 8, 13, 21, // //------------------------------------------------------------------------------ -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - // Threshold of cache entries above which we trim. - BootcacheSize = 1000 +// Threshold of cache entries above which we trim. +static constexpr auto kBOOTCACHE_SIZE = 1000; - // The percentage of addresses we prune when we trim the cache. - , - BootcachePrunePercent = 10 -}; +// The percentage of addresses we prune when we trim the cache. +static constexpr auto kBOOTCACHE_PRUNE_PERCENT = 10; // The cool down wait between database updates // Ideally this should be larger than the time it takes a full diff --git a/src/xrpld/perflog/detail/PerfLogImp.cpp b/src/xrpld/perflog/detail/PerfLogImp.cpp index d50a4ab863..60b6efc0a9 100644 --- a/src/xrpld/perflog/detail/PerfLogImp.cpp +++ b/src/xrpld/perflog/detail/PerfLogImp.cpp @@ -72,7 +72,7 @@ PerfLogImp::Counters::Counters(std::set const& labels, JobTypes con json::Value PerfLogImp::Counters::countersJson() const { - json::Value rpcobj(json::ObjectValue); + json::Value rpcobj(json::ValueType::Object); // totalRpc represents all rpc methods. All that started, finished, etc. Rpc totalRpc; for (auto const& proc : rpc) @@ -88,7 +88,7 @@ PerfLogImp::Counters::countersJson() const value = proc.second.value; } - json::Value p(json::ObjectValue); + json::Value p(json::ValueType::Object); p[jss::started] = std::to_string(value.started); totalRpc.started += value.started; p[jss::finished] = std::to_string(value.finished); @@ -102,7 +102,7 @@ PerfLogImp::Counters::countersJson() const if (totalRpc.started != 0u) { - json::Value totalRpcJson(json::ObjectValue); + json::Value totalRpcJson(json::ValueType::Object); totalRpcJson[jss::started] = std::to_string(totalRpc.started); totalRpcJson[jss::finished] = std::to_string(totalRpc.finished); totalRpcJson[jss::errored] = std::to_string(totalRpc.errored); @@ -110,7 +110,7 @@ PerfLogImp::Counters::countersJson() const rpcobj[jss::total] = totalRpcJson; } - json::Value jobQueueObj(json::ObjectValue); + json::Value jobQueueObj(json::ValueType::Object); // totalJq represents all jobs. All enqueued, started, finished, etc. Jq totalJq; for (auto const& proc : jq) @@ -126,7 +126,7 @@ PerfLogImp::Counters::countersJson() const value = proc.second.value; } - json::Value j(json::ObjectValue); + json::Value j(json::ValueType::Object); j[jss::queued] = std::to_string(value.queued); totalJq.queued += value.queued; j[jss::started] = std::to_string(value.started); @@ -142,7 +142,7 @@ PerfLogImp::Counters::countersJson() const if (totalJq.queued != 0u) { - json::Value totalJqJson(json::ObjectValue); + json::Value totalJqJson(json::ValueType::Object); totalJqJson[jss::queued] = std::to_string(totalJq.queued); totalJqJson[jss::started] = std::to_string(totalJq.started); totalJqJson[jss::finished] = std::to_string(totalJq.finished); @@ -151,7 +151,7 @@ PerfLogImp::Counters::countersJson() const jobQueueObj[jss::total] = totalJqJson; } - json::Value counters(json::ObjectValue); + json::Value counters(json::ValueType::Object); // Be kind to reporting tools and let them expect rpc and jq objects // even if empty. counters[jss::rpc] = rpcobj; @@ -164,7 +164,7 @@ PerfLogImp::Counters::currentJson() const { auto const present = steady_clock::now(); - json::Value jobsArray(json::ArrayValue); + json::Value jobsArray(json::ValueType::Array); auto const jobs = [this] { std::scoped_lock const lock(jobsMutex); return this->jobs; @@ -174,14 +174,14 @@ PerfLogImp::Counters::currentJson() const { if (j.first == JtInvalid) continue; - json::Value jobj(json::ObjectValue); + json::Value jobj(json::ValueType::Object); jobj[jss::job] = JobTypes::name(j.first); jobj[jss::duration_us] = std::to_string(std::chrono::duration_cast(present - j.second).count()); jobsArray.append(jobj); } - json::Value methodsArray(json::ArrayValue); + json::Value methodsArray(json::ValueType::Array); std::vector methods; { std::scoped_lock const lock(methodsMutex); @@ -191,14 +191,14 @@ PerfLogImp::Counters::currentJson() const } for (auto m : methods) { - json::Value methodobj(json::ObjectValue); + json::Value methodobj(json::ValueType::Object); methodobj[jss::method] = m.first; methodobj[jss::duration_us] = std::to_string(std::chrono::duration_cast(present - m.second).count()); methodsArray.append(methodobj); } - json::Value current(json::ObjectValue); + json::Value current(json::ValueType::Object); current[jss::jobs] = jobsArray; current[jss::methods] = methodsArray; return current; @@ -277,7 +277,7 @@ PerfLogImp::report() return; lastLog_ = present; - json::Value report(json::ObjectValue); + json::Value report(json::ValueType::Object); report[jss::time] = to_string(std::chrono::floor(present)); { std::scoped_lock const lock{counters_.jobsMutex}; @@ -285,7 +285,7 @@ PerfLogImp::report() } report[jss::hostid] = hostname_; report[jss::counters] = counters_.countersJson(); - report[jss::nodestore] = json::ObjectValue; + report[jss::nodestore] = json::ValueType::Object; app_.getNodeStore().getCountsJson(report[jss::nodestore]); report[jss::current_activities] = counters_.currentJson(); app_.getOPs().stateAccounting(report); diff --git a/src/xrpld/rpc/BookChanges.h b/src/xrpld/rpc/BookChanges.h index f80de30b09..04c7a2c449 100644 --- a/src/xrpld/rpc/BookChanges.h +++ b/src/xrpld/rpc/BookChanges.h @@ -164,7 +164,7 @@ computeBookChanges(std::shared_ptr const& lpAccepted) } } - json::Value jvObj(json::ObjectValue); + json::Value jvObj(json::ValueType::Object); jvObj[jss::type] = "bookChanges"; // retrieve validated information from LedgerHeader class @@ -174,7 +174,7 @@ computeBookChanges(std::shared_ptr const& lpAccepted) jvObj[jss::ledger_time] = json::Value::UInt(lpAccepted->header().closeTime.time_since_epoch().count()); - jvObj[jss::changes] = json::ArrayValue; + jvObj[jss::changes] = json::ValueType::Array; auto volToStr = [](STAmount const& vol) { return vol.asset().visit( @@ -188,7 +188,7 @@ computeBookChanges(std::shared_ptr const& lpAccepted) for (auto const& entry : tally) { - json::Value& inner = jvObj[jss::changes].append(json::ObjectValue); + json::Value& inner = jvObj[jss::changes].append(json::ValueType::Object); STAmount const volA = std::get<0>(entry.second); STAmount const volB = std::get<1>(entry.second); diff --git a/src/xrpld/rpc/detail/DeliveredAmount.cpp b/src/xrpld/rpc/detail/DeliveredAmount.cpp index 32554e8b5f..8d8aac33bf 100644 --- a/src/xrpld/rpc/detail/DeliveredAmount.cpp +++ b/src/xrpld/rpc/detail/DeliveredAmount.cpp @@ -100,7 +100,7 @@ insertDeliveredAmount( auto amt = getDeliveredAmount(getLedgerIndex, getCloseTime, serializedTx, transactionMeta); if (amt) { - meta[jss::delivered_amount] = amt->getJson(JsonOptions::KIncludeDate); + meta[jss::delivered_amount] = amt->getJson(JsonOptions::Values::IncludeDate); } else { @@ -167,7 +167,7 @@ insertDeliveredAmount( if (amt) { - meta[jss::delivered_amount] = amt->getJson(JsonOptions::KIncludeDate); + meta[jss::delivered_amount] = amt->getJson(JsonOptions::Values::IncludeDate); } else { diff --git a/src/xrpld/rpc/detail/Handler.cpp b/src/xrpld/rpc/detail/Handler.cpp index 6b04f24094..938e2e645d 100644 --- a/src/xrpld/rpc/detail/Handler.cpp +++ b/src/xrpld/rpc/detail/Handler.cpp @@ -28,7 +28,7 @@ byRef(Function const& f) { return [f](JsonContext& context, json::Value& result) { result = f(context); - if (result.type() != json::ObjectValue) + if (result.type() != json::ValueType::Object) { // LCOV_EXCL_START UNREACHABLE("xrpl::RPC::byRef : result is object"); @@ -81,281 +81,290 @@ Handler const kHANDLER_ARRAY[]{ {.name = "account_info", .valueMethod = byRef(&doAccountInfo), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "account_currencies", .valueMethod = byRef(&doAccountCurrencies), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "account_lines", .valueMethod = byRef(&doAccountLines), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "account_channels", .valueMethod = byRef(&doAccountChannels), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "account_nfts", .valueMethod = byRef(&doAccountNFTs), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "account_objects", .valueMethod = byRef(&doAccountObjects), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "account_offers", .valueMethod = byRef(&doAccountOffers), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "account_tx", .valueMethod = byRef(&doAccountTx), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "amm_info", .valueMethod = byRef(&doAMMInfo), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "blacklist", .valueMethod = byRef(&doBlackList), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "book_changes", .valueMethod = byRef(&doBookChanges), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "book_offers", .valueMethod = byRef(&doBookOffers), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "can_delete", .valueMethod = byRef(&doCanDelete), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "channel_authorize", .valueMethod = byRef(&doChannelAuthorize), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "channel_verify", .valueMethod = byRef(&doChannelVerify), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "connect", .valueMethod = byRef(&doConnect), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "consensus_info", .valueMethod = byRef(&doConsensusInfo), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "deposit_authorized", .valueMethod = byRef(&doDepositAuthorized), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "feature", .valueMethod = byRef(&doFeature), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "fee", .valueMethod = byRef(&doFee), .role = Role::USER, - .condition = NeedsCurrentLedger}, + .condition = Condition::NeedsCurrentLedger}, {.name = "fetch_info", .valueMethod = byRef(&doFetchInfo), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "gateway_balances", .valueMethod = byRef(&doGatewayBalances), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "get_counts", .valueMethod = byRef(&doGetCounts), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "get_aggregate_price", .valueMethod = byRef(&doGetAggregatePrice), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "ledger_accept", .valueMethod = byRef(&doLedgerAccept), .role = Role::ADMIN, - .condition = NeedsCurrentLedger}, + .condition = Condition::NeedsCurrentLedger}, {.name = "ledger_cleaner", .valueMethod = byRef(&doLedgerCleaner), .role = Role::ADMIN, - .condition = NeedsNetworkConnection}, + .condition = Condition::NeedsNetworkConnection}, {.name = "ledger_closed", .valueMethod = byRef(&doLedgerClosed), .role = Role::USER, - .condition = NeedsClosedLedger}, + .condition = Condition::NeedsClosedLedger}, {.name = "ledger_current", .valueMethod = byRef(&doLedgerCurrent), .role = Role::USER, - .condition = NeedsCurrentLedger}, + .condition = Condition::NeedsCurrentLedger}, {.name = "ledger_data", .valueMethod = byRef(&doLedgerData), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "ledger_entry", .valueMethod = byRef(&doLedgerEntry), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "ledger_header", .valueMethod = byRef(&doLedgerHeader), .role = Role::USER, - .condition = NoCondition, + .condition = Condition::NoCondition, .minApiVer = 1, .maxApiVer = 1}, {.name = "ledger_request", .valueMethod = byRef(&doLedgerRequest), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "log_level", .valueMethod = byRef(&doLogLevel), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "logrotate", .valueMethod = byRef(&doLogRotate), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "manifest", .valueMethod = byRef(&doManifest), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "nft_buy_offers", .valueMethod = byRef(&doNFTBuyOffers), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "nft_sell_offers", .valueMethod = byRef(&doNFTSellOffers), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "noripple_check", .valueMethod = byRef(&doNoRippleCheck), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "owner_info", .valueMethod = byRef(&doOwnerInfo), .role = Role::USER, - .condition = NeedsCurrentLedger}, + .condition = Condition::NeedsCurrentLedger}, {.name = "peers", .valueMethod = byRef(&doPeers), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "path_find", .valueMethod = byRef(&doPathFind), .role = Role::USER, - .condition = NeedsCurrentLedger}, - {.name = "ping", .valueMethod = byRef(&doPing), .role = Role::USER, .condition = NoCondition}, + .condition = Condition::NeedsCurrentLedger}, + {.name = "ping", + .valueMethod = byRef(&doPing), + .role = Role::USER, + .condition = Condition::NoCondition}, {.name = "print", .valueMethod = byRef(&doPrint), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, // { "profile", byRef (&doProfile), Role::USER, // NEEDS_CURRENT_LEDGER }, {.name = "random", .valueMethod = byRef(&doRandom), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "peer_reservations_add", .valueMethod = byRef(&doPeerReservationsAdd), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "peer_reservations_del", .valueMethod = byRef(&doPeerReservationsDel), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "peer_reservations_list", .valueMethod = byRef(&doPeerReservationsList), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "ripple_path_find", .valueMethod = byRef(&doRipplePathFind), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "server_definitions", .valueMethod = byRef(&doServerDefinitions), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "server_info", .valueMethod = byRef(&doServerInfo), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "server_state", .valueMethod = byRef(&doServerState), .role = Role::USER, - .condition = NoCondition}, - {.name = "sign", .valueMethod = byRef(&doSign), .role = Role::USER, .condition = NoCondition}, + .condition = Condition::NoCondition}, + {.name = "sign", + .valueMethod = byRef(&doSign), + .role = Role::USER, + .condition = Condition::NoCondition}, {.name = "sign_for", .valueMethod = byRef(&doSignFor), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "simulate", .valueMethod = byRef(&doSimulate), .role = Role::USER, - .condition = NeedsCurrentLedger}, - {.name = "stop", .valueMethod = byRef(&doStop), .role = Role::ADMIN, .condition = NoCondition}, + .condition = Condition::NeedsCurrentLedger}, + {.name = "stop", + .valueMethod = byRef(&doStop), + .role = Role::ADMIN, + .condition = Condition::NoCondition}, {.name = "submit", .valueMethod = byRef(&doSubmit), .role = Role::USER, - .condition = NeedsCurrentLedger}, + .condition = Condition::NeedsCurrentLedger}, {.name = "submit_multisigned", .valueMethod = byRef(&doSubmitMultiSigned), .role = Role::USER, - .condition = NeedsCurrentLedger}, + .condition = Condition::NeedsCurrentLedger}, {.name = "transaction_entry", .valueMethod = byRef(&doTransactionEntry), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "tx", .valueMethod = byRef(&doTxJson), .role = Role::USER, - .condition = NeedsNetworkConnection}, + .condition = Condition::NeedsNetworkConnection}, {.name = "tx_history", .valueMethod = byRef(&doTxHistory), .role = Role::USER, - .condition = NoCondition, + .condition = Condition::NoCondition, .minApiVer = 1, .maxApiVer = 1}, {.name = "tx_reduce_relay", .valueMethod = byRef(&doTxReduceRelay), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "unl_list", .valueMethod = byRef(&doUnlList), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "validation_create", .valueMethod = byRef(&doValidationCreate), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "validators", .valueMethod = byRef(&doValidators), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "validator_list_sites", .valueMethod = byRef(&doValidatorListSites), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "validator_info", .valueMethod = byRef(&doValidatorInfo), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "vault_info", .valueMethod = byRef(&doVaultInfo), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "wallet_propose", .valueMethod = byRef(&doWalletPropose), .role = Role::ADMIN, - .condition = NoCondition}, + .condition = Condition::NoCondition}, // Event methods {.name = "subscribe", .valueMethod = byRef(&doSubscribe), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, {.name = "unsubscribe", .valueMethod = byRef(&doUnsubscribe), .role = Role::USER, - .condition = NoCondition}, + .condition = Condition::NoCondition}, }; class HandlerTable diff --git a/src/xrpld/rpc/detail/Handler.h b/src/xrpld/rpc/detail/Handler.h index 1e1db7bb99..5140f5d6be 100644 --- a/src/xrpld/rpc/detail/Handler.h +++ b/src/xrpld/rpc/detail/Handler.h @@ -15,9 +15,7 @@ class Object; namespace xrpl::RPC { // Under what condition can we call this RPC? -// Bitwise flags -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum Condition { +enum class Condition { NoCondition = 0, NeedsNetworkConnection = 1, NeedsCurrentLedger = 1 << 1, @@ -41,12 +39,12 @@ struct Handler Handler const* getHandler(unsigned int version, bool betaEnabled, std::string const&); -/** Return a json::objectValue with a single entry. */ +/** Return a json::ValueType::Object with a single entry. */ template json::Value makeObjectValue(Value const& value, json::StaticString const& field = jss::message) { - json::Value result(json::ObjectValue); + json::Value result(json::ValueType::Object); result[field] = value; return result; } @@ -59,17 +57,17 @@ template ErrorCodeI conditionMet(Condition conditionRequired, T& context) { - if (context.app.getOPs().isAmendmentBlocked() && (conditionRequired != NoCondition)) + if (context.app.getOPs().isAmendmentBlocked() && (conditionRequired != Condition::NoCondition)) { return RpcAmendmentBlocked; } - if (context.app.getOPs().isUNLBlocked() && (conditionRequired != NoCondition)) + if (context.app.getOPs().isUNLBlocked() && (conditionRequired != Condition::NoCondition)) { return RpcExpiredValidatorList; } - if ((conditionRequired != NoCondition) && + if ((conditionRequired != Condition::NoCondition) && (context.netOps.getOperatingMode() < OperatingMode::SYNCING)) { JLOG(context.j.info()) << "Insufficient network mode for RPC: " @@ -80,7 +78,7 @@ conditionMet(Condition conditionRequired, T& context) return RpcNotSynced; } - if (!context.app.config().standalone() && conditionRequired != NoCondition) + if (!context.app.config().standalone() && conditionRequired != Condition::NoCondition) { if (context.ledgerMaster.getValidatedLedgerAge() > Tuning::kMAX_VALIDATED_LEDGER_AGE) { @@ -102,7 +100,7 @@ conditionMet(Condition conditionRequired, T& context) } } - if ((conditionRequired != NoCondition) && !context.ledgerMaster.getClosedLedger()) + if ((conditionRequired != Condition::NoCondition) && !context.ledgerMaster.getClosedLedger()) { if (context.apiVersion == 1) return RpcNoClosed; diff --git a/src/xrpld/rpc/detail/PathRequest.cpp b/src/xrpld/rpc/detail/PathRequest.cpp index 46069ce3bb..7aaf45c50f 100644 --- a/src/xrpld/rpc/detail/PathRequest.cpp +++ b/src/xrpld/rpc/detail/PathRequest.cpp @@ -59,7 +59,7 @@ PathRequest::PathRequest( , owner_(owner) , wpSubscriber_(subscriber) , consumer_(subscriber->getConsumer()) - , jvStatus_(json::ObjectValue) + , jvStatus_(json::ValueType::Object) , lastIndex_(0) , inProgress_(false) , iLevel_(0) @@ -82,7 +82,7 @@ PathRequest::PathRequest( , owner_(owner) , fCompletion_(completion) , consumer_(consumer) - , jvStatus_(json::ObjectValue) + , jvStatus_(json::ValueType::Object) , lastIndex_(0) , inProgress_(false) , iLevel_(0) @@ -198,7 +198,7 @@ PathRequest::isValid(std::shared_ptr const& crCache) auto const sleDest = lrLedger->read(keylet::account(*raDstAccount_)); - json::Value& jvDestCur = (jvStatus_[jss::destination_currencies] = json::ArrayValue); + json::Value& jvDestCur = (jvStatus_[jss::destination_currencies] = json::ValueType::Array); if (!sleDest) { @@ -219,7 +219,7 @@ PathRequest::isValid(std::shared_ptr const& crCache) } else { - bool const disallowXRP((sleDest->getFlags() & lsfDisallowXRP) != 0u); + bool const disallowXRP(sleDest->isFlag(lsfDisallowXRP)); auto const destAssets = accountDestAssets(*raDstAccount_, crCache, !disallowXRP); @@ -673,19 +673,22 @@ PathRequest::findPaths( if (rc.result() == tesSUCCESS) { - json::Value jvEntry(json::ObjectValue); + json::Value jvEntry(json::ValueType::Object); if (rc.actualAmountIn.holds()) rc.actualAmountIn.get().account = sourceAccount; - jvEntry[jss::source_amount] = rc.actualAmountIn.getJson(JsonOptions::KNone); - jvEntry[jss::paths_computed] = ps.getJson(JsonOptions::KNone); + jvEntry[jss::source_amount] = rc.actualAmountIn.getJson(JsonOptions::Values::None); + jvEntry[jss::paths_computed] = ps.getJson(JsonOptions::Values::None); if (convert_all_) - jvEntry[jss::destination_amount] = rc.actualAmountOut.getJson(JsonOptions::KNone); + { + jvEntry[jss::destination_amount] = + rc.actualAmountOut.getJson(JsonOptions::Values::None); + } if (hasCompletion()) { // Old ripple_path_find API requires this - jvEntry[jss::paths_canonical] = json::ArrayValue; + jvEntry[jss::paths_canonical] = json::ValueType::Array; } jvArray.append(jvEntry); @@ -722,12 +725,12 @@ PathRequest::doUpdate( return jvStatus_; } - json::Value newStatus = json::ObjectValue; + json::Value newStatus = json::ValueType::Object; if (hasCompletion()) { // Old ripple_path_find API gives destination_currencies - auto& destAssets = (newStatus[jss::destination_currencies] = json::ArrayValue); + auto& destAssets = (newStatus[jss::destination_currencies] = json::ValueType::Array); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) isValid() ensures both are set auto const assets = accountDestAssets(*raDstAccount_, cache, true); for (auto const& asset : assets) @@ -738,7 +741,7 @@ PathRequest::doUpdate( newStatus[jss::source_account] = toBase58(*raSrcAccount_); newStatus[jss::destination_account] = toBase58(*raDstAccount_); // NOLINTEND(bugprone-unchecked-optional-access) - newStatus[jss::destination_amount] = saDstAmount_.getJson(JsonOptions::KNone); + newStatus[jss::destination_amount] = saDstAmount_.getJson(JsonOptions::Values::None); newStatus[jss::full_reply] = !fast; if (jvId_) @@ -783,7 +786,7 @@ PathRequest::doUpdate( JLOG(journal_.debug()) << iIdentifier_ << " processing at level " << iLevel_; - json::Value jvArray = json::ArrayValue; + json::Value jvArray = json::ValueType::Array; if (findPaths(cache, iLevel_, jvArray, continueCallback)) { bLastSuccess_ = jvArray.size() != 0; diff --git a/src/xrpld/rpc/detail/Pathfinder.cpp b/src/xrpld/rpc/detail/Pathfinder.cpp index 9a34cf44f1..21f232614b 100644 --- a/src/xrpld/rpc/detail/Pathfinder.cpp +++ b/src/xrpld/rpc/detail/Pathfinder.cpp @@ -443,7 +443,7 @@ Pathfinder::getPathLiquidity( catch (std::exception const& e) { JLOG(j_.info()) << "checkpath: exception (" << e.what() << ") " - << path.getJson(JsonOptions::KNone); + << path.getJson(JsonOptions::Values::None); return tefEXCEPTION; } } @@ -561,12 +561,12 @@ Pathfinder::rankPaths( if (!isTesSuccess(resultCode)) { JLOG(j_.debug()) << "findPaths: dropping : " << transToken(resultCode) << ": " - << currentPath.getJson(JsonOptions::KNone); + << currentPath.getJson(JsonOptions::Values::None); } else { JLOG(j_.debug()) << "findPaths: quality: " << uQuality << ": " - << currentPath.getJson(JsonOptions::KNone); + << currentPath.getJson(JsonOptions::Values::None); rankedPaths.push_back({uQuality, currentPath.size(), liquidity, i}); } @@ -713,11 +713,12 @@ Pathfinder::getBestPaths( // We found an extra path that can move the whole amount. fullLiquidityPath = (startsWithIssuer ? removeIssuer(path) : path); JLOG(j_.debug()) << "Found extra full path: " - << fullLiquidityPath.getJson(JsonOptions::KNone); + << fullLiquidityPath.getJson(JsonOptions::Values::None); } else { - JLOG(j_.debug()) << "Skipping a non-filling path: " << path.getJson(JsonOptions::KNone); + JLOG(j_.debug()) << "Skipping a non-filling path: " + << path.getJson(JsonOptions::Values::None); } } @@ -729,7 +730,7 @@ Pathfinder::getBestPaths( } else { - JLOG(j_.debug()) << "findPaths: RESULTS: " << bestPaths.getJson(JsonOptions::KNone); + JLOG(j_.debug()) << "findPaths: RESULTS: " << bestPaths.getJson(JsonOptions::Values::None); } return bestPaths; } @@ -951,7 +952,7 @@ Pathfinder::isNoRipple( auto const flag((toAccount > fromAccount) ? lsfHighNoRipple : lsfLowNoRipple); - return sleRipple && ((sleRipple->getFieldU32(sfFlags) & flag) != 0u); + return sleRipple && sleRipple->isFlag(flag); } // Does this path end on an account-to-account link whose last account has @@ -1010,7 +1011,7 @@ Pathfinder::addLink( JLOG(j_.trace()) << "addLink< flags=" << addFlags << " onXRP=" << bOnXRP << " completePaths size=" << completePaths_.size(); - JLOG(j_.trace()) << currentPath.getJson(JsonOptions::KNone); + JLOG(j_.trace()) << currentPath.getJson(JsonOptions::Values::None); if ((addFlags & kAF_ADD_ACCOUNTS) != 0u) { @@ -1020,7 +1021,7 @@ Pathfinder::addLink( if (dstAmount_.native() && !currentPath.empty()) { // non-default path to XRP destination JLOG(j_.trace()) << "complete path found ax: " - << currentPath.getJson(JsonOptions::KNone); + << currentPath.getJson(JsonOptions::Values::None); addUniquePath(completePaths_, currentPath); } } @@ -1031,7 +1032,7 @@ Pathfinder::addLink( if (sleEnd) { - bool const bRequireAuth((sleEnd->getFieldU32(sfFlags) & lsfRequireAuth) != 0u); + bool const bRequireAuth(sleEnd->isFlag(lsfRequireAuth)); bool const bIsEndAsset(uEndPathAsset == dstAmount_.asset()); bool const bIsNoRippleOut(isNoRippleOut(currentPath)); bool const bDestOnly((addFlags & kAF_AC_LAST) != 0u); @@ -1122,8 +1123,9 @@ Pathfinder::addLink( // this is a complete path if (!currentPath.empty()) { - JLOG(j_.trace()) << "complete path found ae: " - << currentPath.getJson(JsonOptions::KNone); + JLOG(j_.trace()) + << "complete path found ae: " + << currentPath.getJson(JsonOptions::Values::None); addUniquePath(completePaths_, currentPath); } } @@ -1254,7 +1256,7 @@ Pathfinder::addLink( // destination is XRP, add account and path is // complete JLOG(j_.trace()) << "complete path found bx: " - << currentPath.getJson(JsonOptions::KNone); + << currentPath.getJson(JsonOptions::Values::None); addUniquePath(completePaths_, newPath); } else @@ -1300,7 +1302,7 @@ Pathfinder::addLink( { // with the destination account, this path is // complete JLOG(j_.trace()) << "complete path found ba: " - << currentPath.getJson(JsonOptions::KNone); + << currentPath.getJson(JsonOptions::Values::None); addUniquePath(completePaths_, newPath); } else diff --git a/src/xrpld/rpc/detail/RPCCall.cpp b/src/xrpld/rpc/detail/RPCCall.cpp index 98cb7ee9ba..bbeb132b7a 100644 --- a/src/xrpld/rpc/detail/RPCCall.cpp +++ b/src/xrpld/rpc/detail/RPCCall.cpp @@ -134,7 +134,7 @@ private: if (boost::regex_match(strCurrencyIssuer, smMatch, kRE_CUR_ISS)) { - json::Value jvResult(json::ObjectValue); + json::Value jvResult(json::ValueType::Object); std::string const strCurrency = smMatch[1]; std::string const strIssuer = smMatch[2]; @@ -176,7 +176,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseAsIs(json::Value const& jvParams) { - json::Value v(json::ObjectValue); + json::Value v(json::ValueType::Object); if (jvParams.isArray() && (jvParams.size() > 0)) v[jss::params] = jvParams; @@ -188,10 +188,10 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseInternal(json::Value const& jvParams) { - json::Value v(json::ObjectValue); + json::Value v(json::ValueType::Object); v[jss::internal_command] = jvParams[0u]; - json::Value params(json::ArrayValue); + json::Value params(json::ValueType::Array); for (unsigned i = 1; i < jvParams.size(); ++i) params.append(jvParams[i]); @@ -207,7 +207,7 @@ private: { if (jvParams.size() == 1) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); std::string const strPk = jvParams[0u].asString(); if (!validPublicKey(strPk, TokenType::NodePublic)) @@ -226,7 +226,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseFetchInfo(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); unsigned int const iParams = jvParams.size(); if (iParams != 0) @@ -241,7 +241,7 @@ private: // NOLINTNEXTLINE(readability-make-member-function-const) parseAccountTransactions(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); unsigned int iParams = jvParams.size(); auto const account = parseBase58(jvParams[0u].asString()); @@ -317,7 +317,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseBookOffers(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); json::Value jvTakerPays = jvParseCurrencyIssuer(jvParams[0u].asString()); json::Value jvTakerGets = jvParseCurrencyIssuer(jvParams[1u].asString()); @@ -384,7 +384,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseCanDelete(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); if (jvParams.size() == 0u) return jvRequest; @@ -407,7 +407,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseConnect(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); std::string ip = jvParams[0u].asString(); if (jvParams.size() == 2) { @@ -436,7 +436,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseDepositAuthorized(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); jvRequest[jss::source_account] = jvParams[0u].asString(); jvRequest[jss::destination_account] = jvParams[1u].asString(); @@ -446,7 +446,7 @@ private: // 8 credentials max if ((jvParams.size() >= 4) && (jvParams.size() <= 11)) { - jvRequest[jss::credentials] = json::Value(json::ArrayValue); + jvRequest[jss::credentials] = json::Value(json::ValueType::Array); for (uint32_t i = 3; i < jvParams.size(); ++i) jvRequest[jss::credentials].append(jvParams[i].asString()); } @@ -467,7 +467,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseFeature(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); if (jvParams.size() > 0) jvRequest[jss::feature] = jvParams[0u].asString(); @@ -501,7 +501,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseGetCounts(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); if (jvParams.size() != 0u) jvRequest[jss::min_count] = jvParams[0u].asUInt(); @@ -524,7 +524,7 @@ private: if (reader.parse(jvParams[2u].asString(), txJSON)) { // sign_for txJSON. - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; jvRequest[jss::account] = jvParams[0u].asString(); jvRequest[jss::secret] = jvParams[1u].asString(); @@ -600,7 +600,7 @@ private: { if (jv.isObject()) { - json::Value jv1{json::ObjectValue}; + json::Value jv1{json::ValueType::Object}; if (jv.isMember(jss::params)) { auto const& params = jv[jss::params]; @@ -614,7 +614,7 @@ private: return jv1; } // else jv.isArray() - json::Value jv1{json::ArrayValue}; + json::Value jv1{json::ValueType::Array}; for (json::UInt j = 0; j < jv.size(); ++j) { if (jv[j].isMember(jss::params)) @@ -645,7 +645,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseLedger(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); if (jvParams.size() == 0u) { @@ -675,7 +675,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseLedgerId(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); std::string const strLedger = jvParams[0u].asString(); @@ -696,7 +696,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseLedgerEntry(json::Value const& jvParams) { - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; jvRequest[jss::index] = jvParams[0u].asString(); @@ -714,7 +714,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseLogLevel(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); if (jvParams.size() == 1) { @@ -763,7 +763,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseChannelAuthorize(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); unsigned int index = 0; @@ -792,7 +792,7 @@ private: index++; } - if (!jvParams[index].isString() || !toUint64(jvParams[index].asString())) + if (!jvParams[index].isString() || !toUInt64(jvParams[index].asString())) return rpcError(RpcChannelAmtMalformed); jvRequest[jss::amount] = jvParams[index]; @@ -812,7 +812,7 @@ private: if (!validPublicKey(strPk)) return rpcError(RpcPublicMalformed); - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); jvRequest[jss::public_key] = strPk; { @@ -823,7 +823,7 @@ private: } jvRequest[jss::channel_id] = jvParams[1u].asString(); - if (!jvParams[2u].isString() || !toUint64(jvParams[2u].asString())) + if (!jvParams[2u].isString() || !toUInt64(jvParams[2u].asString())) return rpcError(RpcChannelAmtMalformed); jvRequest[jss::amount] = jvParams[2u]; @@ -838,7 +838,7 @@ private: { std::array accFields{{jss::account, acc2Field}}; auto const nParams = jvParams.size(); - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); for (auto i = 0; i < nParams; ++i) { // This was non-const. see comment below @@ -885,7 +885,7 @@ private: return rpcError(RpcActMalformed); // Get info on account. - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); jvRequest[jss::account] = strIdent; @@ -904,7 +904,7 @@ private: if (!id.parseHex(strVaultID)) return rpcError(RpcInvalidParams); - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); jvRequest[jss::vault_id] = strVaultID; if (jvParams.size() > 1) @@ -942,7 +942,7 @@ private: parseRipplePathFind(json::Value const& jvParams) { json::Reader reader; - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; bool const bLedger = 2 == jvParams.size(); JLOG(j_.trace()) << "RPC json: " << jvParams[0u]; @@ -970,7 +970,7 @@ private: { json::Value txJSON; json::Reader reader; - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; if (reader.parse(jvParams[0u].asString(), txJSON)) { @@ -1017,7 +1017,7 @@ private: { // Submitting tx_blob - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; jvRequest[jss::tx_blob] = jvParams[0u].asString(); @@ -1026,7 +1026,7 @@ private: if ((jvParams.size() >= 2 || bOffline) && reader.parse(jvParams[1u].asString(), txJSON)) { // Signing or submitting tx_json. - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; jvRequest[jss::secret] = jvParams[0u].asString(); jvRequest[jss::tx_json] = txJSON; @@ -1056,7 +1056,7 @@ private: json::Reader reader; if (reader.parse(jvParams[0u].asString(), txJSON)) { - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; jvRequest[jss::tx_json] = txJSON; return jvRequest; } @@ -1078,7 +1078,7 @@ private: if (txHash.length() != 64) return rpcError(RpcInvalidParams); - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; jvRequest[jss::tx_hash] = txHash; jvParseLedger(jvRequest, jvParams[1u].asString()); @@ -1096,7 +1096,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseTx(json::Value const& jvParams) { - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; if (jvParams.size() == 2 || jvParams.size() == 4) { @@ -1129,7 +1129,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseTxHistory(json::Value const& jvParams) { - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; jvRequest[jss::start] = jvParams[0u].asUInt(); @@ -1146,7 +1146,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseValidationCreate(json::Value const& jvParams) { - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; if (jvParams.size() != 0u) jvRequest[jss::secret] = jvParams[0u].asString(); @@ -1161,7 +1161,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseWalletPropose(json::Value const& jvParams) { - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; if (jvParams.size() != 0u) jvRequest[jss::passphrase] = jvParams[0u].asString(); @@ -1180,7 +1180,7 @@ private: unsigned int index = 0; unsigned int const size = jvParams.size(); - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; std::string param = jvParams[index++].asString(); if (param.empty()) @@ -1207,7 +1207,7 @@ private: if (index < size) { - json::Value& hotWallets = (jvRequest["hotwallet"] = json::ArrayValue); + json::Value& hotWallets = (jvRequest["hotwallet"] = json::ValueType::Array); while (index < size) hotWallets.append(jvParams[index++].asString()); } @@ -1220,7 +1220,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseServerDefinitions(json::Value const& jvParams) { - json::Value jvRequest{json::ObjectValue}; + json::Value jvRequest{json::ValueType::Object}; if (jvParams.size() == 1) { @@ -1235,7 +1235,7 @@ private: // NOLINTNEXTLINE(readability-convert-member-functions-to-static) parseServerInfo(json::Value const& jvParams) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); if (jvParams.size() == 1 && jvParams[0u].asString() == "counters") jvRequest[jss::counters] = true; return jvRequest; @@ -1585,7 +1585,7 @@ struct RPCCallImp if (!jvReply) Throw("expected reply to have result, error and id properties"); - json::Value jvResult(json::ObjectValue); + json::Value jvResult(json::ValueType::Object); jvResult["result"] = jvReply; @@ -1624,15 +1624,15 @@ rpcCmdToJson( unsigned int apiVersion, beast::Journal j) { - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); RPCParser rpParser(apiVersion, j); - json::Value jvRpcParams(json::ArrayValue); + json::Value jvRpcParams(json::ValueType::Array); for (int i = 1; i != args.size(); i++) jvRpcParams.append(args[i]); - retParams = json::Value(json::ObjectValue); + retParams = json::Value(json::ValueType::Object); retParams[jss::method] = args[0]; retParams[jss::params] = jvRpcParams; @@ -1676,11 +1676,11 @@ rpcClient( int nRet = RpcSuccess; json::Value jvOutput; - json::Value jvRequest(json::ObjectValue); + json::Value jvRequest(json::ValueType::Object); try { - json::Value jvRpc = json::Value(json::ObjectValue); + json::Value jvRpc = json::Value(json::ValueType::Object); jvRequest = rpcCmdToJson(args, jvRpc, apiVersion, logs.journal("RPCParser")); if (jvRequest.isMember(jss::error)) @@ -1708,7 +1708,7 @@ rpcClient( setup.client.port = config.rpc_ip->port(); } - json::Value jvParams(json::ArrayValue); + json::Value jvParams(json::ValueType::Array); if (!setup.client.admin_user.empty()) jvRequest["admin_user"] = setup.client.admin_user; diff --git a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp index f8ab42f499..467546098d 100644 --- a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp +++ b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp @@ -342,7 +342,7 @@ getLedger<>(std::shared_ptr&, uint256 const&, Context const&); // In the absence of the "ledger_hash" or "ledger_index" parameters, the code // assumes that "ledger_index" has the value "current". // -// Returns a json::objectValue. If there was an error, it will be in that +// Returns a json::ValueType::Object. If there was an error, it will be in that // return value. Otherwise, the object contains the field "validated" and // optionally the fields "ledger_hash", "ledger_index" and // "ledger_current_index", if they are defined. @@ -401,13 +401,13 @@ getOrAcquireLedger(RPC::JsonContext const& context) if (hasHash) { - auto const& jsonHash = context.params.get(jss::ledger_hash, json::NullValue); + auto const& jsonHash = context.params.get(jss::ledger_hash, json::ValueType::Null); if (!jsonHash.isString() || !ledgerHash.parseHex(jsonHash.asString())) return Unexpected(RPC::expectedFieldError(jss::ledger_hash, "hex string")); } else { - auto const& jsonIndex = context.params.get(jss::ledger_index, json::NullValue); + auto const& jsonIndex = context.params.get(jss::ledger_index, json::ValueType::Null); if (!jsonIndex.isInt() && !jsonIndex.isUInt()) return Unexpected(RPC::expectedFieldError(jss::ledger_index, "number")); diff --git a/src/xrpld/rpc/detail/Role.cpp b/src/xrpld/rpc/detail/Role.cpp index 998eea15c9..638ef22630 100644 --- a/src/xrpld/rpc/detail/Role.cpp +++ b/src/xrpld/rpc/detail/Role.cpp @@ -18,6 +18,7 @@ #include #include #include +#include #include #include @@ -252,32 +253,46 @@ forwardedFor(http_request_type const& request) // Look for the Forwarded field in the request. if (auto it = request.find(boost::beast::http::field::forwarded); it != request.end()) { - auto asciiTolower = [](char c) -> char { + auto asciiToLower = [](char c) -> char { return ((static_cast(c) - 65U) < 26) ? c + 'a' - 'A' : c; }; - // Look for the first (case insensitive) "for=" - static std::string const kFOR_STR{"for="}; - char const* found = std::search( - it->value().begin(), - it->value().end(), - kFOR_STR.begin(), - kFOR_STR.end(), - [&asciiTolower](char c1, char c2) { return asciiTolower(c1) == asciiTolower(c2); }); + // Look for the first (case insensitive) "for=" at a directive + // boundary (start of value, or preceded by , ; or OWS). + static constexpr std::string_view kFOR_STR{"for="}; + auto const atFieldBoundary = [begin = it->value().begin()](auto p) { + return p == begin || p[-1] == ';' || p[-1] == ',' || p[-1] == ' ' || p[-1] == '\t'; + }; + auto found = it->value().begin(); + while (true) + { + found = std::search( + found, + it->value().end(), + kFOR_STR.begin(), + kFOR_STR.end(), + [&asciiToLower](char c1, char c2) { return asciiToLower(c1) == asciiToLower(c2); }); - if (found == it->value().end()) - return {}; + if (found == it->value().end()) + return {}; - found += kFOR_STR.size(); + if (atFieldBoundary(found)) + break; + + ++found; + } + + std::advance(found, kFOR_STR.size()); // We found a "for=". Scan for the end of the IP address. - std::size_t const pos = [&found, &it]() { - auto const remaining = static_cast(it->value().end() - found); - if (std::size_t const pos = std::string_view(found, remaining).find_first_of(",;"); - pos != std::string_view::npos) + auto const end = it->value().end(); + std::size_t const pos = [&found, &end]() { + std::size_t const pos = + std::string_view(found, std::distance(found, end)).find_first_of(",;"); + if (pos != std::string_view::npos) return pos; - return remaining; + return static_cast(std::distance(found, end)); }(); return extractIpAddrFromField({found, pos}); diff --git a/src/xrpld/rpc/detail/ServerHandler.cpp b/src/xrpld/rpc/detail/ServerHandler.cpp index e81fc37cc5..2b49b06394 100644 --- a/src/xrpld/rpc/detail/ServerHandler.cpp +++ b/src/xrpld/rpc/detail/ServerHandler.cpp @@ -340,7 +340,7 @@ ServerHandler::onWSMessage( if (size > RPC::Tuning::kMAX_REQUEST_SIZE || !json::Reader{}.parse(jv, buffers) || !jv.isObject()) { - json::Value jvResult(json::ObjectValue); + json::Value jvResult(json::ValueType::Object); jvResult[jss::type] = jss::error; jvResult[jss::error] = "jsonInvalid"; jvResult[jss::value] = buffersToString(buffers); @@ -426,7 +426,7 @@ ServerHandler::processSession( } // Requests without "command" are invalid. - json::Value jr(json::ObjectValue); + json::Value jr(json::ValueType::Object); Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; try { @@ -585,10 +585,10 @@ ServerHandler::processSession( static json::Value makeJsonError(json::Int code, json::Value&& message) { - json::Value sub{json::ObjectValue}; + json::Value sub{json::ValueType::Object}; sub["code"] = code; sub["message"] = std::move(message); - json::Value r{json::ObjectValue}; + json::Value r{json::ValueType::Object}; r["error"] = sub; return r; } @@ -638,7 +638,7 @@ ServerHandler::processRequest( size = jsonOrig[jss::params].size(); } - json::Value reply(batch ? json::ArrayValue : json::ObjectValue); + json::Value reply(batch ? json::ValueType::Array : json::ValueType::Object); auto const start(std::chrono::high_resolution_clock::now()); for (unsigned i = 0; i < size; ++i) { @@ -646,7 +646,7 @@ ServerHandler::processRequest( if (!jsonRPC.isObject()) { - json::Value r(json::ObjectValue); + json::Value r(json::ValueType::Object); r[jss::request] = jsonRPC; r[jss::error] = makeJsonError(kMETHOD_NOT_FOUND, "Method not found"); reply.append(r); @@ -674,7 +674,7 @@ ServerHandler::processRequest( httpReply(400, jss::invalid_API_version.cStr(), output, rpcJ); return; } - json::Value r(json::ObjectValue); + json::Value r(json::ValueType::Object); r[jss::request] = jsonRPC; r[jss::error] = makeJsonError(kWRONG_VERSION, jss::invalid_API_version.cStr()); reply.append(r); @@ -698,7 +698,7 @@ ServerHandler::processRequest( } else { - role = requestRole(required, port, json::ObjectValue, remoteIPAddress, user); + role = requestRole(required, port, json::ValueType::Object, remoteIPAddress, user); } Resource::Consumer usage; @@ -794,7 +794,7 @@ ServerHandler::processRequest( params = jsonRPC[jss::params]; if (!params) { - params = json::Value(json::ObjectValue); + params = json::Value(json::ValueType::Object); } else if (!params.isArray() || params.size() != 1) { @@ -895,7 +895,7 @@ ServerHandler::processRequest( if (usage.warn()) result[jss::warning] = jss::load; - json::Value r(json::ObjectValue); + json::Value r(json::ValueType::Object); if (ripplerpc >= "2.0") { if (result.isMember(jss::error)) diff --git a/src/xrpld/rpc/detail/TransactionSign.cpp b/src/xrpld/rpc/detail/TransactionSign.cpp index c6ceeee65f..0fdc1bfdc7 100644 --- a/src/xrpld/rpc/detail/TransactionSign.cpp +++ b/src/xrpld/rpc/detail/TransactionSign.cpp @@ -14,6 +14,7 @@ #include #include +#include #include #include #include @@ -54,6 +55,7 @@ #include #include +#include #include #include #include @@ -322,10 +324,10 @@ checkPayment( auto j = app.getJournal("RPCHandler"); JLOG(j.debug()) << "transactionSign: build_path: " - << result.getJson(JsonOptions::KNone); + << result.getJson(JsonOptions::Values::None); if (!result.empty()) - txJson[jss::Paths] = result.getJson(JsonOptions::KNone); + txJson[jss::Paths] = result.getJson(JsonOptions::Values::None); } } return json::Value(); @@ -405,6 +407,25 @@ checkTxJsonFields( return ret; } +static Expected +checkNetworkID(json::Value const& txJson, uint32_t appNetworkId) +{ + if (appNetworkId > 1024) + { + if (!txJson.isMember(jss::NetworkID)) + { + return Unexpected( + RPC::makeError(RpcInvalidParams, RPC::missingFieldMessage("tx_json.NetworkID"))); + } + if (!txJson[jss::NetworkID].isIntegral() || txJson[jss::NetworkID].asUInt() != appNetworkId) + { + return Unexpected( + RPC::makeError(RpcInvalidParams, RPC::invalidFieldMessage("tx_json.NetworkID"))); + } + } + return Expected(); +} + //------------------------------------------------------------------------------ // A move-only struct that makes it easy to return either a json::Value or a @@ -760,12 +781,12 @@ transactionFormatResultImpl(Transaction::pointer tpTrans, unsigned apiVersion) { if (apiVersion > 1) { - jvResult[jss::tx_json] = tpTrans->getJson(JsonOptions::KDisableApiPriorV2); + jvResult[jss::tx_json] = tpTrans->getJson(JsonOptions::Values::DisableApiPriorV2); jvResult[jss::hash] = to_string(tpTrans->getID()); } else { - jvResult[jss::tx_json] = tpTrans->getJson(JsonOptions::KNone); + jvResult[jss::tx_json] = tpTrans->getJson(JsonOptions::Values::None); } RPC::insertDeliverMax( @@ -972,7 +993,7 @@ checkFee( //------------------------------------------------------------------------------ -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSign( json::Value jvRequest, @@ -1006,7 +1027,7 @@ transactionSign( return transactionFormatResultImpl(txn.second, apiVersion); } -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSubmit( json::Value jvRequest, @@ -1129,7 +1150,7 @@ sortAndValidateSigners(STArray& signers, AccountID const& signingForID) } // namespace detail -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSignFor( json::Value jvRequest, @@ -1165,8 +1186,16 @@ transactionSignFor( if (!txJson.isObject()) return RPC::objectFieldError(jss::tx_json); - // If the tx_json.SigningPubKey field is missing, - // insert an empty one. + if (auto checkResult = + detail::checkNetworkID(txJson, app.getNetworkIDService().getNetworkID()); + !checkResult) + { + return std::move(checkResult).error(); + } + + // If the tx_json.SigningPubKey field is missing, insert an empty one, + // in order for the `checkMultiSignFields` to not return an error + // for non-multisign transactions. if (!txJson.isMember(sfSigningPubKey.getJsonName())) txJson[sfSigningPubKey.getJsonName()] = ""; } @@ -1241,7 +1270,7 @@ transactionSignFor( return transactionFormatResultImpl(txn.second, apiVersion); } -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSubmitMultiSigned( json::Value jvRequest, diff --git a/src/xrpld/rpc/detail/TransactionSign.h b/src/xrpld/rpc/detail/TransactionSign.h index 3d6f41ba30..e26c0795b8 100644 --- a/src/xrpld/rpc/detail/TransactionSign.h +++ b/src/xrpld/rpc/detail/TransactionSign.h @@ -84,7 +84,7 @@ getProcessTxnFn(NetworkOPs& netOPs) }; } -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSign( json::Value params, // Passed by value so it can be modified locally. @@ -94,7 +94,7 @@ transactionSign( std::chrono::seconds validatedLedgerAge, Application& app); -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSubmit( json::Value params, // Passed by value so it can be modified locally. @@ -105,7 +105,7 @@ transactionSubmit( Application& app, ProcessTransactionFn const& processTransaction); -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSignFor( json::Value params, // Passed by value so it can be modified locally. @@ -115,7 +115,7 @@ transactionSignFor( std::chrono::seconds validatedLedgerAge, Application& app); -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSubmitMultiSigned( json::Value params, // Passed by value so it can be modified locally. diff --git a/src/xrpld/rpc/detail/TrustLine.cpp b/src/xrpld/rpc/detail/TrustLine.cpp index 4d0393bfed..f7293d0816 100644 --- a/src/xrpld/rpc/detail/TrustLine.cpp +++ b/src/xrpld/rpc/detail/TrustLine.cpp @@ -30,7 +30,7 @@ TrustLineBase::TrustLineBase(std::shared_ptr const& sle, AccountID co json::Value TrustLineBase::getJson(int) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret["low_id"] = to_string(lowLimit_.getIssuer()); ret["high_id"] = to_string(highLimit_.getIssuer()); return ret; diff --git a/src/xrpld/rpc/handlers/ChannelVerify.cpp b/src/xrpld/rpc/handlers/ChannelVerify.cpp index 082188f8dc..64f616e829 100644 --- a/src/xrpld/rpc/handlers/ChannelVerify.cpp +++ b/src/xrpld/rpc/handlers/ChannelVerify.cpp @@ -58,7 +58,7 @@ doChannelVerify(RPC::JsonContext& context) return rpcError(RpcChannelMalformed); std::optional const optDrops = - params[jss::amount].isString() ? toUint64(params[jss::amount].asString()) : std::nullopt; + params[jss::amount].isString() ? toUInt64(params[jss::amount].asString()) : std::nullopt; if (!optDrops) return rpcError(RpcChannelAmtMalformed); diff --git a/src/xrpld/rpc/handlers/VaultInfo.cpp b/src/xrpld/rpc/handlers/VaultInfo.cpp index 59795736ed..882a865904 100644 --- a/src/xrpld/rpc/handlers/VaultInfo.cpp +++ b/src/xrpld/rpc/handlers/VaultInfo.cpp @@ -42,7 +42,7 @@ parseVault(json::Value const& params, json::Value& jvResult) } if (!(params[jss::seq].isInt() || params[jss::seq].isUInt()) || params[jss::seq].asDouble() <= 0.0 || - params[jss::seq].asDouble() > double(json::Value::kMAX_U_INT)) + params[jss::seq].asDouble() > double(json::Value::kMAX_UINT)) { RPC::injectError(RpcInvalidParams, jvResult); return std::nullopt; @@ -87,9 +87,9 @@ doVaultInfo(RPC::JsonContext& context) } json::Value& vault = jvResult[jss::vault]; - vault = sleVault->getJson(JsonOptions::KNone); + vault = sleVault->getJson(JsonOptions::Values::None); auto& share = vault[jss::shares]; - share = sleIssuance->getJson(JsonOptions::KNone); + share = sleIssuance->getJson(JsonOptions::Values::None); jvResult[jss::vault] = vault; return jvResult; diff --git a/src/xrpld/rpc/handlers/account/AccountChannels.cpp b/src/xrpld/rpc/handlers/account/AccountChannels.cpp index 52c6b3148f..8ba193f5ea 100644 --- a/src/xrpld/rpc/handlers/account/AccountChannels.cpp +++ b/src/xrpld/rpc/handlers/account/AccountChannels.cpp @@ -38,7 +38,7 @@ namespace xrpl { void addChannel(json::Value& jsonLines, SLE const& line) { - json::Value& jDst(jsonLines.append(json::ObjectValue)); + json::Value& jDst(jsonLines.append(json::ValueType::Object)); jDst[jss::channel_id] = to_string(line.key()); jDst[jss::account] = to_string(line[sfAccount]); jDst[jss::destination_account] = to_string(line[sfDestination]); @@ -111,7 +111,7 @@ doAccountChannels(RPC::JsonContext& context) if (auto err = readLimitField(limit, RPC::Tuning::kACCOUNT_CHANNELS, context)) return *err; - json::Value jsonChannels{json::ArrayValue}; + json::Value jsonChannels{json::ValueType::Array}; struct VisitData { std::vector> items; diff --git a/src/xrpld/rpc/handlers/account/AccountCurrencies.cpp b/src/xrpld/rpc/handlers/account/AccountCurrencies.cpp index 1ea629c5ff..058c10e224 100644 --- a/src/xrpld/rpc/handlers/account/AccountCurrencies.cpp +++ b/src/xrpld/rpc/handlers/account/AccountCurrencies.cpp @@ -72,11 +72,11 @@ doAccountCurrencies(RPC::JsonContext& context) send.erase(badCurrency()); receive.erase(badCurrency()); - json::Value& sendCurrencies = (result[jss::send_currencies] = json::ArrayValue); + json::Value& sendCurrencies = (result[jss::send_currencies] = json::ValueType::Array); for (auto const& c : send) sendCurrencies.append(to_string(c)); - json::Value& recvCurrencies = (result[jss::receive_currencies] = json::ArrayValue); + json::Value& recvCurrencies = (result[jss::receive_currencies] = json::ValueType::Array); for (auto const& c : receive) recvCurrencies.append(to_string(c)); diff --git a/src/xrpld/rpc/handlers/account/AccountInfo.cpp b/src/xrpld/rpc/handlers/account/AccountInfo.cpp index 69b0fb2879..ece73c9aee 100644 --- a/src/xrpld/rpc/handlers/account/AccountInfo.cpp +++ b/src/xrpld/rpc/handlers/account/AccountInfo.cpp @@ -49,7 +49,7 @@ namespace xrpl { void injectSLE(json::Value& jv, SLE const& sle) { - jv = sle.getJson(JsonOptions::KNone); + jv = sle.getJson(JsonOptions::Values::None); if (sle.getType() == ltACCOUNT_ROOT) { if (sle.isFieldPresent(sfEmailHash)) @@ -158,11 +158,11 @@ doAccountInfo(RPC::JsonContext& context) return result; } - json::Value jvAccepted(json::ObjectValue); + json::Value jvAccepted(json::ValueType::Object); injectSLE(jvAccepted, *sleAccepted); result[jss::account_data] = jvAccepted; - json::Value acctFlags{json::ObjectValue}; + json::Value acctFlags{json::ValueType::Object}; for (auto const& lsf : kLS_FLAGS) acctFlags[lsf.first.data()] = sleAccepted->isFlag(lsf.second); @@ -218,13 +218,13 @@ doAccountInfo(RPC::JsonContext& context) { // We put the SignerList in an array because of an anticipated // future when we support multiple signer lists on one account. - json::Value jvSignerList = json::ArrayValue; + json::Value jvSignerList = json::ValueType::Array; // This code will need to be revisited if in the future we support // multiple SignerLists on one account. auto const sleSigners = ledger->read(keylet::signers(accountID)); if (sleSigners) - jvSignerList.append(sleSigners->getJson(JsonOptions::KNone)); + jvSignerList.append(sleSigners->getJson(JsonOptions::Values::None)); // Documentation states this is returned as part of the account_info // response, but previously the code put it under account_data. We @@ -242,7 +242,7 @@ doAccountInfo(RPC::JsonContext& context) // Return queue info if that is requested if (queue) { - json::Value jvQueueData = json::ObjectValue; + json::Value jvQueueData = json::ValueType::Object; auto const txs = context.app.getTxQ().getAccountTxs(accountID); if (!txs.empty()) @@ -250,7 +250,7 @@ doAccountInfo(RPC::JsonContext& context) jvQueueData[jss::txn_count] = static_cast(txs.size()); auto& jvQueueTx = jvQueueData[jss::transactions]; - jvQueueTx = json::ArrayValue; + jvQueueTx = json::ValueType::Array; std::uint32_t seqCount = 0; std::uint32_t ticketCount = 0; @@ -266,7 +266,7 @@ doAccountInfo(RPC::JsonContext& context) SeqProxy prevSeqProxy = SeqProxy::sequence(0); for (auto const& tx : txs) { - json::Value jvTx = json::ObjectValue; + json::Value jvTx = json::ValueType::Object; if (tx.seqProxy.isSeq()) { diff --git a/src/xrpld/rpc/handlers/account/AccountLines.cpp b/src/xrpld/rpc/handlers/account/AccountLines.cpp index 7d0d4daa5a..d8f067a3be 100644 --- a/src/xrpld/rpc/handlers/account/AccountLines.cpp +++ b/src/xrpld/rpc/handlers/account/AccountLines.cpp @@ -40,7 +40,7 @@ addLine(json::Value& jsonLines, RPCTrustLine const& line) STAmount const& saBalance(line.getBalance()); STAmount const& saLimit(line.getLimit()); STAmount const& saLimitPeer(line.getLimitPeer()); - json::Value& jPeer(jsonLines.append(json::ObjectValue)); + json::Value& jPeer(jsonLines.append(json::ValueType::Object)); jPeer[jss::account] = to_string(line.getAccountIDPeer()); // Amount reported is positive if current account holds other @@ -129,7 +129,7 @@ doAccountLines(RPC::JsonContext& context) bool const ignoreDefault = params.isMember(jss::ignore_default) && params[jss::ignore_default].asBool(); - json::Value& jsonLines(result[jss::lines] = json::ArrayValue); + json::Value& jsonLines(result[jss::lines] = json::ValueType::Array); struct VisitData { std::vector items; @@ -219,11 +219,11 @@ doAccountLines(RPC::JsonContext& context) { if (sleCur->getFieldAmount(sfLowLimit).getIssuer() == visitData.accountID) { - ignore = !(sleCur->getFieldU32(sfFlags) & lsfLowReserve); + ignore = !sleCur->isFlag(lsfLowReserve); } else { - ignore = !(sleCur->getFieldU32(sfFlags) & lsfHighReserve); + ignore = !sleCur->isFlag(lsfHighReserve); } } diff --git a/src/xrpld/rpc/handlers/account/AccountNFTs.cpp b/src/xrpld/rpc/handlers/account/AccountNFTs.cpp index 077001e543..6fc72ef72a 100644 --- a/src/xrpld/rpc/handlers/account/AccountNFTs.cpp +++ b/src/xrpld/rpc/handlers/account/AccountNFTs.cpp @@ -81,7 +81,7 @@ doAccountNFTs(RPC::JsonContext& context) Keylet(ltNFTOKEN_PAGE, ledger->succ(first.key, last.key.next()).value_or(last.key))); std::uint32_t cnt = 0; - auto& nfts = (result[jss::account_nfts] = json::ArrayValue); + auto& nfts = (result[jss::account_nfts] = json::ValueType::Array); // Continue iteration from the current page: bool pastMarker = marker.isZero(); @@ -128,7 +128,7 @@ doAccountNFTs(RPC::JsonContext& context) pastMarker = true; { - json::Value& obj = nfts.append(o.getJson(JsonOptions::KNone)); + json::Value& obj = nfts.append(o.getJson(JsonOptions::Values::None)); // Pull out the components of the nft ID. obj[sfFlags.jsonName] = nft::getFlags(nftokenID); diff --git a/src/xrpld/rpc/handlers/account/AccountObjects.cpp b/src/xrpld/rpc/handlers/account/AccountObjects.cpp index c930333d91..c544a6ff1a 100644 --- a/src/xrpld/rpc/handlers/account/AccountObjects.cpp +++ b/src/xrpld/rpc/handlers/account/AccountObjects.cpp @@ -59,12 +59,12 @@ getAccountObjects( // iterate NFT pages if the filter says so AND dirIndex == 0 bool iterateNFTPages = (!typeFilter.has_value() || typeMatchesFilter(typeFilter.value(), ltNFTOKEN_PAGE)) && - dirIndex == beast::kZERO; + dirIndex.isZero(); Keylet const firstNFTPage = keylet::nftpageMin(account); // we need to check the marker to see if it is an NFTTokenPage index. - if (iterateNFTPages && entryIndex != beast::kZERO) + if (iterateNFTPages && entryIndex.isNonZero()) { // if it is we will try to iterate the pages up to the limit // and then change over to the owner directory @@ -73,53 +73,48 @@ getAccountObjects( iterateNFTPages = false; } - auto& jvObjects = (jvResult[jss::account_objects] = json::ArrayValue); + auto& jvObjects = (jvResult[jss::account_objects] = json::ValueType::Array); // this is a mutable version of limit, used to seamlessly switch // to iterating directory entries when nftokenpages are exhausted - uint32_t mlimit = limit; + uint32_t limitLeft = limit; // iterate NFTokenPages preferentially if (iterateNFTPages) { Keylet const first = - entryIndex == beast::kZERO ? firstNFTPage : Keylet{ltNFTOKEN_PAGE, entryIndex}; + entryIndex.isZero() ? firstNFTPage : Keylet{ltNFTOKEN_PAGE, entryIndex}; Keylet const last = keylet::nftpageMax(account); - // current key - uint256 ck = ledger.succ(first.key, last.key.next()).value_or(last.key); + auto currentKey = ledger.succ(first.key, last.key.next()).value_or(last.key); - // current page - auto cp = ledger.read(Keylet{ltNFTOKEN_PAGE, ck}); + auto currentPage = ledger.read(Keylet{ltNFTOKEN_PAGE, currentKey}); - while (cp) + while (currentPage) { - jvObjects.append(cp->getJson(JsonOptions::KNone)); - auto const npm = (*cp)[~sfNextPageMin]; + jvObjects.append(currentPage->getJson(JsonOptions::Values::None)); + auto const npm = (*currentPage)[~sfNextPageMin]; if (npm) { - cp = ledger.read(Keylet(ltNFTOKEN_PAGE, *npm)); + currentPage = ledger.read(Keylet(ltNFTOKEN_PAGE, *npm)); } else { - cp = nullptr; + currentPage = nullptr; } - if (--mlimit == 0) + if (--limitLeft == 0 && currentPage) { - if (cp) - { - jvResult[jss::limit] = limit; - jvResult[jss::marker] = std::string("0,") + to_string(ck); - return true; - } + jvResult[jss::limit] = limit; + jvResult[jss::marker] = std::string("0,") + to_string(currentKey); + return true; } if (!npm) break; - ck = *npm; + currentKey = *npm; } // if execution reaches here then we're about to transition @@ -130,12 +125,12 @@ getAccountObjects( } auto const root = keylet::ownerDir(account); - auto found = false; + auto startEntryFound = false; if (dirIndex.isZero()) { dirIndex = root.key; - found = true; + startEntryFound = true; } auto dir = ledger.read({ltDIR_NODE, dirIndex}); @@ -144,8 +139,8 @@ getAccountObjects( // it's possible the user had nftoken pages but no // directory entries. If there's no nftoken page, we will // give empty array for account_objects. - if (mlimit >= limit) - jvResult[jss::account_objects] = json::ArrayValue; + if (limitLeft >= limit) + jvResult[jss::account_objects] = json::ValueType::Array; // non-zero dirIndex validity was checked in the beginning of this // function; by this point, it should be zero. This function returns @@ -156,46 +151,46 @@ getAccountObjects( return true; } - std::uint32_t i = 0; + std::uint32_t itemsAdded = 0; for (;;) { - auto const& entries = dir->getFieldV256(sfIndexes); - auto iter = entries.begin(); + auto const& dirEntries = dir->getFieldV256(sfIndexes); + auto entryIter = dirEntries.begin(); - if (!found) + if (!startEntryFound) { - iter = std::find(iter, entries.end(), entryIndex); - if (iter == entries.end()) + entryIter = std::find(entryIter, dirEntries.end(), entryIndex); + if (entryIter == dirEntries.end()) return false; - found = true; + startEntryFound = true; } // it's possible that the returned NFTPages exactly filled the // response. Check for that condition. - if (i == mlimit && mlimit < limit) + if (itemsAdded == limitLeft && limitLeft < limit && entryIter != dirEntries.end()) { jvResult[jss::limit] = limit; - jvResult[jss::marker] = to_string(dirIndex) + ',' + to_string(*iter); + jvResult[jss::marker] = to_string(dirIndex) + ',' + to_string(*entryIter); return true; } - for (; iter != entries.end(); ++iter) + for (; entryIter != dirEntries.end(); ++entryIter) { - auto const sleNode = ledger.read(keylet::child(*iter)); + auto const sleNode = ledger.read(keylet::child(*entryIter)); if (!typeFilter.has_value() || typeMatchesFilter(typeFilter.value(), sleNode->getType())) { - jvObjects.append(sleNode->getJson(JsonOptions::KNone)); + jvObjects.append(sleNode->getJson(JsonOptions::Values::None)); } - if (++i == mlimit) + if (++itemsAdded == limitLeft) { - if (++iter != entries.end()) + if (++entryIter != dirEntries.end()) { jvResult[jss::limit] = limit; - jvResult[jss::marker] = to_string(dirIndex) + ',' + to_string(*iter); + jvResult[jss::marker] = to_string(dirIndex) + ',' + to_string(*entryIter); return true; } @@ -212,13 +207,14 @@ getAccountObjects( if (!dir) return true; - if (i == mlimit) + if (itemsAdded == limitLeft) { - auto const& e = dir->getFieldV256(sfIndexes); - if (!e.empty()) + auto const& currentDirEntries = dir->getFieldV256(sfIndexes); + if (!currentDirEntries.empty()) { jvResult[jss::limit] = limit; - jvResult[jss::marker] = to_string(dirIndex) + ',' + to_string(*e.begin()); + jvResult[jss::marker] = + to_string(dirIndex) + ',' + to_string(*currentDirEntries.begin()); } return true; diff --git a/src/xrpld/rpc/handlers/account/AccountOffers.cpp b/src/xrpld/rpc/handlers/account/AccountOffers.cpp index 6314dc8ec2..f8ce85099a 100644 --- a/src/xrpld/rpc/handlers/account/AccountOffers.cpp +++ b/src/xrpld/rpc/handlers/account/AccountOffers.cpp @@ -36,7 +36,7 @@ void appendOfferJson(std::shared_ptr const& offer, json::Value& offers) { STAmount const dirRate = amountFromQuality(getQuality(offer->getFieldH256(sfBookDirectory))); - json::Value& obj(offers.append(json::ObjectValue)); + json::Value& obj(offers.append(json::ValueType::Object)); offer->getFieldAmount(sfTakerPays).setJson(obj[jss::taker_pays]); offer->getFieldAmount(sfTakerGets).setJson(obj[jss::taker_gets]); obj[jss::seq] = offer->getFieldU32(sfSequence); @@ -86,7 +86,7 @@ doAccountOffers(RPC::JsonContext& context) if (auto err = readLimitField(limit, RPC::Tuning::kACCOUNT_OFFERS, context)) return *err; - json::Value& jsonOffers(result[jss::offers] = json::ArrayValue); + json::Value& jsonOffers(result[jss::offers] = json::ValueType::Array); std::vector> offers; uint256 startAfter = beast::kZERO; std::uint64_t startHint = 0; diff --git a/src/xrpld/rpc/handlers/account/AccountTx.cpp b/src/xrpld/rpc/handlers/account/AccountTx.cpp index 7c8e45f523..f1c1309d59 100644 --- a/src/xrpld/rpc/handlers/account/AccountTx.cpp +++ b/src/xrpld/rpc/handlers/account/AccountTx.cpp @@ -293,7 +293,7 @@ populateJsonResponse( response[jss::ledger_index_min] = result.ledgerRange.min; response[jss::ledger_index_max] = result.ledgerRange.max; - json::Value& jvTxns = (response[jss::transactions] = json::ArrayValue); + json::Value& jvTxns = (response[jss::transactions] = json::ValueType::Array); if (auto txnsData = std::get_if(&result.transactions)) { @@ -303,14 +303,18 @@ populateJsonResponse( { if (txn) { - json::Value& jvObj = jvTxns.append(json::ObjectValue); + json::Value& jvObj = jvTxns.append(json::ValueType::Object); jvObj[jss::validated] = true; auto const jsonTx = (context.apiVersion > 1 ? jss::tx_json : jss::tx); if (context.apiVersion > 1) { jvObj[jsonTx] = txn->getJson( - JsonOptions::KIncludeDate | JsonOptions::KDisableApiPriorV2, false); + static_cast( + JsonOptions::Values::IncludeDate) | + static_cast( + JsonOptions::Values::DisableApiPriorV2), + false); jvObj[jss::hash] = to_string(txn->getID()); jvObj[jss::ledger_index] = txn->getLedger(); jvObj[jss::ledger_hash] = @@ -322,14 +326,14 @@ populateJsonResponse( } else { - jvObj[jsonTx] = txn->getJson(JsonOptions::KIncludeDate); + jvObj[jsonTx] = txn->getJson(JsonOptions::Values::IncludeDate); } auto const& sttx = txn->getSTransaction(); RPC::insertDeliverMax(jvObj[jsonTx], sttx->getTxnType(), context.apiVersion); if (txnMeta) { - jvObj[jss::meta] = txnMeta->getJson(JsonOptions::KIncludeDate); + jvObj[jss::meta] = txnMeta->getJson(JsonOptions::Values::IncludeDate); insertDeliveredAmount(jvObj[jss::meta], context, txn, *txnMeta); RPC::insertNFTSyntheticInJson(jvObj, sttx, *txnMeta); RPC::insertMPTokenIssuanceID(jvObj[jss::meta], sttx, *txnMeta); @@ -351,7 +355,7 @@ populateJsonResponse( for (auto const& binaryData : std::get(result.transactions)) { - json::Value& jvObj = jvTxns.append(json::ObjectValue); + json::Value& jvObj = jvTxns.append(json::ValueType::Object); jvObj[jss::tx_blob] = strHex(std::get<0>(binaryData)); auto const jsonMeta = (context.apiVersion > 1 ? jss::meta_blob : jss::meta); @@ -363,7 +367,7 @@ populateJsonResponse( if (result.marker) { - response[jss::marker] = json::ObjectValue; + response[jss::marker] = json::ValueType::Object; response[jss::marker][jss::ledger] = result.marker->ledgerSeq; response[jss::marker][jss::seq] = result.marker->txnSeq; } @@ -436,8 +440,8 @@ doAccountTx(RPC::JsonContext& context) { auto& token = params[jss::marker]; if (!token.isMember(jss::ledger) || !token.isMember(jss::seq) || - !token[jss::ledger].isConvertibleTo(json::ValueType::UintValue) || - !token[jss::seq].isConvertibleTo(json::ValueType::UintValue)) + !token[jss::ledger].isConvertibleTo(json::ValueType::UInt) || + !token[jss::seq].isConvertibleTo(json::ValueType::UInt)) { RPC::Status const status{ RpcInvalidParams, diff --git a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp index 2f4c90e4e7..b8a2055069 100644 --- a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp +++ b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp @@ -99,7 +99,7 @@ doNoRippleCheck(RPC::JsonContext& context) json::Value dummy; // NOLINT(misc-const-correctness) json::Value& jvTransactions = - transactions ? (result[jss::transactions] = json::ArrayValue) : dummy; + transactions ? (result[jss::transactions] = json::ValueType::Array) : dummy; auto id = parseBase58(params[jss::account].asString()); if (!id) @@ -114,9 +114,9 @@ doNoRippleCheck(RPC::JsonContext& context) std::uint32_t seq = sle->getFieldU32(sfSequence); - json::Value& problems = (result["problems"] = json::ArrayValue); + json::Value& problems = (result["problems"] = json::ValueType::Array); - bool const bDefaultRipple = (sle->getFieldU32(sfFlags) & lsfDefaultRipple) != 0u; + bool const bDefaultRipple = sle->isFlag(lsfDefaultRipple); if (bDefaultRipple && !roleGateway) { @@ -130,7 +130,7 @@ doNoRippleCheck(RPC::JsonContext& context) problems.append("You should immediately set your default ripple flag"); if (transactions) { - json::Value& tx = jvTransactions.append(json::ObjectValue); + json::Value& tx = jvTransactions.append(json::ValueType::Object); tx["TransactionType"] = jss::AccountSet; tx["SetFlag"] = 8; fillTransaction(context, tx, accountID, seq, *ledger); @@ -143,8 +143,7 @@ doNoRippleCheck(RPC::JsonContext& context) { bool const bLow = accountID == ownedItem->getFieldAmount(sfLowLimit).getIssuer(); - bool const bNoRipple = - ownedItem->getFieldU32(sfFlags) & (bLow ? lsfLowNoRipple : lsfHighNoRipple); + bool const bNoRipple = ownedItem->isFlag(bLow ? lsfLowNoRipple : lsfHighNoRipple); std::string problem; bool needFix = false; @@ -173,9 +172,9 @@ doNoRippleCheck(RPC::JsonContext& context) ownedItem->getFieldAmount(bLow ? sfLowLimit : sfHighLimit)); limitAmount.get().account = peer; - json::Value& tx = jvTransactions.append(json::ObjectValue); + json::Value& tx = jvTransactions.append(json::ValueType::Object); tx["TransactionType"] = jss::TrustSet; - tx["LimitAmount"] = limitAmount.getJson(JsonOptions::KNone); + tx["LimitAmount"] = limitAmount.getJson(JsonOptions::Values::None); tx["Flags"] = bNoRipple ? tfClearNoRipple : tfSetNoRipple; fillTransaction(context, tx, accountID, seq, *ledger); diff --git a/src/xrpld/rpc/handlers/admin/UnlList.cpp b/src/xrpld/rpc/handlers/admin/UnlList.cpp index 58a5bd3c25..c3835c7ae0 100644 --- a/src/xrpld/rpc/handlers/admin/UnlList.cpp +++ b/src/xrpld/rpc/handlers/admin/UnlList.cpp @@ -14,11 +14,11 @@ namespace xrpl { json::Value doUnlList(RPC::JsonContext& context) { - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); context.app.getValidators().forEachListed( [&unl = obj[jss::unl]](PublicKey const& publicKey, bool trusted) { - json::Value node(json::ObjectValue); + json::Value node(json::ValueType::Object); node[jss::pubkey_validator] = toBase58(TokenType::NodePublic, publicKey); node[jss::trusted] = trusted; diff --git a/src/xrpld/rpc/handlers/admin/data/CanDelete.cpp b/src/xrpld/rpc/handlers/admin/data/CanDelete.cpp index ae67f1f0dd..9ec1157e66 100644 --- a/src/xrpld/rpc/handlers/admin/data/CanDelete.cpp +++ b/src/xrpld/rpc/handlers/admin/data/CanDelete.cpp @@ -24,7 +24,7 @@ doCanDelete(RPC::JsonContext& context) if (!context.app.getSHAMapStore().advisoryDelete()) return RPC::makeError(RpcNotEnabled); - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); if (context.params.isMember(jss::can_delete)) { diff --git a/src/xrpld/rpc/handlers/admin/keygen/ValidationCreate.cpp b/src/xrpld/rpc/handlers/admin/keygen/ValidationCreate.cpp index 4ef16c4f97..0849bad944 100644 --- a/src/xrpld/rpc/handlers/admin/keygen/ValidationCreate.cpp +++ b/src/xrpld/rpc/handlers/admin/keygen/ValidationCreate.cpp @@ -32,7 +32,7 @@ validationSeed(json::Value const& params) json::Value doValidationCreate(RPC::JsonContext& context) { - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); auto seed = validationSeed(context.params); diff --git a/src/xrpld/rpc/handlers/admin/keygen/WalletPropose.cpp b/src/xrpld/rpc/handlers/admin/keygen/WalletPropose.cpp index 3d670b9818..c783319049 100644 --- a/src/xrpld/rpc/handlers/admin/keygen/WalletPropose.cpp +++ b/src/xrpld/rpc/handlers/admin/keygen/WalletPropose.cpp @@ -126,7 +126,7 @@ walletPropose(json::Value const& params) auto const publicKey = generateKeyPair(*keyType, *seed).first; - json::Value obj(json::ObjectValue); + json::Value obj(json::ValueType::Object); auto const seed1751 = seedAs1751(*seed); auto const seedHex = strHex(*seed); diff --git a/src/xrpld/rpc/handlers/admin/log/LogLevel.cpp b/src/xrpld/rpc/handlers/admin/log/LogLevel.cpp index a18fd8cc89..1ff5aa1a27 100644 --- a/src/xrpld/rpc/handlers/admin/log/LogLevel.cpp +++ b/src/xrpld/rpc/handlers/admin/log/LogLevel.cpp @@ -19,13 +19,13 @@ json::Value doLogLevel(RPC::JsonContext& context) { // log_level - if (!context.params.isMember(jss::severity)) + if (not context.params.isMember(jss::severity)) { // get log severities - json::Value ret(json::ObjectValue); - json::Value lev(json::ObjectValue); + json::Value ret(json::ValueType::Object); + json::Value lev(json::ValueType::Object); - lev[jss::base] = Logs::toString(Logs::fromSeverity(context.app.getLogs().threshold())); + lev[jss::base] = Logs::toString(context.app.getLogs().threshold()); std::vector> const logTable( context.app.getLogs().partitionSeverities()); for (auto const& [k, v] : logTable) @@ -35,18 +35,17 @@ doLogLevel(RPC::JsonContext& context) return ret; } - LogSeverity const sv(Logs::fromString(context.params[jss::severity].asString())); + auto const severity = Logs::fromString(context.params[jss::severity].asString()); - if (sv == LSInvalid) + if (not severity.has_value()) return rpcError(RpcInvalidParams); - auto severity = Logs::toSeverity(sv); // log_level severity - if (!context.params.isMember(jss::partition)) + if (not context.params.isMember(jss::partition)) { // set base log threshold - context.app.getLogs().threshold(severity); - return json::ObjectValue; + context.app.getLogs().threshold(*severity); + return json::ValueType::Object; } // log_level partition severity base? @@ -57,14 +56,14 @@ doLogLevel(RPC::JsonContext& context) if (boost::iequals(partition, "base")) { - context.app.getLogs().threshold(severity); + context.app.getLogs().threshold(*severity); } else { - context.app.getLogs().get(partition).threshold(severity); + context.app.getLogs().get(partition).threshold(*severity); } - return json::ObjectValue; + return json::ValueType::Object; } return rpcError(RpcInvalidParams); diff --git a/src/xrpld/rpc/handlers/admin/peer/Connect.cpp b/src/xrpld/rpc/handlers/admin/peer/Connect.cpp index cfa79eeb82..1d5e537aba 100644 --- a/src/xrpld/rpc/handlers/admin/peer/Connect.cpp +++ b/src/xrpld/rpc/handlers/admin/peer/Connect.cpp @@ -32,7 +32,7 @@ doConnect(RPC::JsonContext& context) return RPC::missingFieldError(jss::ip); if (context.params.isMember(jss::port) && - !context.params[jss::port].isConvertibleTo(json::IntValue)) + !context.params[jss::port].isConvertibleTo(json::ValueType::Int)) { return rpcError(RpcInvalidParams); } diff --git a/src/xrpld/rpc/handlers/admin/peer/PeerReservationsAdd.cpp b/src/xrpld/rpc/handlers/admin/peer/PeerReservationsAdd.cpp index b437d17c6a..23b0d094b4 100644 --- a/src/xrpld/rpc/handlers/admin/peer/PeerReservationsAdd.cpp +++ b/src/xrpld/rpc/handlers/admin/peer/PeerReservationsAdd.cpp @@ -59,7 +59,7 @@ doPeerReservationsAdd(RPC::JsonContext& context) auto const previous = context.app.getPeerReservations().insertOrAssign( PeerReservation{.nodeId = nodeId, .description = desc}); - json::Value result{json::ObjectValue}; + json::Value result{json::ValueType::Object}; if (previous) { result[jss::previous] = previous->toJson(); diff --git a/src/xrpld/rpc/handlers/admin/peer/PeerReservationsDel.cpp b/src/xrpld/rpc/handlers/admin/peer/PeerReservationsDel.cpp index 374170b135..40042a0390 100644 --- a/src/xrpld/rpc/handlers/admin/peer/PeerReservationsDel.cpp +++ b/src/xrpld/rpc/handlers/admin/peer/PeerReservationsDel.cpp @@ -31,7 +31,7 @@ doPeerReservationsDel(RPC::JsonContext& context) auto const previous = context.app.getPeerReservations().erase(nodeId); - json::Value result{json::ObjectValue}; + json::Value result{json::ValueType::Object}; if (previous) { result[jss::previous] = previous->toJson(); diff --git a/src/xrpld/rpc/handlers/admin/peer/PeerReservationsList.cpp b/src/xrpld/rpc/handlers/admin/peer/PeerReservationsList.cpp index a9323340f9..95da4c8567 100644 --- a/src/xrpld/rpc/handlers/admin/peer/PeerReservationsList.cpp +++ b/src/xrpld/rpc/handlers/admin/peer/PeerReservationsList.cpp @@ -12,8 +12,8 @@ doPeerReservationsList(RPC::JsonContext& context) auto const& reservations = context.app.getPeerReservations().list(); // Enumerate the reservations in context.app.getPeerReservations() // as a json::Value. - json::Value result{json::ObjectValue}; - json::Value& jaReservations = result[jss::reservations] = json::ArrayValue; + json::Value result{json::ValueType::Object}; + json::Value& jaReservations = result[jss::reservations] = json::ValueType::Array; for (auto const& reservation : reservations) { jaReservations.append(reservation.toJson()); diff --git a/src/xrpld/rpc/handlers/admin/peer/Peers.cpp b/src/xrpld/rpc/handlers/admin/peer/Peers.cpp index 41132826e4..ab14325f0e 100644 --- a/src/xrpld/rpc/handlers/admin/peer/Peers.cpp +++ b/src/xrpld/rpc/handlers/admin/peer/Peers.cpp @@ -19,7 +19,7 @@ namespace xrpl { json::Value doPeers(RPC::JsonContext& context) { - json::Value jvResult(json::ObjectValue); + json::Value jvResult(json::ValueType::Object); jvResult[jss::peers] = context.app.getOverlay().json(); @@ -47,7 +47,7 @@ doPeers(RPC::JsonContext& context) auto const now = context.app.getTimeKeeper().now(); auto const self = context.app.nodeIdentity().first; - json::Value& cluster = (jvResult[jss::cluster] = json::ObjectValue); + json::Value& cluster = (jvResult[jss::cluster] = json::ValueType::Object); std::uint32_t const ref = context.app.getFeeTrack().getLoadBase(); context.app.getCluster().forEach([&cluster, now, ref, &self](ClusterNode const& node) { diff --git a/src/xrpld/rpc/handlers/admin/signing/ChannelAuthorize.cpp b/src/xrpld/rpc/handlers/admin/signing/ChannelAuthorize.cpp index d9b6cfb2eb..be3ce13d45 100644 --- a/src/xrpld/rpc/handlers/admin/signing/ChannelAuthorize.cpp +++ b/src/xrpld/rpc/handlers/admin/signing/ChannelAuthorize.cpp @@ -68,7 +68,7 @@ doChannelAuthorize(RPC::JsonContext& context) return rpcError(RpcChannelMalformed); std::optional const optDrops = - params[jss::amount].isString() ? toUint64(params[jss::amount].asString()) : std::nullopt; + params[jss::amount].isString() ? toUInt64(params[jss::amount].asString()) : std::nullopt; if (!optDrops) return rpcError(RpcChannelAmtMalformed); diff --git a/src/xrpld/rpc/handlers/admin/status/ConsensusInfo.cpp b/src/xrpld/rpc/handlers/admin/status/ConsensusInfo.cpp index d55d4bb206..341980ba6d 100644 --- a/src/xrpld/rpc/handlers/admin/status/ConsensusInfo.cpp +++ b/src/xrpld/rpc/handlers/admin/status/ConsensusInfo.cpp @@ -9,7 +9,7 @@ namespace xrpl { json::Value doConsensusInfo(RPC::JsonContext& context) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret[jss::info] = context.netOps.getConsensusInfo(); diff --git a/src/xrpld/rpc/handlers/admin/status/FetchInfo.cpp b/src/xrpld/rpc/handlers/admin/status/FetchInfo.cpp index 5cf05ee00f..16e4789025 100644 --- a/src/xrpld/rpc/handlers/admin/status/FetchInfo.cpp +++ b/src/xrpld/rpc/handlers/admin/status/FetchInfo.cpp @@ -9,7 +9,7 @@ namespace xrpl { json::Value doFetchInfo(RPC::JsonContext& context) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); if (context.params.isMember(jss::clear) && context.params[jss::clear].asBool()) { diff --git a/src/xrpld/rpc/handlers/admin/status/GetCounts.cpp b/src/xrpld/rpc/handlers/admin/status/GetCounts.cpp index 83a2aa2127..789c6dcf17 100644 --- a/src/xrpld/rpc/handlers/admin/status/GetCounts.cpp +++ b/src/xrpld/rpc/handlers/admin/status/GetCounts.cpp @@ -47,7 +47,7 @@ getCountsJson(Application& app, int minObjectCount) { auto objectCounts = CountedObjects::getInstance().getCounts(minObjectCount); - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); for (auto const& [k, v] : objectCounts) { diff --git a/src/xrpld/rpc/handlers/ledger/Ledger.cpp b/src/xrpld/rpc/handlers/ledger/Ledger.cpp index 2b6116da27..7034dce768 100644 --- a/src/xrpld/rpc/handlers/ledger/Ledger.cpp +++ b/src/xrpld/rpc/handlers/ledger/Ledger.cpp @@ -80,10 +80,13 @@ LedgerHandler::check() if (!queue.has_value()) return queue.error(); - options_ = (*full ? LedgerFill::Full : 0) | (*expand ? LedgerFill::Expand : 0) | - (*transactions ? LedgerFill::DumpTxrp : 0) | (*accounts ? LedgerFill::DumpState : 0) | - (*binary ? LedgerFill::Binary : 0) | (*ownerFunds ? LedgerFill::OwnerFunds : 0) | - (*queue ? LedgerFill::DumpQueue : 0); + options_ = (*full ? static_cast(LedgerFill::Options::Full) : 0) | + (*expand ? static_cast(LedgerFill::Options::Expand) : 0) | + (*transactions ? static_cast(LedgerFill::Options::DumpTxrp) : 0) | + (*accounts ? static_cast(LedgerFill::Options::DumpState) : 0) | + (*binary ? static_cast(LedgerFill::Options::Binary) : 0) | + (*ownerFunds ? static_cast(LedgerFill::Options::OwnerFunds) : 0) | + (*queue ? static_cast(LedgerFill::Options::DumpQueue) : 0); bool const needsLedger = params.isMember(jss::ledger) || params.isMember(jss::ledger_hash) || params.isMember(jss::ledger_index); @@ -134,19 +137,19 @@ LedgerHandler::writeResult(json::Value& value) { auto& master = context_.app.getLedgerMaster(); { - auto& closed = value[jss::closed] = json::ObjectValue; + auto& closed = value[jss::closed] = json::ValueType::Object; addJson(closed, {*master.getClosedLedger(), &context_, 0}); } { - auto& open = value[jss::open] = json::ObjectValue; + auto& open = value[jss::open] = json::ValueType::Object; addJson(open, {*master.getCurrentLedger(), &context_, 0}); } } - json::Value warnings{json::ArrayValue}; + json::Value warnings{json::ValueType::Array}; if (context_.params.isMember(jss::type)) { - json::Value& w = warnings.append(json::ObjectValue); + json::Value& w = warnings.append(json::ValueType::Object); w[jss::id] = WarnRpcFieldsDeprecated; w[jss::message] = "Some fields from your request are deprecated. Please check the " diff --git a/src/xrpld/rpc/handlers/ledger/Ledger.h b/src/xrpld/rpc/handlers/ledger/Ledger.h index 2ac9b99a06..83ea4314e5 100644 --- a/src/xrpld/rpc/handlers/ledger/Ledger.h +++ b/src/xrpld/rpc/handlers/ledger/Ledger.h @@ -46,7 +46,7 @@ public: static constexpr Role role = Role::USER; - static constexpr Condition condition = NoCondition; + static constexpr Condition condition = Condition::NoCondition; // NOLINTEND(readability-identifier-naming) private: diff --git a/src/xrpld/rpc/handlers/ledger/LedgerData.cpp b/src/xrpld/rpc/handlers/ledger/LedgerData.cpp index f450c88dab..64ab30374b 100644 --- a/src/xrpld/rpc/handlers/ledger/LedgerData.cpp +++ b/src/xrpld/rpc/handlers/ledger/LedgerData.cpp @@ -82,8 +82,8 @@ doLedgerData(RPC::JsonContext& context) if (!isMarker) { // Return base ledger data on first query - jvResult[jss::ledger] = - getJson(LedgerFill(*lpLedger, &context, isBinary ? LedgerFill::Options::Binary : 0)); + jvResult[jss::ledger] = getJson(LedgerFill( + *lpLedger, &context, isBinary ? static_cast(LedgerFill::Options::Binary) : 0)); } auto [rpcStatus, type] = RPC::chooseLedgerEntryType(params); @@ -94,9 +94,9 @@ doLedgerData(RPC::JsonContext& context) return jvResult; } json::Value& nodes = jvResult[jss::state]; - if (nodes.type() == json::NullValue) + if (nodes.type() == json::ValueType::Null) { - nodes = json::Value(json::ArrayValue); + nodes = json::Value(json::ValueType::Array); } auto e = lpLedger->sles.end(); @@ -115,13 +115,13 @@ doLedgerData(RPC::JsonContext& context) { if (isBinary) { - json::Value& entry = nodes.append(json::ObjectValue); + json::Value& entry = nodes.append(json::ValueType::Object); entry[jss::data] = serializeHex(*sle); entry[jss::index] = to_string(sle->key()); } else { - json::Value& entry = nodes.append(sle->getJson(JsonOptions::KNone)); + json::Value& entry = nodes.append(sle->getJson(JsonOptions::Values::None)); entry[jss::index] = to_string(sle->key()); } } diff --git a/src/xrpld/rpc/handlers/ledger/LedgerEntry.cpp b/src/xrpld/rpc/handlers/ledger/LedgerEntry.cpp index a5fcee7a5e..f07b7f2f06 100644 --- a/src/xrpld/rpc/handlers/ledger/LedgerEntry.cpp +++ b/src/xrpld/rpc/handlers/ledger/LedgerEntry.cpp @@ -377,7 +377,7 @@ parseDirectoryNode( } if (params.isMember(jss::sub_index) && - (!params[jss::sub_index].isConvertibleTo(json::UintValue) || + (!params[jss::sub_index].isConvertibleTo(json::ValueType::UInt) || params[jss::sub_index].isBool())) { return LedgerEntryHelpers::invalidFieldError("malformedRequest", jss::sub_index, "number"); @@ -970,7 +970,7 @@ doLedgerEntry(RPC::JsonContext& context) } else { - jvResult[jss::node] = sleNode->getJson(JsonOptions::KNone); + jvResult[jss::node] = sleNode->getJson(JsonOptions::Values::None); } return jvResult; diff --git a/src/xrpld/rpc/handlers/ledger/LedgerEntryHelpers.h b/src/xrpld/rpc/handlers/ledger/LedgerEntryHelpers.h index a5b83e8501..e8e295ca2c 100644 --- a/src/xrpld/rpc/handlers/ledger/LedgerEntryHelpers.h +++ b/src/xrpld/rpc/handlers/ledger/LedgerEntryHelpers.h @@ -17,7 +17,7 @@ namespace xrpl::LedgerEntryHelpers { inline Unexpected missingFieldError(json::StaticString const field, std::optional err = std::nullopt) { - json::Value json = json::ObjectValue; + json::Value json = json::ValueType::Object; json[jss::error] = err.value_or("malformedRequest"); json[jss::error_code] = RpcInvalidParams; json[jss::error_message] = RPC::missingFieldMessage(std::string(field.cStr())); @@ -27,7 +27,7 @@ missingFieldError(json::StaticString const field, std::optional err inline Unexpected invalidFieldError(std::string const& err, json::StaticString const field, std::string const& type) { - json::Value json = json::ObjectValue; + json::Value json = json::ValueType::Object; json[jss::error] = err; json[jss::error_code] = RpcInvalidParams; json[jss::error_message] = RPC::expectedFieldMessage(field, type); @@ -37,7 +37,7 @@ invalidFieldError(std::string const& err, json::StaticString const field, std::s inline Unexpected malformedError(std::string const& err, std::string const& message) { - json::Value json = json::ObjectValue; + json::Value json = json::ValueType::Object; json[jss::error] = err; json[jss::error_code] = RpcInvalidParams; json[jss::error_message] = message; diff --git a/src/xrpld/rpc/handlers/orderbook/AMMInfo.cpp b/src/xrpld/rpc/handlers/orderbook/AMMInfo.cpp index 73dfb178bc..38251f855f 100644 --- a/src/xrpld/rpc/handlers/orderbook/AMMInfo.cpp +++ b/src/xrpld/rpc/handlers/orderbook/AMMInfo.cpp @@ -194,7 +194,7 @@ doAMMInfo(RPC::JsonContext& context) lptAMMBalance.setJson(ammResult[jss::lp_token]); ammResult[jss::trading_fee] = (*amm)[sfTradingFee]; ammResult[jss::account] = to_string(ammAccountID); - json::Value voteSlots(json::ArrayValue); + json::Value voteSlots(json::ValueType::Array); if (amm->isFieldPresent(sfVoteSlots)) { for (auto const& voteEntry : amm->getFieldArray(sfVoteSlots)) diff --git a/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp b/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp index 2c9c53620c..390dd88166 100644 --- a/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp +++ b/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp @@ -249,7 +249,7 @@ doBookOffers(RPC::JsonContext& context) json::Value const jvMarker( context.params.isMember(jss::marker) ? context.params[jss::marker] - : json::Value(json::NullValue)); + : json::Value(json::ValueType::Null)); context.netOps.getBookPage( lpLedger, diff --git a/src/xrpld/rpc/handlers/orderbook/DepositAuthorized.cpp b/src/xrpld/rpc/handlers/orderbook/DepositAuthorized.cpp index 7e9f891e7f..4963663b39 100644 --- a/src/xrpld/rpc/handlers/orderbook/DepositAuthorized.cpp +++ b/src/xrpld/rpc/handlers/orderbook/DepositAuthorized.cpp @@ -86,7 +86,7 @@ doDepositAuthorized(RPC::JsonContext& context) return result; } - bool const reqAuth = ((sleDest->getFlags() & lsfDepositAuth) != 0u) && (srcAcct != dstAcct); + bool const reqAuth = sleDest->isFlag(lsfDepositAuth) && (srcAcct != dstAcct); bool const credentialsPresent = params.isMember(jss::credentials); std::set> sorted; @@ -135,13 +135,13 @@ doDepositAuthorized(RPC::JsonContext& context) return result; } - if ((sleCred->getFlags() & lsfAccepted) == 0u) + if (!sleCred->isFlag(lsfAccepted)) { RPC::injectError(RpcBadCredentials, "credentials aren't accepted", result); return result; } - if (credentials::checkExpired(sleCred, ledger->header().parentCloseTime)) + if (credentials::checkExpired(*sleCred, ledger->header().parentCloseTime)) { RPC::injectError(RpcBadCredentials, "credentials are expired", result); return result; diff --git a/src/xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h b/src/xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h index ed68ae3ac1..822896a644 100644 --- a/src/xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h +++ b/src/xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h @@ -22,7 +22,7 @@ appendNftOfferJson( std::shared_ptr const& offer, json::Value& offers) { - json::Value& obj(offers.append(json::ObjectValue)); + json::Value& obj(offers.append(json::ValueType::Object)); obj[jss::nft_offer_index] = to_string(offer->key()); obj[jss::flags] = (*offer)[sfFlags]; @@ -62,7 +62,7 @@ enumerateNFTOffers(RPC::JsonContext& context, uint256 const& nftId, Keylet const json::Value result; result[jss::nft_id] = to_string(nftId); - json::Value& jsonOffers(result[jss::offers] = json::ArrayValue); + json::Value& jsonOffers(result[jss::offers] = json::ValueType::Array); std::vector> offers; unsigned int reserve(limit); diff --git a/src/xrpld/rpc/handlers/server_info/Feature.cpp b/src/xrpld/rpc/handlers/server_info/Feature.cpp index 4de07297d4..bd7198b61c 100644 --- a/src/xrpld/rpc/handlers/server_info/Feature.cpp +++ b/src/xrpld/rpc/handlers/server_info/Feature.cpp @@ -47,7 +47,7 @@ doFeature(RPC::JsonContext& context) features[to_string(h)][jss::majority] = t.time_since_epoch().count(); } - json::Value jvReply = json::ObjectValue; + json::Value jvReply = json::ValueType::Object; jvReply[jss::features] = features; return jvReply; } diff --git a/src/xrpld/rpc/handlers/server_info/Fee.cpp b/src/xrpld/rpc/handlers/server_info/Fee.cpp index a3847d743a..1fe5476d50 100644 --- a/src/xrpld/rpc/handlers/server_info/Fee.cpp +++ b/src/xrpld/rpc/handlers/server_info/Fee.cpp @@ -11,7 +11,7 @@ json::Value doFee(RPC::JsonContext& context) { auto result = context.app.getTxQ().doRPC(context.app); - if (result.type() == json::ObjectValue) + if (result.type() == json::ValueType::Object) return result; // LCOV_EXCL_START diff --git a/src/xrpld/rpc/handlers/server_info/ServerDefinitions.cpp b/src/xrpld/rpc/handlers/server_info/ServerDefinitions.cpp index ca887bb0c8..a5a9836e27 100644 --- a/src/xrpld/rpc/handlers/server_info/ServerDefinitions.cpp +++ b/src/xrpld/rpc/handlers/server_info/ServerDefinitions.cpp @@ -122,10 +122,10 @@ ServerDefinitions::translate(std::string const& inp) return out; }; -ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} +ServerDefinitions::ServerDefinitions() : defs_{json::ValueType::Object} { // populate SerializedTypeID names and values - defs_[jss::TYPES] = json::ObjectValue; + defs_[jss::TYPES] = json::ValueType::Object; defs_[jss::TYPES]["Done"] = -1; std::map typeMap{{-1, "Done"}}; @@ -137,7 +137,7 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } // populate LedgerEntryType names and values - defs_[jss::LEDGER_ENTRY_TYPES] = json::ObjectValue; + defs_[jss::LEDGER_ENTRY_TYPES] = json::ValueType::Object; defs_[jss::LEDGER_ENTRY_TYPES][jss::Invalid] = -1; for (auto const& f : LedgerFormats::getInstance()) @@ -146,26 +146,14 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } // populate SField serialization data - defs_[jss::FIELDS] = json::ArrayValue; + defs_[jss::FIELDS] = json::ValueType::Array; uint32_t i = 0; - { - json::Value a = json::ArrayValue; - a[0U] = "Generic"; - json::Value v = json::ObjectValue; - v[jss::nth] = 0; - v[jss::isVLEncoded] = false; - v[jss::isSerialized] = false; - v[jss::isSigningField] = false; - v[jss::type] = "Unknown"; - a[1U] = v; - defs_[jss::FIELDS][i++] = a; - } { - json::Value a = json::ArrayValue; + json::Value a = json::ValueType::Array; a[0U] = "Invalid"; - json::Value v = json::ObjectValue; + json::Value v = json::ValueType::Object; v[jss::nth] = -1; v[jss::isVLEncoded] = false; v[jss::isSerialized] = false; @@ -176,9 +164,9 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } { - json::Value a = json::ArrayValue; + json::Value a = json::ValueType::Array; a[0U] = "ObjectEndMarker"; - json::Value v = json::ObjectValue; + json::Value v = json::ValueType::Object; v[jss::nth] = 1; v[jss::isVLEncoded] = false; v[jss::isSerialized] = true; @@ -189,9 +177,9 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } { - json::Value a = json::ArrayValue; + json::Value a = json::ValueType::Array; a[0U] = "ArrayEndMarker"; - json::Value v = json::ObjectValue; + json::Value v = json::ValueType::Object; v[jss::nth] = 1; v[jss::isVLEncoded] = false; v[jss::isSerialized] = true; @@ -202,9 +190,9 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } { - json::Value a = json::ArrayValue; + json::Value a = json::ValueType::Array; a[0U] = "taker_gets_funded"; - json::Value v = json::ObjectValue; + json::Value v = json::ValueType::Object; v[jss::nth] = 258; v[jss::isVLEncoded] = false; v[jss::isSerialized] = false; @@ -215,9 +203,9 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } { - json::Value a = json::ArrayValue; + json::Value a = json::ValueType::Array; a[0U] = "taker_pays_funded"; - json::Value v = json::ObjectValue; + json::Value v = json::ValueType::Object; v[jss::nth] = 259; v[jss::isVLEncoded] = false; v[jss::isSerialized] = false; @@ -227,21 +215,28 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} defs_[jss::FIELDS][i++] = a; } - for (auto const& [code, field] : xrpl::SField::getKnownCodeToField()) + // copy into a sorted map to ensure deterministic output order (sorted by fieldCode) + static std::map const kSORTED_FIELDS( + xrpl::SField::getKnownCodeToField().begin(), xrpl::SField::getKnownCodeToField().end()); + + for (auto const& [code, field] : kSORTED_FIELDS) { if (field->fieldName.empty()) continue; - json::Value innerObj = json::ObjectValue; + json::Value innerObj = json::ValueType::Object; - uint32_t type = field->fieldType; + int32_t const type = field->fieldType; innerObj[jss::nth] = field->fieldValue; // whether the field is variable-length encoded this means that the length is included // before the content innerObj[jss::isVLEncoded] = - (type == 7U /* Blob */ || type == 8U /* AccountID */ || type == 19U /* Vector256 */); + (type == STI_VL || type == STI_ACCOUNT || type == STI_VECTOR256); + static_assert( + STI_VL == 7U && STI_ACCOUNT == 8U && STI_VECTOR256 == 19U, + "STI_VL, STI_ACCOUNT, STI_VECTOR256 must be 7, 8, 19 respectively"); // whether the field is included in serialization innerObj[jss::isSerialized] = @@ -254,7 +249,7 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} innerObj[jss::type] = typeMap[type]; - json::Value innerArray = json::ArrayValue; + json::Value innerArray = json::ValueType::Array; innerArray[0U] = field->fieldName; innerArray[1U] = innerObj; @@ -262,7 +257,7 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } // populate TER code names and values - defs_[jss::TRANSACTION_RESULTS] = json::ObjectValue; + defs_[jss::TRANSACTION_RESULTS] = json::ValueType::Object; for (auto const& [code, terInfo] : transResults()) { @@ -270,7 +265,7 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } // populate TxType names and values - defs_[jss::TRANSACTION_TYPES] = json::ObjectValue; + defs_[jss::TRANSACTION_TYPES] = json::ValueType::Object; defs_[jss::TRANSACTION_TYPES][jss::Invalid] = -1; for (auto const& f : TxFormats::getInstance()) { @@ -278,13 +273,13 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } // populate TxFormats - defs_[jss::TRANSACTION_FORMATS] = json::ObjectValue; + defs_[jss::TRANSACTION_FORMATS] = json::ValueType::Object; - defs_[jss::TRANSACTION_FORMATS][jss::common] = json::ArrayValue; + defs_[jss::TRANSACTION_FORMATS][jss::common] = json::ValueType::Array; auto txCommonFields = std::set(); for (auto const& element : TxFormats::getCommonFields()) { - json::Value elementObj = json::ObjectValue; + json::Value elementObj = json::ValueType::Object; elementObj[jss::name] = element.sField().getName(); elementObj[jss::optionality] = element.style(); defs_[jss::TRANSACTION_FORMATS][jss::common].append(elementObj); @@ -294,12 +289,12 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} for (auto const& format : TxFormats::getInstance()) { auto const& soTemplate = format.getSOTemplate(); - json::Value templateArray = json::ArrayValue; + json::Value templateArray = json::ValueType::Array; for (auto const& element : soTemplate) { if (txCommonFields.contains(element.sField().getName())) continue; // skip common fields, already added - json::Value elementObj = json::ObjectValue; + json::Value elementObj = json::ValueType::Object; elementObj[jss::name] = element.sField().getName(); elementObj[jss::optionality] = element.style(); templateArray.append(elementObj); @@ -308,12 +303,12 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} } // populate LedgerFormats - defs_[jss::LEDGER_ENTRY_FORMATS] = json::ObjectValue; - defs_[jss::LEDGER_ENTRY_FORMATS][jss::common] = json::ArrayValue; + defs_[jss::LEDGER_ENTRY_FORMATS] = json::ValueType::Object; + defs_[jss::LEDGER_ENTRY_FORMATS][jss::common] = json::ValueType::Array; auto ledgerCommonFields = std::set(); for (auto const& element : LedgerFormats::getCommonFields()) { - json::Value elementObj = json::ObjectValue; + json::Value elementObj = json::ValueType::Object; elementObj[jss::name] = element.sField().getName(); elementObj[jss::optionality] = element.style(); defs_[jss::LEDGER_ENTRY_FORMATS][jss::common].append(elementObj); @@ -322,12 +317,12 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} for (auto const& format : LedgerFormats::getInstance()) { auto const& soTemplate = format.getSOTemplate(); - json::Value templateArray = json::ArrayValue; + json::Value templateArray = json::ValueType::Array; for (auto const& element : soTemplate) { if (ledgerCommonFields.contains(element.sField().getName())) continue; // skip common fields, already added - json::Value elementObj = json::ObjectValue; + json::Value elementObj = json::ValueType::Object; elementObj[jss::name] = element.sField().getName(); elementObj[jss::optionality] = element.style(); templateArray.append(elementObj); @@ -335,10 +330,10 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} defs_[jss::LEDGER_ENTRY_FORMATS][format.getName()] = templateArray; } - defs_[jss::TRANSACTION_FLAGS] = json::ObjectValue; + defs_[jss::TRANSACTION_FLAGS] = json::ValueType::Object; for (auto const& [name, value] : getAllTxFlags()) { - json::Value txObj = json::ObjectValue; + json::Value txObj = json::ValueType::Object; for (auto const& [flagName, flagValue] : value) { txObj[flagName] = flagValue; @@ -346,10 +341,10 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} defs_[jss::TRANSACTION_FLAGS][name] = txObj; } - defs_[jss::LEDGER_ENTRY_FLAGS] = json::ObjectValue; + defs_[jss::LEDGER_ENTRY_FLAGS] = json::ValueType::Object; for (auto const& [name, value] : getAllLedgerFlags()) { - json::Value ledgerObj = json::ObjectValue; + json::Value ledgerObj = json::ValueType::Object; for (auto const& [flagName, flagValue] : value) { ledgerObj[flagName] = flagValue; @@ -357,7 +352,7 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} defs_[jss::LEDGER_ENTRY_FLAGS][name] = ledgerObj; } - defs_[jss::ACCOUNT_SET_FLAGS] = json::ObjectValue; + defs_[jss::ACCOUNT_SET_FLAGS] = json::ValueType::Object; for (auto const& [name, value] : getAsfFlagMap()) { defs_[jss::ACCOUNT_SET_FLAGS][name] = value; @@ -401,7 +396,7 @@ doServerDefinitions(RPC::JsonContext& context) auto const& defs = detail::getDefinitions(); if (defs.hashMatches(hash)) { - json::Value jv = json::ObjectValue; + json::Value jv = json::ValueType::Object; jv[jss::hash] = to_string(hash); return jv; } diff --git a/src/xrpld/rpc/handlers/server_info/ServerInfo.cpp b/src/xrpld/rpc/handlers/server_info/ServerInfo.cpp index af401cd22f..aaad9d2b02 100644 --- a/src/xrpld/rpc/handlers/server_info/ServerInfo.cpp +++ b/src/xrpld/rpc/handlers/server_info/ServerInfo.cpp @@ -11,7 +11,7 @@ namespace xrpl { json::Value doServerInfo(RPC::JsonContext& context) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret[jss::info] = context.netOps.getServerInfo( true, diff --git a/src/xrpld/rpc/handlers/server_info/ServerState.cpp b/src/xrpld/rpc/handlers/server_info/ServerState.cpp index a3730ca703..acf4e9eb43 100644 --- a/src/xrpld/rpc/handlers/server_info/ServerState.cpp +++ b/src/xrpld/rpc/handlers/server_info/ServerState.cpp @@ -10,7 +10,7 @@ namespace xrpl { json::Value doServerState(RPC::JsonContext& context) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); ret[jss::state] = context.netOps.getServerInfo( false, diff --git a/src/xrpld/rpc/handlers/server_info/Version.h b/src/xrpld/rpc/handlers/server_info/Version.h index 04c9d0f75c..c3ae5cf39f 100644 --- a/src/xrpld/rpc/handlers/server_info/Version.h +++ b/src/xrpld/rpc/handlers/server_info/Version.h @@ -33,7 +33,7 @@ public: static constexpr Role role = Role::USER; - static constexpr Condition condition = NoCondition; + static constexpr Condition condition = Condition::NoCondition; // NOLINTEND(readability-identifier-naming) private: diff --git a/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp b/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp index dee88533af..adad854eb9 100644 --- a/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp +++ b/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp @@ -30,7 +30,7 @@ json::Value doSubscribe(RPC::JsonContext& context) { InfoSub::pointer ispSub; - json::Value jvResult(json::ObjectValue); + json::Value jvResult(json::ValueType::Object); if (!context.infoSub && !context.params.isMember(jss::url)) { @@ -290,8 +290,8 @@ doSubscribe(RPC::JsonContext& context) context.app.getLedgerMaster().getPublishedLedger(); if (lpLedger) { - json::Value const jvMarker = json::Value(json::NullValue); - json::Value jvOffers(json::ObjectValue); + json::Value const jvMarker = json::Value(json::ValueType::Null); + json::Value jvOffers(json::ValueType::Object); auto add = [&](json::StaticString field) { context.netOps.getBookPage( diff --git a/src/xrpld/rpc/handlers/subscribe/Unsubscribe.cpp b/src/xrpld/rpc/handlers/subscribe/Unsubscribe.cpp index 580f213ec4..36dae615b3 100644 --- a/src/xrpld/rpc/handlers/subscribe/Unsubscribe.cpp +++ b/src/xrpld/rpc/handlers/subscribe/Unsubscribe.cpp @@ -21,7 +21,7 @@ json::Value doUnsubscribe(RPC::JsonContext& context) { InfoSub::pointer ispSub; - json::Value jvResult(json::ObjectValue); + json::Value jvResult(json::ValueType::Object); bool removeUrl{false}; if (!context.infoSub && !context.params.isMember(jss::url)) diff --git a/src/xrpld/rpc/handlers/transaction/Simulate.cpp b/src/xrpld/rpc/handlers/transaction/Simulate.cpp index a119ea94f6..6f7940d4aa 100644 --- a/src/xrpld/rpc/handlers/transaction/Simulate.cpp +++ b/src/xrpld/rpc/handlers/transaction/Simulate.cpp @@ -194,7 +194,7 @@ getTxJsonFromParams(json::Value const& params) try { SerialIter sitTrans(makeSlice(*unHexed)); - txJson = STObject(std::ref(sitTrans), kSF_GENERIC).getJson(JsonOptions::KNone); + txJson = STObject(std::ref(sitTrans), kSF_GENERIC).getJson(JsonOptions::Values::None); } catch (std::runtime_error const&) { @@ -276,7 +276,7 @@ simulateTxn(RPC::JsonContext& context, std::shared_ptr transaction) } else { - jvResult[jss::meta] = result.metadata->getJson(JsonOptions::KNone); + jvResult[jss::meta] = result.metadata->getJson(JsonOptions::Values::None); RPC::insertDeliveredAmount( jvResult[jss::meta], view, transaction->getSTransaction(), *result.metadata); RPC::insertNFTSyntheticInJson( @@ -293,7 +293,7 @@ simulateTxn(RPC::JsonContext& context, std::shared_ptr transaction) } else { - jvResult[jss::tx_json] = transaction->getJson(JsonOptions::KNone); + jvResult[jss::tx_json] = transaction->getJson(JsonOptions::Values::None); } return jvResult; @@ -344,7 +344,7 @@ doSimulate(RPC::JsonContext& context) } catch (std::exception& e) { - json::Value jvResult = json::ObjectValue; + json::Value jvResult = json::ValueType::Object; jvResult[jss::error] = "invalidTransaction"; jvResult[jss::error_exception] = e.what(); return jvResult; @@ -365,7 +365,7 @@ doSimulate(RPC::JsonContext& context) // LCOV_EXCL_START this is just in case, so xrpld doesn't crash catch (std::exception const& e) { - json::Value jvResult = json::ObjectValue; + json::Value jvResult = json::ValueType::Object; jvResult[jss::error] = "internalSimulate"; jvResult[jss::error_exception] = e.what(); return jvResult; diff --git a/src/xrpld/rpc/handlers/transaction/Submit.cpp b/src/xrpld/rpc/handlers/transaction/Submit.cpp index d3ce5c3fc0..774297391a 100644 --- a/src/xrpld/rpc/handlers/transaction/Submit.cpp +++ b/src/xrpld/rpc/handlers/transaction/Submit.cpp @@ -141,7 +141,7 @@ doSubmit(RPC::JsonContext& context) try { - jvResult[jss::tx_json] = transaction->getJson(JsonOptions::KNone); + jvResult[jss::tx_json] = transaction->getJson(JsonOptions::Values::None); jvResult[jss::tx_blob] = strHex(transaction->getSTransaction()->getSerializer().peekData()); if (temUNCERTAIN != transaction->getResult()) diff --git a/src/xrpld/rpc/handlers/transaction/TransactionEntry.cpp b/src/xrpld/rpc/handlers/transaction/TransactionEntry.cpp index c951053c51..bb68226334 100644 --- a/src/xrpld/rpc/handlers/transaction/TransactionEntry.cpp +++ b/src/xrpld/rpc/handlers/transaction/TransactionEntry.cpp @@ -33,7 +33,7 @@ doTransactionEntry(RPC::JsonContext& context) { jvResult[jss::error] = "fieldNotFoundTransaction"; } - else if (jvResult.get(jss::ledger_hash, json::NullValue).isNull()) + else if (jvResult.get(jss::ledger_hash, json::ValueType::Null).isNull()) { // We don't work on ledger current. @@ -60,7 +60,7 @@ doTransactionEntry(RPC::JsonContext& context) { if (context.apiVersion > 1) { - jvResult[jss::tx_json] = sttx->getJson(JsonOptions::KDisableApiPriorV2); + jvResult[jss::tx_json] = sttx->getJson(JsonOptions::Values::DisableApiPriorV2); jvResult[jss::hash] = to_string(sttx->getTransactionID()); if (!lpLedger->open()) @@ -81,14 +81,14 @@ doTransactionEntry(RPC::JsonContext& context) } else { - jvResult[jss::tx_json] = sttx->getJson(JsonOptions::KNone); + jvResult[jss::tx_json] = sttx->getJson(JsonOptions::Values::None); } RPC::insertDeliverMax(jvResult[jss::tx_json], sttx->getTxnType(), context.apiVersion); auto const jsonMeta = (context.apiVersion > 1 ? jss::meta : jss::metadata); if (stobj) - jvResult[jsonMeta] = stobj->getJson(JsonOptions::KNone); + jvResult[jsonMeta] = stobj->getJson(JsonOptions::Values::None); // 'accounts' // 'engine_...' // 'ledger_...' diff --git a/src/xrpld/rpc/handlers/transaction/Tx.cpp b/src/xrpld/rpc/handlers/transaction/Tx.cpp index cddda6d2c2..099caeac42 100644 --- a/src/xrpld/rpc/handlers/transaction/Tx.cpp +++ b/src/xrpld/rpc/handlers/transaction/Tx.cpp @@ -190,7 +190,7 @@ populateJsonResponse( { if (error.toErrorCode() == RpcTxnNotFound && result.searchedAll != TxSearched::Unknown) { - response = json::Value(json::ObjectValue); + response = json::Value(json::ValueType::Object); response[jss::searched_all] = (result.searchedAll == TxSearched::All); error.inject(response); } @@ -206,7 +206,8 @@ populateJsonResponse( if (context.apiVersion > 1) { constexpr auto kOPTIONS_JSON = - JsonOptions::KIncludeDate | JsonOptions::KDisableApiPriorV2; + static_cast(JsonOptions::Values::IncludeDate) | + static_cast(JsonOptions::Values::DisableApiPriorV2); if (args.binary) { response[jss::tx_blob] = result.txn->getJson(kOPTIONS_JSON, true); @@ -233,7 +234,7 @@ populateJsonResponse( } else { - response = result.txn->getJson(JsonOptions::KIncludeDate, args.binary); + response = result.txn->getJson(JsonOptions::Values::IncludeDate, args.binary); if (!args.binary) RPC::insertDeliverMax(response, sttx->getTxnType(), context.apiVersion); } @@ -251,7 +252,7 @@ populateJsonResponse( auto& meta = *m; if (meta) { - response[jss::meta] = meta->getJson(JsonOptions::KNone); + response[jss::meta] = meta->getJson(JsonOptions::Values::None); insertDeliveredAmount(response[jss::meta], context, result.txn, *meta); RPC::insertNFTSyntheticInJson(response, sttx, *meta); RPC::insertMPTokenIssuanceID(response[jss::meta], sttx, *meta); diff --git a/src/xrpld/rpc/handlers/transaction/TxHistory.cpp b/src/xrpld/rpc/handlers/transaction/TxHistory.cpp index b7333d0115..75d03951a4 100644 --- a/src/xrpld/rpc/handlers/transaction/TxHistory.cpp +++ b/src/xrpld/rpc/handlers/transaction/TxHistory.cpp @@ -39,7 +39,7 @@ doTxHistory(RPC::JsonContext& context) for (auto const& t : trans) { - json::Value txJson = t->getJson(JsonOptions::KNone); + json::Value txJson = t->getJson(JsonOptions::Values::None); RPC::insertDeliverMax(txJson, t->getSTransaction()->getTxnType(), context.apiVersion); txs.append(txJson); } diff --git a/src/xrpld/rpc/handlers/utility/Ping.cpp b/src/xrpld/rpc/handlers/utility/Ping.cpp index 428b16ddd4..0d34b9e0fc 100644 --- a/src/xrpld/rpc/handlers/utility/Ping.cpp +++ b/src/xrpld/rpc/handlers/utility/Ping.cpp @@ -13,7 +13,7 @@ struct JsonContext; json::Value doPing(RPC::JsonContext& context) { - json::Value ret(json::ObjectValue); + json::Value ret(json::ValueType::Object); switch (context.role) { case Role::ADMIN: