diff --git a/.clang-tidy b/.clang-tidy index 33569be50a..ee6bde6eba 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -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 @@ -165,7 +171,7 @@ CheckOptions: readability-identifier-naming.EnumCase: CamelCase readability-identifier-naming.EnumConstantCase: CamelCase readability-identifier-naming.ScopedEnumConstantCase: CamelCase - readability-identifier-naming.GlobalConstantCase: UPPER_CASE + readability-identifier-naming.GlobalConstantCase: CamelCase readability-identifier-naming.GlobalConstantPrefix: "k" readability-identifier-naming.GlobalVariableCase: CamelCase readability-identifier-naming.GlobalVariablePrefix: "g" @@ -173,27 +179,26 @@ CheckOptions: readability-identifier-naming.ConstexprMethodCase: camelBack readability-identifier-naming.ClassMethodCase: camelBack readability-identifier-naming.ClassMemberCase: camelBack - readability-identifier-naming.ClassConstantCase: UPPER_CASE + readability-identifier-naming.ClassConstantCase: CamelCase readability-identifier-naming.ClassConstantPrefix: "k" - readability-identifier-naming.StaticConstantCase: UPPER_CASE + readability-identifier-naming.StaticConstantCase: CamelCase readability-identifier-naming.StaticConstantPrefix: "k" - readability-identifier-naming.StaticVariableCase: UPPER_CASE - readability-identifier-naming.StaticVariablePrefix: "k" - readability-identifier-naming.ConstexprVariableCase: UPPER_CASE - readability-identifier-naming.ConstexprVariablePrefix: "k" + readability-identifier-naming.StaticVariableCase: camelBack + readability-identifier-naming.ConstexprVariableCase: camelBack readability-identifier-naming.LocalConstantCase: camelBack readability-identifier-naming.LocalVariableCase: camelBack readability-identifier-naming.TemplateParameterCase: CamelCase readability-identifier-naming.ParameterCase: camelBack readability-identifier-naming.FunctionCase: camelBack readability-identifier-naming.MemberCase: camelBack + readability-identifier-naming.PrivateMemberCase: camelBack readability-identifier-naming.PrivateMemberSuffix: _ + readability-identifier-naming.ProtectedMemberCase: camelBack readability-identifier-naming.ProtectedMemberSuffix: _ + readability-identifier-naming.PublicMemberCase: camelBack 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/.github/scripts/levelization/generate.py b/.github/scripts/levelization/generate.py old mode 100644 new mode 100755 diff --git a/.github/scripts/rename/config.sh b/.github/scripts/rename/config.sh index a27d0823a9..81edcc73d6 100755 --- a/.github/scripts/rename/config.sh +++ b/.github/scripts/rename/config.sh @@ -62,7 +62,7 @@ ${SED_COMMAND} -i 's@ripple/@xrpld/@g' src/test/core/Config_test.cpp ${SED_COMMAND} -i 's/Rippled/File/g' src/test/core/Config_test.cpp # Restore the old config file name in the code that maintains support for now. -${SED_COMMAND} -i 's/kCONFIG_LEGACY_NAME = "xrpld.cfg"/kCONFIG_LEGACY_NAME = "rippled.cfg"/g' src/xrpld/core/detail/Config.cpp +${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/g' src/xrpld/core/detail/Config.cpp # Restore an URL. ${SED_COMMAND} -i 's/connect-your-xrpld-to-the-xrp-test-net.html/connect-your-rippled-to-the-xrp-test-net.html/g' cfg/xrpld-example.cfg diff --git a/.github/scripts/rename/docs.sh b/.github/scripts/rename/docs.sh index 23ff76bc05..8b7a362405 100755 --- a/.github/scripts/rename/docs.sh +++ b/.github/scripts/rename/docs.sh @@ -90,7 +90,7 @@ ${SED_COMMAND} -i 's/www.ripple.com/www.xrpl.org/g' src/test/protocol/Seed_test. # Restore specific changes. ${SED_COMMAND} -i 's@b5efcc/src/xrpld@b5efcc/src/ripple@' include/xrpl/protocol/README.md ${SED_COMMAND} -i 's/dbPrefix_ = "xrpldb"/dbPrefix_ = "rippledb"/' src/xrpld/app/misc/SHAMapStoreImp.h # cspell: disable-line -${SED_COMMAND} -i 's/kCONFIG_LEGACY_NAME = "xrpld.cfg"/kCONFIG_LEGACY_NAME = "rippled.cfg"/' src/xrpld/core/detail/Config.cpp +${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/' src/xrpld/core/detail/Config.cpp popd echo "Renaming complete." diff --git a/.github/scripts/strategy-matrix/generate.py b/.github/scripts/strategy-matrix/generate.py index dec41a2610..6eccfcc6be 100755 --- a/.github/scripts/strategy-matrix/generate.py +++ b/.github/scripts/strategy-matrix/generate.py @@ -32,7 +32,32 @@ We will further set additional CMake arguments as follows: """ -def generate_strategy_matrix(all: bool, config: Config) -> list: +def build_config_name(os_entry: dict[str, str], platform: str, build_type: str) -> str: + parts = [os_entry["distro_name"]] + for key in ("distro_version", "compiler_name", "compiler_version"): + if value := os_entry[key]: + parts.append(value) + parts.append("arm64" if "arm64" in platform else "amd64") + parts.append(build_type.lower()) + return "-".join(parts) + + +def generate_packaging_matrix(config: Config) -> list[dict]: + """Emit one entry per os entry with `package: true`. Architecture is + hardcoded to linux/amd64 here (and the runner is hardcoded at the + workflow level) until arm64 packaging is ready. + """ + return [ + { + "artifact_name": f"xrpld-{build_config_name(os, 'linux/amd64', 'Release')}", + "os": os, + } + for os in config.os + if os.get("package", False) + ] + + +def generate_strategy_matrix(all: bool, config: Config) -> list[dict]: configurations = [] for architecture, os, build_type, cmake_args in itertools.product( config.architecture, config.os, config.build_type, config.cmake_args @@ -72,7 +97,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 +115,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" ): @@ -100,14 +126,15 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: continue # RHEL: - # - 9 using GCC 12: Debug on linux/amd64. + # - 9 using GCC 12: Debug and Release on linux/amd64 + # (Release is required for RPM packaging). # - 10 using Clang: Release on linux/amd64. if os["distro_name"] == "rhel": skip = True if os["distro_version"] == "9": if ( f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12" - and build_type == "Debug" + and build_type in ["Debug", "Release"] and architecture["platform"] == "linux/amd64" ): skip = False @@ -122,7 +149,8 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: continue # Ubuntu: - # - Jammy using GCC 12: Debug on linux/arm64. + # - Jammy using GCC 12: Debug on linux/arm64, Release on + # linux/amd64 (Release is required for DEB packaging). # - Noble using GCC 14: Release on linux/amd64. # - Noble using Clang 18: Debug on linux/amd64. # - Noble using Clang 19: Release on linux/arm64. @@ -135,6 +163,12 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: and architecture["platform"] == "linux/arm64" ): skip = False + if ( + f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12" + and build_type == "Release" + and architecture["platform"] == "linux/amd64" + ): + skip = False elif os["distro_version"] == "noble": if ( f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-14" @@ -188,8 +222,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 @@ -216,17 +251,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: # Generate a unique name for the configuration, e.g. macos-arm64-debug # or debian-bookworm-gcc-12-amd64-release. - config_name = os["distro_name"] - if (n := os["distro_version"]) != "": - config_name += f"-{n}" - if (n := os["compiler_name"]) != "": - config_name += f"-{n}" - if (n := os["compiler_version"]) != "": - config_name += f"-{n}" - config_name += ( - f"-{architecture['platform'][architecture['platform'].find('/')+1:]}" - ) - config_name += f"-{build_type.lower()}" + config_name = build_config_name(os, architecture["platform"], build_type) if "-Dcoverage=ON" in cmake_args: config_name += "-coverage" if "-Dunity=ON" in cmake_args: @@ -238,13 +263,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 +283,6 @@ def generate_strategy_matrix(all: bool, config: Config) -> list: "sanitizers": "address", } ) - # Add UBSAN configuration. configurations.append( { "config_name": config_name + "-ubsan", @@ -330,10 +355,19 @@ if __name__ == "__main__": required=False, type=Path, ) + parser.add_argument( + "-p", + "--packaging", + help="Emit the packaging matrix (derived from the 'package' field on os entries) instead of the build/test matrix.", + action="store_true", + ) args = parser.parse_args() matrix = [] - if args.config is None or args.config == "": + if args.packaging: + config_path = args.config if args.config else THIS_DIR / "linux.json" + matrix += generate_packaging_matrix(read_config(config_path)) + elif args.config is None or args.config == "": matrix += generate_strategy_matrix( args.all, read_config(THIS_DIR / "linux.json") ) diff --git a/.github/scripts/strategy-matrix/linux.json b/.github/scripts/strategy-matrix/linux.json index 4943579be8..4f090a81a3 100644 --- a/.github/scripts/strategy-matrix/linux.json +++ b/.github/scripts/strategy-matrix/linux.json @@ -15,196 +15,205 @@ "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", + "package": true }, { "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", + "package": true }, { "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 d95f3a6c00..ca715e0376 100644 --- a/.github/workflows/on-pr.yml +++ b/.github/workflows/on-pr.yml @@ -64,11 +64,13 @@ jobs: .github/workflows/reusable-build-test-config.yml .github/workflows/reusable-build-test.yml .github/workflows/reusable-clang-tidy.yml + .github/workflows/reusable-package.yml .github/workflows/reusable-strategy-matrix.yml .github/workflows/reusable-test.yml .github/workflows/reusable-upload-recipe.yml .clang-tidy .codecov.yml + cfg/** cmake/** conan/** external/** @@ -78,6 +80,10 @@ jobs: CMakeLists.txt conanfile.py conan.lock + LICENSE.md + package/** + README.md + - name: Check whether to run # This step determines whether the rest of the workflow should # run. The rest of the workflow will run if this job runs AND at @@ -134,6 +140,11 @@ jobs: secrets: CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + package: + needs: [should-run, build-test] + if: ${{ needs.should-run.outputs.go == 'true' }} + uses: ./.github/workflows/reusable-package.yml + upload-recipe: needs: - should-run @@ -168,6 +179,7 @@ jobs: - check-rename - clang-tidy - build-test + - package - upload-recipe - notify-clio runs-on: ubuntu-latest diff --git a/.github/workflows/on-tag.yml b/.github/workflows/on-tag.yml index e570a0e119..b7517ccf11 100644 --- a/.github/workflows/on-tag.yml +++ b/.github/workflows/on-tag.yml @@ -1,5 +1,5 @@ -# This workflow uploads the libxrpl recipe to the Conan remote when a versioned -# tag is pushed. +# This workflow uploads the libxrpl recipe to the Conan remote and builds +# release packages when a versioned tag is pushed. name: Tag on: @@ -22,3 +22,22 @@ jobs: secrets: remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }} remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }} + + build-test: + if: ${{ github.repository == 'XRPLF/rippled' }} + uses: ./.github/workflows/reusable-build-test.yml + strategy: + fail-fast: true + matrix: + os: [linux] + with: + ccache_enabled: false + os: ${{ matrix.os }} + strategy_matrix: minimal + secrets: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + + package: + if: ${{ github.repository == 'XRPLF/rippled' }} + needs: build-test + uses: ./.github/workflows/reusable-package.yml diff --git a/.github/workflows/on-trigger.yml b/.github/workflows/on-trigger.yml index 11d98bffb7..803ba3c87b 100644 --- a/.github/workflows/on-trigger.yml +++ b/.github/workflows/on-trigger.yml @@ -21,11 +21,13 @@ on: - ".github/workflows/reusable-build-test-config.yml" - ".github/workflows/reusable-build-test.yml" - ".github/workflows/reusable-clang-tidy.yml" + - ".github/workflows/reusable-package.yml" - ".github/workflows/reusable-strategy-matrix.yml" - ".github/workflows/reusable-test.yml" - ".github/workflows/reusable-upload-recipe.yml" - ".clang-tidy" - ".codecov.yml" + - "cfg/**" - "cmake/**" - "conan/**" - "external/**" @@ -35,6 +37,9 @@ on: - "CMakeLists.txt" - "conanfile.py" - "conan.lock" + - "LICENSE.md" + - "package/**" + - "README.md" # Run at 06:32 UTC on every day of the week from Monday through Friday. This # will force all dependencies to be rebuilt, which is useful to verify that @@ -95,3 +100,7 @@ jobs: secrets: remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }} remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }} + + package: + needs: build-test + uses: ./.github/workflows/reusable-package.yml diff --git a/.github/workflows/reusable-build-test-config.yml b/.github/workflows/reusable-build-test-config.yml index ae998faebd..cc927512ea 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 \ @@ -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.yml b/.github/workflows/reusable-clang-tidy.yml index a678fe4c8e..e01a50cf6d 100644 --- a/.github/workflows/reusable-clang-tidy.yml +++ b/.github/workflows/reusable-clang-tidy.yml @@ -29,7 +29,7 @@ jobs: if: ${{ inputs.check_only_changed }} permissions: contents: read - uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@12f5dbc98a2260259a66970e57fa4d26fb7f285c + uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@224f3c48d3014d082a1129237b8291ff0b0a331f run-clang-tidy: name: Run clang tidy @@ -39,6 +39,7 @@ jobs: 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 @@ -92,6 +93,11 @@ jobs: 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 @@ -100,13 +106,24 @@ jobs: 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.run_clang_tidy.outcome != 'success' }} + 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.run_clang_tidy.outcome != 'success' }} + if: ${{ github.event.repository.visibility == 'public' && steps.files_changed.outcome != 'success' }} uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: path: ${{ env.DIFF_FILE }} @@ -116,24 +133,16 @@ jobs: - name: Write issue header if: ${{ steps.run_clang_tidy.outcome != 'success' }} run: | - # Prepare issue body with clang-tidy output cat > "${ISSUE_FILE}" < filtered-output.txt || true @@ -161,53 +170,21 @@ jobs: cat >> "${ISSUE_FILE}" < create_issue.log - - - name: Output created issue number - run: | - created_issue="$(sed 's|.*/||' create_issue.log)" - echo "created_issue=$created_issue" >> $GITHUB_OUTPUT - echo "Created issue #$created_issue" diff --git a/.github/workflows/reusable-package.yml b/.github/workflows/reusable-package.yml new file mode 100644 index 0000000000..5108a55cd2 --- /dev/null +++ b/.github/workflows/reusable-package.yml @@ -0,0 +1,99 @@ +# Build Linux packages (DEB and RPM) from pre-built binary artifacts. +# Discovers which configurations to package from linux.json (os entries +# with "package": true) and fans out one job per entry. Today only +# linux/amd64 is emitted; the architecture is hardcoded both here +# (runner) and in generate.py. +name: Package + +on: + workflow_call: + inputs: + pkg_release: + description: "Package release number. Increment when repackaging the same executable." + required: false + type: string + default: "1" + +defaults: + run: + shell: bash + +env: + BUILD_DIR: build + +jobs: + generate-matrix: + runs-on: ubuntu-latest + outputs: + matrix: ${{ steps.generate.outputs.matrix }} + steps: + - name: Checkout repository + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - name: Set up Python + uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0 + with: + python-version: 3.13 + + - name: Generate packaging matrix + id: generate + working-directory: .github/scripts/strategy-matrix + run: | + ./generate.py --packaging --config=linux.json >> "${GITHUB_OUTPUT}" + + generate-version: + runs-on: ubuntu-latest + outputs: + version: ${{ steps.version.outputs.version }} + steps: + - name: Checkout repository + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + sparse-checkout: | + .github/actions/generate-version + src/libxrpl/protocol/BuildInfo.cpp + - name: Generate version + id: version + uses: ./.github/actions/generate-version + + package: + needs: [generate-matrix, generate-version] + if: ${{ github.event.repository.visibility == 'public' }} + strategy: + fail-fast: false + matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }} + name: "${{ matrix.artifact_name }}" + permissions: + contents: read + runs-on: ["self-hosted", "Linux", "X64", "heavy"] + container: ${{ format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-{4}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version, matrix.os.image_sha) }} + timeout-minutes: 30 + + steps: + - name: Checkout repository + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - name: Download pre-built binary + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: ${{ matrix.artifact_name }} + path: ${{ env.BUILD_DIR }} + + - name: Make binary executable + run: chmod +x "${BUILD_DIR}/xrpld" + + - name: Build package + env: + PKG_VERSION: ${{ needs.generate-version.outputs.version }} + PKG_RELEASE: ${{ inputs.pkg_release }} + run: ./package/build_pkg.sh + + - name: Upload package artifact + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: ${{ matrix.artifact_name }}-pkg-${{ needs.generate-version.outputs.version }} + path: | + ${{ env.BUILD_DIR }}/debbuild/*.deb + ${{ env.BUILD_DIR }}/debbuild/*.ddeb + ${{ env.BUILD_DIR }}/rpmbuild/RPMS/**/*.rpm + if-no-files-found: error diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 1c0dc94550..1313ad567c 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -70,7 +70,11 @@ repos: rev: a42085ade523f591dca134379a595e7859986445 # frozen: v9.7.0 hooks: - id: cspell # Spell check changed files - exclude: (.config/cspell.config.yaml|^include/xrpl/protocol_autogen/(transactions|ledger_entries)/) + exclude: | + (?x)^( + .config/cspell.config.yaml| + include/xrpl/protocol_autogen/(transactions|ledger_entries)/.* + )$ - id: cspell # Spell check the commit message name: check commit message spelling args: diff --git a/BUILD.md b/BUILD.md index cf0a685abd..a1163dbfcc 100644 --- a/BUILD.md +++ b/BUILD.md @@ -141,7 +141,7 @@ Alternatively, you can pull our recipes from the repository and export them loca ```bash # Define which recipes to export. -recipes=('abseil' 'ed25519' 'grpc' 'm4' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi') +recipes=('abseil' 'ed25519' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi') # Selectively check out the recipes from our CCI fork. cd external @@ -427,16 +427,19 @@ install ccache --version 4.11.3 --allow-downgrade`. Single-config generators: ``` - cmake --build . + cmake --build . --parallel N ``` Multi-config generators: ``` - cmake --build . --config Release - cmake --build . --config Debug + cmake --build . --config Release --parallel N + cmake --build . --config Debug --parallel N ``` + Replace the `--parallel` parameter N with the desired number of parallel jobs. A common starting point is half of the number of available CPU + cores. + 5. Test xrpld. Single-config generators: @@ -530,16 +533,16 @@ stored inside the build directory, as either of: ## Sanitizers To build dependencies and xrpld with sanitizer instrumentation, set the -`SANITIZERS` environment variable (only once before running conan and cmake) and use the `sanitizers` profile in conan: +`SANITIZERS` environment variable when running `conan install` and use the `sanitizers` profile: ```bash export SANITIZERS=address,undefinedbehavior conan install .. --output-folder . --profile:all sanitizers --build missing --settings build_type=Debug - -cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Debug -Dxrpld=ON -Dtests=ON .. ``` +You can then build and test as usual, with the generated `xrpld` binary containing the sanitizer instrumentation. When you run it, it will report any sanitizer errors it detects in the console output. + See [Sanitizers docs](./docs/build/sanitizers.md) for more details. ## Options diff --git a/CMakeLists.txt b/CMakeLists.txt index 80ff8fec13..d315a5dcec 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -134,6 +134,7 @@ endif() include(XrplCore) include(XrplProtocolAutogen) include(XrplInstall) +include(XrplPackaging) include(XrplValidatorKeys) if(tests) diff --git a/bin/pre-commit/clang_tidy_check.py b/bin/pre-commit/clang_tidy_check.py index 7fb51d1c46..f134660671 100755 --- a/bin/pre-commit/clang_tidy_check.py +++ b/bin/pre-commit/clang_tidy_check.py @@ -168,7 +168,13 @@ def main(): if not os.environ.get("TIDY"): return 0 - repo_root = Path(__file__).parent.parent + repo_root = Path( + subprocess.check_output( + ["git", "rev-parse", "--show-toplevel"], + cwd=Path(__file__).parent, + text=True, + ).strip() + ) files = staged_files(repo_root) if not files: return 0 diff --git a/cfg/validators-example.txt b/cfg/validators-example.txt index 384db924f4..d690a67501 100644 --- a/cfg/validators-example.txt +++ b/cfg/validators-example.txt @@ -28,7 +28,7 @@ # https://vl.ripple.com # https://unl.xrplf.org # http://127.0.0.1:8000 -# file:///etc/opt/xrpld/vl.txt +# file:///etc/xrpld/vl.txt # # [validator_list_keys] # diff --git a/cfg/xrpld-example.cfg b/cfg/xrpld-example.cfg index 4b17bf0500..effc62c274 100644 --- a/cfg/xrpld-example.cfg +++ b/cfg/xrpld-example.cfg @@ -527,6 +527,17 @@ # # The current default (which is subject to change) is 300 seconds. # +# verify_endpoints = <0 | 1> +# +# 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 # #------------------------------------------------------------------------------- # @@ -1455,10 +1466,7 @@ admin = 127.0.0.1 protocol = http [port_peer] -# Many servers still use the legacy port of 51235, so for backward-compatibility -# we maintain that port number here. However, for new servers we recommend -# changing this to the default port of 2459. -port = 51235 +port = 2459 ip = 0.0.0.0 # alternatively, to accept connections on IPv4 + IPv6, use: #ip = :: diff --git a/cmake/XrplPackaging.cmake b/cmake/XrplPackaging.cmake new file mode 100644 index 0000000000..fe885c200c --- /dev/null +++ b/cmake/XrplPackaging.cmake @@ -0,0 +1,44 @@ +#[===================================================================[ + Linux packaging support: 'package' target. + + The packaging script (package/build_pkg.sh) installs to FHS-standard + paths (/usr/bin, /etc/xrpld, etc.) regardless of CMAKE_INSTALL_PREFIX, + so no prefix guard is needed here. +#]===================================================================] +if(NOT is_linux) + message(STATUS "Packaging not supported on non-Linux hosts") + return() +endif() + +if(NOT DEFINED pkg_release) + set(pkg_release 1) +endif() + +find_program(RPMBUILD_EXECUTABLE rpmbuild) +find_program(DPKG_BUILDPACKAGE_EXECUTABLE dpkg-buildpackage) + +if(NOT (RPMBUILD_EXECUTABLE OR DPKG_BUILDPACKAGE_EXECUTABLE)) + message( + STATUS + "Neither rpmbuild nor dpkg-buildpackage found; 'package' target not available" + ) + return() +endif() + +set(package_env + SRC_DIR=${CMAKE_SOURCE_DIR} + BUILD_DIR=${CMAKE_BINARY_DIR} + PKG_VERSION=${xrpld_version} + PKG_RELEASE=${pkg_release} +) + +add_custom_target( + package + COMMAND + ${CMAKE_COMMAND} -E env ${package_env} + ${CMAKE_SOURCE_DIR}/package/build_pkg.sh + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + DEPENDS xrpld + COMMENT "Building Linux package (deb/rpm inferred from host tooling)" + VERBATIM +) 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 5aaeeae5e3..275df41f58 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 @@ -97,12 +99,15 @@ words: - desync - desynced - determ + - disablerepo - distro - doxyfile - dxrpl - enabled + - enablerepo - endmacro - exceptioned + - EXPECT_STREQ - Falco - fcontext - finalizers @@ -114,6 +119,7 @@ words: - gcovr - ghead - Gnutella + - godexsoft - gpgcheck - gpgkey - hotwallet @@ -159,6 +165,7 @@ words: - Merkle - Metafuncton - misprediction + - missingok - mptbalance - MPTDEX - mptflags @@ -190,7 +197,9 @@ words: - NOLINT - NOLINTNEXTLINE - nonxrp + - noreplace - noripple + - notifempty - nudb - nullptr - nunl @@ -210,6 +219,7 @@ words: - preauthorize - preauthorizes - preclaim + - preun - protobuf - protos - ptrs @@ -244,12 +254,14 @@ words: - sfields - shamap - shamapitem + - shlibs - sidechain - SIGGOOD - sle - sles - soci - socidb + - SRPMS - sslws - statsd - STATSDCOLLECTOR @@ -277,8 +289,8 @@ words: - txn - txns - txs - - UBSAN - ubsan + - UBSAN - umant - unacquired - unambiguity @@ -315,7 +327,6 @@ words: - xbridge - xchain - ximinez - - EXPECT_STREQ - XMACRO - xrpkuwait - xrpl @@ -323,3 +334,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/IntrusivePointer.h b/include/xrpl/basics/IntrusivePointer.h index 06ee3e5bb4..d66c340d3f 100644 --- a/include/xrpl/basics/IntrusivePointer.h +++ b/include/xrpl/basics/IntrusivePointer.h @@ -406,8 +406,8 @@ private: // pointer. The low bit must be masked to zero when converting back to a // pointer. If the low bit is '1', this is a weak pointer. std::uintptr_t tp_{0}; - static constexpr std::uintptr_t kTAG_MASK = 1; - static constexpr std::uintptr_t kPTR_MASK = ~kTAG_MASK; + static constexpr std::uintptr_t kTagMask = 1; + static constexpr std::uintptr_t kPtrMask = ~kTagMask; private: /** Return the raw pointer held by this object. diff --git a/include/xrpl/basics/IntrusivePointer.ipp b/include/xrpl/basics/IntrusivePointer.ipp index f229df8b27..8344a3e613 100644 --- a/include/xrpl/basics/IntrusivePointer.ipp +++ b/include/xrpl/basics/IntrusivePointer.ipp @@ -567,14 +567,14 @@ template bool SharedWeakUnion::isStrong() const { - return (tp_ & kTAG_MASK) == 0u; + return (tp_ & kTagMask) == 0u; } template bool SharedWeakUnion::isWeak() const { - return (tp_ & kTAG_MASK) != 0u; + return (tp_ & kTagMask) != 0u; } template @@ -641,7 +641,7 @@ template T* SharedWeakUnion::unsafeGetRawPtr() const { - return reinterpret_cast(tp_ & kPTR_MASK); + return reinterpret_cast(tp_ & kPtrMask); } template @@ -650,7 +650,7 @@ SharedWeakUnion::unsafeSetRawPtr(T* p, RefStrength rs) { tp_ = reinterpret_cast(p); if (tp_ && rs == RefStrength::Weak) - tp_ |= kTAG_MASK; + tp_ |= kTagMask; } template diff --git a/include/xrpl/basics/IntrusiveRefCounts.h b/include/xrpl/basics/IntrusiveRefCounts.h index f0689197d7..0b00f1d5b1 100644 --- a/include/xrpl/basics/IntrusiveRefCounts.h +++ b/include/xrpl/basics/IntrusiveRefCounts.h @@ -98,11 +98,11 @@ private: // enough for strong pointers and 14 bit counts are enough for weak // pointers. Use type aliases to make it easy to switch types. using CountType = std::uint16_t; - static constexpr size_t kSTRONG_COUNT_NUM_BITS = sizeof(CountType) * 8; - static constexpr size_t kWEAK_COUNT_NUM_BITS = kSTRONG_COUNT_NUM_BITS - 2; + static constexpr size_t kStrongCountNumBits = sizeof(CountType) * 8; + static constexpr size_t kWeakCountNumBits = kStrongCountNumBits - 2; using FieldType = std::uint32_t; - static constexpr size_t kFIELD_TYPE_BITS = sizeof(FieldType) * 8; - static constexpr FieldType kONE = 1; + static constexpr size_t kFieldTypeBits = sizeof(FieldType) * 8; + static constexpr FieldType kOne = 1; /** `refCounts` consists of four fields that are treated atomically: @@ -137,21 +137,21 @@ private: */ - mutable std::atomic refCounts_{kSTRONG_DELTA}; + mutable std::atomic refCounts_{kStrongDelta}; /** Amount to change the strong count when adding or releasing a reference Note: The strong count is stored in the low `StrongCountNumBits` bits of refCounts */ - static constexpr FieldType kSTRONG_DELTA = 1; + static constexpr FieldType kStrongDelta = 1; /** Amount to change the weak count when adding or releasing a reference Note: The weak count is stored in the high `WeakCountNumBits` bits of refCounts */ - static constexpr FieldType kWEAK_DELTA = (kONE << kSTRONG_COUNT_NUM_BITS); + static constexpr FieldType kWeakDelta = (kOne << kStrongCountNumBits); /** Flag that is set when the partialDestroy function has started running (or is about to start running). @@ -159,34 +159,33 @@ private: See description of the `refCounts` field for a fuller description of this field. */ - static constexpr FieldType kPARTIAL_DESTROY_STARTED_MASK = (kONE << (kFIELD_TYPE_BITS - 1)); + static constexpr FieldType kPartialDestroyStartedMask = (kOne << (kFieldTypeBits - 1)); /** Flag that is set when the partialDestroy function has finished running See description of the `refCounts` field for a fuller description of this field. */ - static constexpr FieldType kPARTIAL_DESTROY_FINISHED_MASK = (kONE << (kFIELD_TYPE_BITS - 2)); + static constexpr FieldType kPartialDestroyFinishedMask = (kOne << (kFieldTypeBits - 2)); /** Mask that will zero out all the `count` bits and leave the tag bits unchanged. */ - static constexpr FieldType kTAG_MASK = - kPARTIAL_DESTROY_STARTED_MASK | kPARTIAL_DESTROY_FINISHED_MASK; + static constexpr FieldType kTagMask = kPartialDestroyStartedMask | kPartialDestroyFinishedMask; /** Mask that will zero out the `tag` bits and leave the count bits unchanged. */ - static constexpr FieldType kVALUE_MASK = ~kTAG_MASK; + static constexpr FieldType kValueMask = ~kTagMask; /** Mask that will zero out everything except the strong count. */ - static constexpr FieldType kSTRONG_MASK = ((kONE << kSTRONG_COUNT_NUM_BITS) - 1) & kVALUE_MASK; + static constexpr FieldType kStrongMask = ((kOne << kStrongCountNumBits) - 1) & kValueMask; /** Mask that will zero out everything except the weak count. */ - static constexpr FieldType kWEAK_MASK = - (((kONE << kWEAK_COUNT_NUM_BITS) - 1) << kSTRONG_COUNT_NUM_BITS) & kVALUE_MASK; + static constexpr FieldType kWeakMask = + (((kOne << kWeakCountNumBits) - 1) << kStrongCountNumBits) & kValueMask; /** Unpack the count and tag fields from the packed atomic integer form. */ struct RefCountPair @@ -211,29 +210,29 @@ private: [[nodiscard]] FieldType combinedValue() const noexcept; - static constexpr CountType kMAX_STRONG_VALUE = - static_cast((kONE << kSTRONG_COUNT_NUM_BITS) - 1); - static constexpr CountType kMAX_WEAK_VALUE = - static_cast((kONE << kWEAK_COUNT_NUM_BITS) - 1); + static constexpr CountType kMaxStrongValue = + static_cast((kOne << kStrongCountNumBits) - 1); + static constexpr CountType kMaxWeakValue = + static_cast((kOne << kWeakCountNumBits) - 1); /** Put an extra margin to detect when running up against limits. This is only used in debug code, and is useful if we reduce the number of bits in the strong and weak counts (to 16 and 14 bits). */ - static constexpr CountType kCHECK_STRONG_MAX_VALUE = kMAX_STRONG_VALUE - 32; - static constexpr CountType kCHECK_WEAK_MAX_VALUE = kMAX_WEAK_VALUE - 32; + static constexpr CountType kCheckStrongMaxValue = kMaxStrongValue - 32; + static constexpr CountType kCheckWeakMaxValue = kMaxWeakValue - 32; }; }; inline void IntrusiveRefCounts::addStrongRef() const noexcept { - refCounts_.fetch_add(kSTRONG_DELTA, std::memory_order_acq_rel); + refCounts_.fetch_add(kStrongDelta, std::memory_order_acq_rel); } inline void IntrusiveRefCounts::addWeakRef() const noexcept { - refCounts_.fetch_add(kWEAK_DELTA, std::memory_order_acq_rel); + refCounts_.fetch_add(kWeakDelta, std::memory_order_acq_rel); } inline ReleaseStrongRefAction @@ -252,10 +251,10 @@ IntrusiveRefCounts::releaseStrongRef() const { RefCountPair const prevVal{prevIntVal}; XRPL_ASSERT( - (prevVal.strong >= kSTRONG_DELTA), + (prevVal.strong >= kStrongDelta), "xrpl::IntrusiveRefCounts::releaseStrongRef : previous ref " "higher than new"); - auto nextIntVal = prevIntVal - kSTRONG_DELTA; + auto nextIntVal = prevIntVal - kStrongDelta; ReleaseStrongRefAction action = NoOp; if (prevVal.strong == 1) { @@ -265,7 +264,7 @@ IntrusiveRefCounts::releaseStrongRef() const } else { - nextIntVal |= kPARTIAL_DESTROY_STARTED_MASK; + nextIntVal |= kPartialDestroyStartedMask; action = PartialDestroy; } } @@ -276,7 +275,7 @@ IntrusiveRefCounts::releaseStrongRef() const // count to zero can start a partial destroy, and that can't happen // twice. XRPL_ASSERT( - (action == NoOp) || !(prevIntVal & kPARTIAL_DESTROY_STARTED_MASK), + (action == NoOp) || !(prevIntVal & kPartialDestroyStartedMask), "xrpl::IntrusiveRefCounts::releaseStrongRef : not in partial " "destroy"); return action; @@ -289,8 +288,8 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const { using enum ReleaseStrongRefAction; - static_assert(kWEAK_DELTA > kSTRONG_DELTA); - auto constexpr kDELTA = kWEAK_DELTA - kSTRONG_DELTA; + static_assert(kWeakDelta > kStrongDelta); + static constexpr auto kDelta = kWeakDelta - kStrongDelta; auto prevIntVal = refCounts_.load(std::memory_order_acquire); // This loop will almost always run once. The loop is needed to atomically // change the counts and flags (the count could be atomically changed, but @@ -312,7 +311,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const "xrpl::IntrusiveRefCounts::addWeakReleaseStrongRef : not in " "partial destroy"); - auto nextIntVal = prevIntVal + kDELTA; + auto nextIntVal = prevIntVal + kDelta; ReleaseStrongRefAction action = NoOp; if (prevVal.strong == 1) { @@ -322,14 +321,14 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const } else { - nextIntVal |= kPARTIAL_DESTROY_STARTED_MASK; + nextIntVal |= kPartialDestroyStartedMask; action = PartialDestroy; } } if (refCounts_.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel)) { XRPL_ASSERT( - (!(prevIntVal & kPARTIAL_DESTROY_STARTED_MASK)), + (!(prevIntVal & kPartialDestroyStartedMask)), "xrpl::IntrusiveRefCounts::addWeakReleaseStrongRef : not " "started partial destroy"); return action; @@ -340,7 +339,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const inline ReleaseWeakRefAction IntrusiveRefCounts::releaseWeakRef() const { - auto prevIntVal = refCounts_.fetch_sub(kWEAK_DELTA, std::memory_order_acq_rel); + auto prevIntVal = refCounts_.fetch_sub(kWeakDelta, std::memory_order_acq_rel); RefCountPair prev = prevIntVal; if (prev.weak == 1 && prev.strong == 0) { @@ -357,7 +356,7 @@ IntrusiveRefCounts::releaseWeakRef() const { // partial destroy MUST finish before running a full destroy (when // using weak pointers) - refCounts_.wait(prevIntVal - kWEAK_DELTA, std::memory_order_acquire); + refCounts_.wait(prevIntVal - kWeakDelta, std::memory_order_acquire); } return ReleaseWeakRefAction::Destroy; } @@ -376,7 +375,7 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept if (prev.strong == 0u) return false; - desiredValue = curValue + kSTRONG_DELTA; + desiredValue = curValue + kStrongDelta; } return true; } @@ -400,23 +399,22 @@ inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept #ifndef NDEBUG auto v = refCounts_.load(std::memory_order_acquire); XRPL_ASSERT( - (!(v & kVALUE_MASK)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero"); - auto t = v & kTAG_MASK; - XRPL_ASSERT( - (!t || t == kTAG_MASK), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag"); + (!(v & kValueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero"); + auto t = v & kTagMask; + XRPL_ASSERT((!t || t == kTagMask), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag"); #endif } //------------------------------------------------------------------------------ inline IntrusiveRefCounts::RefCountPair::RefCountPair(IntrusiveRefCounts::FieldType v) noexcept - : strong{static_cast(v & kSTRONG_MASK)} - , weak{static_cast((v & kWEAK_MASK) >> kSTRONG_COUNT_NUM_BITS)} - , partialDestroyStartedBit{v & kPARTIAL_DESTROY_STARTED_MASK} - , partialDestroyFinishedBit{v & kPARTIAL_DESTROY_FINISHED_MASK} + : strong{static_cast(v & kStrongMask)} + , weak{static_cast((v & kWeakMask) >> kStrongCountNumBits)} + , partialDestroyStartedBit{v & kPartialDestroyStartedMask} + , partialDestroyFinishedBit{v & kPartialDestroyFinishedMask} { XRPL_ASSERT( - (strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE), + (strong < kCheckStrongMaxValue && weak < kCheckWeakMaxValue), "xrpl::IntrusiveRefCounts::RefCountPair(FieldType) : inputs inside " "range"); } @@ -427,7 +425,7 @@ inline IntrusiveRefCounts::RefCountPair::RefCountPair( : strong{s}, weak{w} { XRPL_ASSERT( - (strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE), + (strong < kCheckStrongMaxValue && weak < kCheckWeakMaxValue), "xrpl::IntrusiveRefCounts::RefCountPair(CountType, CountType) : " "inputs inside range"); } @@ -436,11 +434,11 @@ inline IntrusiveRefCounts::FieldType IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept { XRPL_ASSERT( - (strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE), + (strong < kCheckStrongMaxValue && weak < kCheckWeakMaxValue), "xrpl::IntrusiveRefCounts::RefCountPair::combinedValue : inputs " "inside range"); return (static_cast(weak) - << IntrusiveRefCounts::kSTRONG_COUNT_NUM_BITS) | + << IntrusiveRefCounts::kStrongCountNumBits) | static_cast(strong) | partialDestroyStartedBit | partialDestroyFinishedBit; } @@ -451,7 +449,7 @@ partialDestructorFinished(T** o) { T& self = **o; IntrusiveRefCounts::RefCountPair const p = - self.refCounts_.fetch_or(IntrusiveRefCounts::kPARTIAL_DESTROY_FINISHED_MASK); + self.refCounts_.fetch_or(IntrusiveRefCounts::kPartialDestroyFinishedMask); XRPL_ASSERT( (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong), "xrpl::partialDestructorFinished : not a weak ref"); diff --git a/include/xrpl/basics/LocalValue.h b/include/xrpl/basics/LocalValue.h index f39df425a6..1c2a657a18 100644 --- a/include/xrpl/basics/LocalValue.h +++ b/include/xrpl/basics/LocalValue.h @@ -55,8 +55,8 @@ template boost::thread_specific_ptr& getLocalValues() { - static boost::thread_specific_ptr kTSP(&detail::LocalValues::cleanup); - return kTSP; + static boost::thread_specific_ptr kTsp(&detail::LocalValues::cleanup); + return kTsp; } } // namespace detail diff --git a/include/xrpl/basics/Log.h b/include/xrpl/basics/Log.h index 8e6532f7c0..6bafbc7c54 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 kMaximumMessageCharacters = 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/Number.h b/include/xrpl/basics/Number.h index cdb9014a87..e67f1f534d 100644 --- a/include/xrpl/basics/Number.h +++ b/include/xrpl/basics/Number.h @@ -214,12 +214,12 @@ class Number public: // The range for the exponent when normalized - constexpr static int kMIN_EXPONENT = -32768; - constexpr static int kMAX_EXPONENT = 32768; + static constexpr int kMinExponent = -32768; + static constexpr int kMaxExponent = 32768; - constexpr static internalrep kMAX_REP = std::numeric_limits::max(); - static_assert(kMAX_REP == 9'223'372'036'854'775'807); - static_assert(-kMAX_REP == std::numeric_limits::min() + 1); + static constexpr internalrep kMaxRep = std::numeric_limits::max(); + static_assert(kMaxRep == 9'223'372'036'854'775'807); + static_assert(-kMaxRep == std::numeric_limits::min() + 1); // May need to make unchecked private struct Unchecked @@ -409,26 +409,26 @@ public: static internalrep minMantissa() { - return kRANGE.get().min; + return kRange.get().min; } static internalrep maxMantissa() { - return kRANGE.get().max; + return kRange.get().max; } static int mantissaLog() { - return kRANGE.get().log; + return kRange.get().log; } /// oneSmall is needed because the ranges are private - constexpr static Number + static constexpr Number oneSmall(); /// oneLarge is needed because the ranges are private - constexpr static Number + static constexpr Number oneLarge(); // And one is needed because it needs to choose between oneSmall and @@ -445,25 +445,25 @@ private: static thread_local RoundingMode mode; // The available ranges for mantissa - constexpr static MantissaRange kSMALL_RANGE{MantissaRange::MantissaScale::Small}; - static_assert(isPowerOfTen(kSMALL_RANGE.min)); - static_assert(kSMALL_RANGE.min == 1'000'000'000'000'000LL); - static_assert(kSMALL_RANGE.max == 9'999'999'999'999'999LL); - static_assert(kSMALL_RANGE.log == 15); - static_assert(kSMALL_RANGE.min < kMAX_REP); - static_assert(kSMALL_RANGE.max < kMAX_REP); - constexpr static MantissaRange kLARGE_RANGE{MantissaRange::MantissaScale::Large}; - static_assert(isPowerOfTen(kLARGE_RANGE.min)); - static_assert(kLARGE_RANGE.min == 1'000'000'000'000'000'000ULL); - static_assert(kLARGE_RANGE.max == internalrep(9'999'999'999'999'999'999ULL)); - static_assert(kLARGE_RANGE.log == 18); - static_assert(kLARGE_RANGE.min < kMAX_REP); - static_assert(kLARGE_RANGE.max > kMAX_REP); + static constexpr MantissaRange kSmallRange{MantissaRange::MantissaScale::Small}; + static_assert(isPowerOfTen(kSmallRange.min)); + static_assert(kSmallRange.min == 1'000'000'000'000'000LL); + static_assert(kSmallRange.max == 9'999'999'999'999'999LL); + static_assert(kSmallRange.log == 15); + static_assert(kSmallRange.min < kMaxRep); + static_assert(kSmallRange.max < kMaxRep); + static constexpr MantissaRange kLargeRange{MantissaRange::MantissaScale::Large}; + static_assert(isPowerOfTen(kLargeRange.min)); + static_assert(kLargeRange.min == 1'000'000'000'000'000'000ULL); + static_assert(kLargeRange.max == internalrep(9'999'999'999'999'999'999ULL)); + static_assert(kLargeRange.log == 18); + static_assert(kLargeRange.min < kMaxRep); + static_assert(kLargeRange.max > kMaxRep); // The range for the mantissa when normalized. // Use reference_wrapper to avoid making copies, and prevent accidentally // changing the values inside the range. - static thread_local std::reference_wrapper kRANGE; + static thread_local std::reference_wrapper kRange; void normalize(); @@ -471,7 +471,7 @@ private: /** Normalize Number components to an arbitrary range. * * min/maxMantissa are parameters because this function is used by both - * normalize(), which reads from kRANGE, and by normalizeToRange, + * normalize(), which reads from kRange, and by normalizeToRange, * which is public and can accept an arbitrary range from the caller. */ template @@ -521,7 +521,7 @@ constexpr Number::Number(internalrep mantissa, int exponent, Unchecked) noexcept { } -constexpr static Number kNUM_ZERO{}; +static constexpr Number kNumZero{}; inline Number::Number(bool negative, internalrep mantissa, int exponent, Normalized) : Number(negative, mantissa, exponent, Unchecked{}) @@ -552,10 +552,10 @@ constexpr Number::rep Number::mantissa() const noexcept { auto m = mantissa_; - if (m > kMAX_REP) + if (m > kMaxRep) { XRPL_ASSERT_PARTS( - !isnormal() || (m % 10 == 0 && m / 10 <= kMAX_REP), + !isnormal() || (m % 10 == 0 && m / 10 <= kMaxRep), "xrpl::Number::mantissa", "large normalized mantissa has no remainder"); m /= 10; @@ -573,10 +573,10 @@ constexpr int Number::exponent() const noexcept { auto e = exponent_; - if (mantissa_ > kMAX_REP) + if (mantissa_ > kMaxRep) { XRPL_ASSERT_PARTS( - !isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= kMAX_REP), + !isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= kMaxRep), "xrpl::Number::exponent", "large normalized mantissa has no remainder"); ++e; @@ -671,29 +671,29 @@ operator/(Number const& x, Number const& y) inline Number Number::min() noexcept { - return Number{false, kRANGE.get().min, kMIN_EXPONENT, Unchecked{}}; + return Number{false, kRange.get().min, kMinExponent, Unchecked{}}; } inline Number Number::max() noexcept { - return Number{false, std::min(kRANGE.get().max, kMAX_REP), kMAX_EXPONENT, Unchecked{}}; + return Number{false, std::min(kRange.get().max, kMaxRep), kMaxExponent, Unchecked{}}; } inline Number Number::lowest() noexcept { - return Number{true, std::min(kRANGE.get().max, kMAX_REP), kMAX_EXPONENT, Unchecked{}}; + return Number{true, std::min(kRange.get().max, kMaxRep), kMaxExponent, Unchecked{}}; } inline bool Number::isnormal() const noexcept { - MantissaRange const& range = kRANGE; + MantissaRange const& range = kRange; auto const absM = mantissa_; return *this == Number{} || - (range.min <= absM && absM <= range.max && (absM <= kMAX_REP || absM % 10 == 0) && - kMIN_EXPONENT <= exponent_ && exponent_ <= kMAX_EXPONENT); + (range.min <= absM && absM <= range.max && (absM <= kMaxRep || absM % 10 == 0) && + kMinExponent <= exponent_ && exponent_ <= kMaxExponent); } template 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/SharedWeakCachePointer.ipp b/include/xrpl/basics/SharedWeakCachePointer.ipp index 2f8345e645..6228d09b6f 100644 --- a/include/xrpl/basics/SharedWeakCachePointer.ipp +++ b/include/xrpl/basics/SharedWeakCachePointer.ipp @@ -57,10 +57,10 @@ template std::shared_ptr const& SharedWeakCachePointer::getStrong() const { - static std::shared_ptr const kEMPTY; + static std::shared_ptr const kEmpty; if (auto p = std::get_if>(&combo_)) return *p; - return kEMPTY; + return kEmpty; } template diff --git a/include/xrpl/basics/StringUtilities.h b/include/xrpl/basics/StringUtilities.h index c9f26026be..28421626aa 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 kDigitLookupTable = []() { + 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 kDigitLookupTable[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/TaggedCache.h b/include/xrpl/basics/TaggedCache.h index 52b866cdad..fca9eabde2 100644 --- a/include/xrpl/basics/TaggedCache.h +++ b/include/xrpl/basics/TaggedCache.h @@ -181,14 +181,14 @@ private: beast::insight::Collector::ptr const& collector) : hook(collector->makeHook(handler)) , size(collector->makeGauge(prefix, "size")) - , hit_rate(collector->makeGauge(prefix, "hit_rate")) + , hitRate(collector->makeGauge(prefix, "hit_rate")) { } beast::insight::Hook hook; beast::insight::Gauge size; - beast::insight::Gauge hit_rate; + beast::insight::Gauge hitRate; std::size_t hits{0}; std::size_t misses{0}; @@ -197,16 +197,16 @@ private: class KeyOnlyEntry { public: - clock_type::time_point last_access; + clock_type::time_point lastAccess; - explicit KeyOnlyEntry(clock_type::time_point const& lastAccess) : last_access(lastAccess) + explicit KeyOnlyEntry(clock_type::time_point const& lastAccess) : lastAccess(lastAccess) { } void touch(clock_type::time_point const& now) { - last_access = now; + lastAccess = now; } }; @@ -214,10 +214,10 @@ private: { public: shared_weak_combo_pointer_type ptr; - clock_type::time_point last_access; + clock_type::time_point lastAccess; ValueEntry(clock_type::time_point const& lastAccess, shared_pointer_type const& ptr) - : ptr(ptr), last_access(lastAccess) + : ptr(ptr), lastAccess(lastAccess) { } @@ -246,7 +246,7 @@ private: void touch(clock_type::time_point const& now) { - last_access = now; + lastAccess = now; } }; @@ -286,13 +286,13 @@ private: std::string name_; // Desired number of cache entries (0 = ignore) - int const target_size_; + int const targetSize_; // Desired maximum cache age - clock_type::duration const target_age_; + clock_type::duration const targetAge_; // Number of items cached - int cache_count_{0}; + int cacheCount_{0}; cache_type cache_; // Hold strong reference to recent objects std::uint64_t hits_{0}; std::uint64_t misses_{0}; diff --git a/include/xrpl/basics/TaggedCache.ipp b/include/xrpl/basics/TaggedCache.ipp index 8ef9e16570..cee02749c6 100644 --- a/include/xrpl/basics/TaggedCache.ipp +++ b/include/xrpl/basics/TaggedCache.ipp @@ -34,8 +34,8 @@ inline TaggedCache< , clock_(clock) , stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector) , name_(name) - , target_size_(size) - , target_age_(expiration) + , targetSize_(size) + , targetAge_(expiration) { } @@ -86,7 +86,7 @@ TaggedCache(cache_.size()) <= target_size_)) + if (targetSize_ == 0 || (static_cast(cache_.size()) <= targetSize_)) { - whenExpire = now - target_age_; + whenExpire = now - targetAge_; } else { - whenExpire = now - (target_age_ * target_size_ / cache_.size()); + whenExpire = now - (targetAge_ * targetSize_ / cache_.size()); clock_type::duration const minimumAge(std::chrono::seconds(1)); if (whenExpire > (now - minimumAge)) whenExpire = now - minimumAge; JLOG(journal_.trace()) - << name_ << " is growing fast " << cache_.size() << " of " << target_size_ - << " aging at " << (now - whenExpire).count() << " of " << target_age_.count(); + << name_ << " is growing fast " << cache_.size() << " of " << targetSize_ + << " aging at " << (now - whenExpire).count() << " of " << targetAge_.count(); } std::vector workers; @@ -242,7 +242,7 @@ TaggedCachesecond.last_access = now; + it->second.lastAccess = now; return inserted; } @@ -626,7 +626,7 @@ TaggedCachesecond.last_access <= whenExpire) + else if (cit->second.lastAccess <= whenExpire) { // strong, expired ++cacheRemovals; @@ -773,12 +773,12 @@ TaggedCachesecond.last_access > now) + if (cit->second.lastAccess > now) { - cit->second.last_access = now; + cit->second.lastAccess = now; ++cit; } - else if (cit->second.last_access <= whenExpire) + else if (cit->second.lastAccess <= whenExpire) { cit = partition.erase(cit); } diff --git a/include/xrpl/basics/UptimeClock.h b/include/xrpl/basics/UptimeClock.h index bb7d4fd77a..502aae7c25 100644 --- a/include/xrpl/basics/UptimeClock.h +++ b/include/xrpl/basics/UptimeClock.h @@ -30,8 +30,8 @@ public: now(); // seconds since xrpld program start private: - static std::atomic kNOW; - static std::atomic kSTOP; + static std::atomic kNow; + static std::atomic kStop; struct UpdateThread : private std::thread { diff --git a/include/xrpl/basics/base_uint.h b/include/xrpl/basics/base_uint.h index 15fc4f6966..93a9ced15e 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,18 +67,18 @@ 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."); static_assert(Bits >= 64, "The length of a base_uint in bits must be at least 64."); - static constexpr std::size_t kWIDTH = Bits / 32; + static constexpr std::size_t kWidth = Bits / 32; // This is really big-endian in byte order. // We sometimes use std::uint32_t for speed. - std::array data_; + std::array data_; public: //-------------------------------------------------------------------------- @@ -81,8 +86,8 @@ public: // STL Container Interface // - static std::size_t constexpr kBYTES = Bits / 8; - static_assert(sizeof(data_) == kBYTES, ""); + static constexpr std::size_t kBytes = Bits / 8; + static_assert(sizeof(data_) == kBytes, ""); using size_type = std::size_t; using difference_type = std::ptrdiff_t; @@ -116,7 +121,7 @@ public: iterator end() { - return data() + kBYTES; + return data() + kBytes; } [[nodiscard]] const_iterator begin() const @@ -126,7 +131,7 @@ public: [[nodiscard]] const_iterator end() const { - return data() + kBYTES; + return data() + kBytes; } [[nodiscard]] const_iterator cbegin() const @@ -136,7 +141,7 @@ public: [[nodiscard]] const_iterator cend() const { - return data() + kBYTES; + return data() + kBytes; } /** Value hashing function. @@ -160,9 +165,9 @@ private: explicit VoidHelper() = default; }; - explicit BaseUint(void const* data, VoidHelper) + explicit BaseUInt(void const* data, VoidHelper) { - memcpy(data_.data(), data, kBYTES); + memcpy(data_.data(), data, kBytes); } // Helper function to initialize a base_uint from a std::string_view. @@ -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()) @@ -313,7 +336,7 @@ public: [[nodiscard]] constexpr int signum() const { - for (int i = 0; i < kWIDTH; i++) + for (int i = 0; i < kWidth; i++) { if (data_[i] != 0) return 1; @@ -325,24 +348,24 @@ public: bool operator!() const { - return *this == beast::kZERO; + return *this == beast::kZero; } - constexpr BaseUint + constexpr BaseUInt operator~() const { - BaseUint ret; + BaseUInt ret; - for (int i = 0; i < kWIDTH; i++) + for (int i = 0; i < kWidth; i++) ret.data_[i] = ~data_[i]; return ret; } - BaseUint& + BaseUInt& operator=(std::uint64_t uHost) { - *this = beast::kZERO; + *this = beast::kZero; // NOLINTBEGIN(cppcoreguidelines-pro-type-member-init) union { @@ -352,43 +375,43 @@ public: // NOLINTEND(cppcoreguidelines-pro-type-member-init) // Put in least significant bits. ul = boost::endian::native_to_big(uHost); - data_[kWIDTH - 2] = u[0]; - data_[kWIDTH - 1] = u[1]; + data_[kWidth - 2] = u[0]; + data_[kWidth - 1] = u[1]; return *this; } - BaseUint& - operator^=(BaseUint const& b) + BaseUInt& + operator^=(BaseUInt const& b) { - for (int i = 0; i < kWIDTH; i++) + for (int i = 0; i < kWidth; i++) data_[i] ^= b.data_[i]; return *this; } - BaseUint& - operator&=(BaseUint const& b) + BaseUInt& + operator&=(BaseUInt const& b) { - for (int i = 0; i < kWIDTH; i++) + for (int i = 0; i < kWidth; i++) data_[i] &= b.data_[i]; return *this; } - BaseUint& - operator|=(BaseUint const& b) + BaseUInt& + operator|=(BaseUInt const& b) { - for (int i = 0; i < kWIDTH; i++) + for (int i = 0; i < kWidth; i++) data_[i] |= b.data_[i]; return *this; } - BaseUint& + BaseUInt& operator++() { // prefix operator - for (int i = kWIDTH - 1; i >= 0; --i) + for (int i = kWidth - 1; i >= 0; --i) { data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) + 1); if (data_[i] != 0) @@ -398,20 +421,20 @@ 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) + for (int i = kWidth - 1; i >= 0; --i) { auto prev = data_[i]; data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) - 1); @@ -423,36 +446,36 @@ 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; - for (int i = kWIDTH - 1; i >= 0; i--) + for (int i = kWidth - 1; i >= 0; i--) { std::uint64_t const n = carry + boost::endian::big_to_native(data_[i]) + boost::endian::big_to_native(b.data_[i]); @@ -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_)); @@ -503,13 +526,13 @@ public: return parseHex(std::string_view{str}); } - constexpr static std::size_t + static constexpr std::size_t size() { - return kBYTES; + return kBytes; } - BaseUint& + BaseUInt& operator=(beast::Zero) { data_.fill(0); @@ -520,28 +543,28 @@ public: [[nodiscard]] bool isZero() const { - return *this == beast::kZERO; + return *this == beast::kZero; } [[nodiscard]] bool isNonZero() const { - return *this != beast::kZERO; + return *this != beast::kZero; } void zero() { - *this = beast::kZERO; + *this = beast::kZero; } }; -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/chrono.h b/include/xrpl/basics/chrono.h index 8b71be04b4..5d6de06248 100644 --- a/include/xrpl/basics/chrono.h +++ b/include/xrpl/basics/chrono.h @@ -30,10 +30,10 @@ using weeks = std::chrono::duration @@ -77,7 +77,7 @@ toStringIso(NetClock::time_point tp) // 2000-01-01 00:00:00 UTC is 946684800s from 1970-01-01 00:00:00 UTC // Note, NetClock::duration is seconds, as checked by static_assert static_assert(std::is_same_v>); - return toStringIso(date::sys_time{tp.time_since_epoch() + kEPOCH_OFFSET}); + return toStringIso(date::sys_time{tp.time_since_epoch() + kEpochOffset}); } /** A clock for measuring elapsed time. diff --git a/include/xrpl/basics/hardened_hash.h b/include/xrpl/basics/hardened_hash.h index 07f5aded4c..efc77e058b 100644 --- a/include/xrpl/basics/hardened_hash.h +++ b/include/xrpl/basics/hardened_hash.h @@ -31,9 +31,9 @@ makeSeedPair() noexcept // state_t(state_t const&) = delete; // state_t& operator=(state_t const&) = delete; }; - static StateT kSTATE; - std::scoped_lock const lock(kSTATE.mutex); - return {kSTATE.dist(kSTATE.gen), kSTATE.dist(kSTATE.gen)}; + static StateT kState; + std::scoped_lock const lock(kState.mutex); + return {kState.dist(kState.gen), kState.dist(kState.gen)}; } } // namespace detail diff --git a/include/xrpl/basics/mulDiv.h b/include/xrpl/basics/mulDiv.h index 8a9bc4f5dc..9076da62f2 100644 --- a/include/xrpl/basics/mulDiv.h +++ b/include/xrpl/basics/mulDiv.h @@ -5,7 +5,7 @@ #include namespace xrpl { -auto constexpr kMULDIV_MAX = std::numeric_limits::max(); +constexpr auto kMuldivMax = std::numeric_limits::max(); /** Return value*mul/div accurately. Computes the result of the multiplication and division in 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..17f4a1c213 100644 --- a/include/xrpl/basics/random.h +++ b/include/xrpl/basics/random.h @@ -47,7 +47,7 @@ inline beast::xor_shift_engine& defaultPrng() { // This is used to seed the thread-specific PRNGs on demand - static beast::xor_shift_engine kSEEDER = [] { + static beast::xor_shift_engine kSeeder = [] { std::random_device rng; std::uniform_int_distribution distribution{1}; return beast::xor_shift_engine(distribution(rng)); @@ -57,17 +57,17 @@ defaultPrng() static std::mutex kM; // The thread-specific PRNGs: - thread_local beast::xor_shift_engine kENGINE = [] { + thread_local beast::xor_shift_engine kEngine = [] { std::uint64_t seed = 0; { std::scoped_lock const lk(kM); std::uniform_int_distribution distribution{1}; - seed = distribution(kSEEDER); + seed = distribution(kSeeder); } return beast::xor_shift_engine{seed}; }(); - return kENGINE; + return kEngine; } /** Return a uniformly distributed random integer. @@ -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..f71edc47ad 100644 --- a/include/xrpl/basics/safe_cast.h +++ b/include/xrpl/basics/safe_cast.h @@ -22,9 +22,9 @@ safeCast(Src s) noexcept { static_assert( std::is_signed_v || std::is_unsigned_v, "Cannot cast signed to unsigned"); - constexpr unsigned kNOT_SAME = std::is_signed_v != std::is_signed_v; + constexpr unsigned kNotSame = std::is_signed_v != std::is_signed_v; static_assert( - sizeof(Dest) >= sizeof(Src) + kNOT_SAME, + sizeof(Dest) >= sizeof(Src) + kNotSame, "Destination is too small to hold all values of source"); return static_cast(s); } @@ -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..cfd21e6e30 100644 --- a/include/xrpl/basics/scope.h +++ b/include/xrpl/basics/scope.h @@ -24,20 +24,20 @@ namespace xrpl { template class ScopeExit { - EF exit_function_; - bool execute_on_destruction_{true}; + EF exitFunction_; + bool executeOnDestruction_{true}; public: ~ScopeExit() { - if (execute_on_destruction_) - exit_function_(); + if (executeOnDestruction_) + exitFunction_(); } ScopeExit(ScopeExit&& rhs) noexcept( std::is_nothrow_move_constructible_v || std::is_nothrow_copy_constructible_v) - : exit_function_{std::forward(rhs.exit_function_)} - , execute_on_destruction_{rhs.execute_on_destruction_} + : exitFunction_{std::forward(rhs.exitFunction_)} + , executeOnDestruction_{rhs.executeOnDestruction_} { rhs.release(); } @@ -51,7 +51,7 @@ public: std::enable_if_t< !std::is_same_v, ScopeExit> && std::is_constructible_v>* = 0) noexcept - : exit_function_{std::forward(f)} + : exitFunction_{std::forward(f)} { static_assert(std::is_nothrow_constructible_v(f))>); } @@ -59,7 +59,7 @@ public: void release() noexcept { - execute_on_destruction_ = false; + executeOnDestruction_ = false; } }; @@ -69,22 +69,22 @@ ScopeExit(EF) -> ScopeExit; template class ScopeFail { - EF exit_function_; - bool execute_on_destruction_{true}; - int uncaught_on_creation_{std::uncaught_exceptions()}; + EF exitFunction_; + bool executeOnDestruction_{true}; + int uncaughtOnCreation_{std::uncaught_exceptions()}; public: ~ScopeFail() { - if (execute_on_destruction_ && std::uncaught_exceptions() > uncaught_on_creation_) - exit_function_(); + if (executeOnDestruction_ && std::uncaught_exceptions() > uncaughtOnCreation_) + exitFunction_(); } ScopeFail(ScopeFail&& rhs) noexcept( std::is_nothrow_move_constructible_v || std::is_nothrow_copy_constructible_v) - : exit_function_{std::forward(rhs.exit_function_)} - , execute_on_destruction_{rhs.execute_on_destruction_} - , uncaught_on_creation_{rhs.uncaught_on_creation_} + : exitFunction_{std::forward(rhs.exitFunction_)} + , executeOnDestruction_{rhs.executeOnDestruction_} + , uncaughtOnCreation_{rhs.uncaughtOnCreation_} { rhs.release(); } @@ -98,7 +98,7 @@ public: std::enable_if_t< !std::is_same_v, ScopeFail> && std::is_constructible_v>* = 0) noexcept - : exit_function_{std::forward(f)} + : exitFunction_{std::forward(f)} { static_assert(std::is_nothrow_constructible_v(f))>); } @@ -106,7 +106,7 @@ public: void release() noexcept { - execute_on_destruction_ = false; + executeOnDestruction_ = false; } }; @@ -116,22 +116,22 @@ ScopeFail(EF) -> ScopeFail; template class ScopeSuccess { - EF exit_function_; - bool execute_on_destruction_{true}; - int uncaught_on_creation_{std::uncaught_exceptions()}; + EF exitFunction_; + bool executeOnDestruction_{true}; + int uncaughtOnCreation_{std::uncaught_exceptions()}; public: - ~ScopeSuccess() noexcept(noexcept(exit_function_())) + ~ScopeSuccess() noexcept(noexcept(exitFunction_())) { - if (execute_on_destruction_ && std::uncaught_exceptions() <= uncaught_on_creation_) - exit_function_(); + if (executeOnDestruction_ && std::uncaught_exceptions() <= uncaughtOnCreation_) + exitFunction_(); } ScopeSuccess(ScopeSuccess&& rhs) noexcept( std::is_nothrow_move_constructible_v || std::is_nothrow_copy_constructible_v) - : exit_function_{std::forward(rhs.exit_function_)} - , execute_on_destruction_{rhs.execute_on_destruction_} - , uncaught_on_creation_{rhs.uncaught_on_creation_} + : exitFunction_{std::forward(rhs.exitFunction_)} + , executeOnDestruction_{rhs.executeOnDestruction_} + , uncaughtOnCreation_{rhs.uncaughtOnCreation_} { rhs.release(); } @@ -146,14 +146,14 @@ public: !std::is_same_v, ScopeSuccess> && std::is_constructible_v>* = 0) noexcept(std::is_nothrow_constructible_v || std::is_nothrow_constructible_v) - : exit_function_{std::forward(f)} + : exitFunction_{std::forward(f)} { } void release() noexcept { - execute_on_destruction_ = false; + executeOnDestruction_ = false; } }; @@ -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/clock/abstract_clock.h b/include/xrpl/beast/clock/abstract_clock.h index 67320ceabc..33d4096d0e 100644 --- a/include/xrpl/beast/clock/abstract_clock.h +++ b/include/xrpl/beast/clock/abstract_clock.h @@ -83,8 +83,8 @@ template AbstractClock& getAbstractClock() { - static detail::AbstractClockWrapper kCLOCK; - return kCLOCK; + static detail::AbstractClockWrapper kClock; + return kClock; } } // namespace beast 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/core/CurrentThreadName.h b/include/xrpl/beast/core/CurrentThreadName.h index 9bf062a885..6175d99b16 100644 --- a/include/xrpl/beast/core/CurrentThreadName.h +++ b/include/xrpl/beast/core/CurrentThreadName.h @@ -21,7 +21,7 @@ setCurrentThreadName(std::string_view newThreadName); // On Linux, thread names are limited to 16 bytes including the null terminator. // Maximum number of characters is therefore 15. -constexpr std::size_t kMAX_THREAD_NAME_LENGTH = 15; +constexpr std::size_t kMaxThreadNameLength = 15; /** Sets the name of the caller thread with compile-time size checking. @tparam N The size of the string literal including null terminator @@ -34,7 +34,7 @@ template void setCurrentThreadName(char const (&newThreadName)[N]) { - static_assert(N <= kMAX_THREAD_NAME_LENGTH + 1, "Thread name cannot exceed 15 characters"); + static_assert(N <= kMaxThreadNameLength + 1, "Thread name cannot exceed 15 characters"); setCurrentThreadName(std::string_view(newThreadName, N - 1)); } diff --git a/include/xrpl/beast/hash/hash_append.h b/include/xrpl/beast/hash/hash_append.h index 25ce668166..83cff4bdea 100644 --- a/include/xrpl/beast/hash/hash_append.h +++ b/include/xrpl/beast/hash/hash_append.h @@ -53,7 +53,7 @@ inline void maybeReverseBytes(T& t, Hasher&) { maybeReverseBytes( - t, std::integral_constant{}); + t, std::integral_constant{}); } } // namespace detail @@ -154,7 +154,7 @@ struct IsContiguouslyHashable : public std::integral_constant< bool, IsUniquelyRepresented::value && - (sizeof(T) == 1 || HashAlgorithm::kENDIAN == boost::endian::order::native)> + (sizeof(T) == 1 || HashAlgorithm::kEndian == boost::endian::order::native)> { explicit IsContiguouslyHashable() = default; }; diff --git a/include/xrpl/beast/hash/xxhasher.h b/include/xrpl/beast/hash/xxhasher.h index 01485e1e85..95a67dede0 100644 --- a/include/xrpl/beast/hash/xxhasher.h +++ b/include/xrpl/beast/hash/xxhasher.h @@ -21,9 +21,9 @@ private: static_assert(sizeof(std::size_t) == 8, "requires 64-bit std::size_t"); // Have an internal buffer to avoid the streaming API // A 64-byte buffer should to be big enough for us - static constexpr std::size_t kINTERNAL_BUFFER_SIZE = 64; + static constexpr std::size_t kInternalBufferSize = 64; - alignas(64) std::array buffer_{}; + alignas(64) std::array buffer_{}; std::span readBuffer_; std::span writeBuffer_; @@ -102,7 +102,7 @@ private: } public: - static constexpr auto const kENDIAN = boost::endian::order::native; + static constexpr auto kEndian = boost::endian::order::native; Xxhasher(Xxhasher const&) = delete; Xxhasher& diff --git a/include/xrpl/beast/unit_test/reporter.h b/include/xrpl/beast/unit_test/reporter.h index d2ba624f4a..1fdbb451a6 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 kMaxTop = 10; std::size_t suites = 0; std::size_t cases = 0; @@ -79,8 +77,8 @@ private: std::ostream& os_; Results results_; - SuiteResults suite_results_; - CaseResults case_results_; + SuiteResults suiteResults_; + CaseResults caseResults_; public: Reporter(Reporter const&) = delete; @@ -148,11 +146,11 @@ Reporter::Results::add(SuiteResults const& r) }); if (iter != top.end()) { - if (top.size() == MaxTop) + if (top.size() == kMaxTop) top.resize(top.size() - 1); top.emplace(iter, r.name, elapsed); } - else if (top.size() < MaxTop) + else if (top.size() < kMaxTop) { top.emplace_back(r.name, elapsed); } @@ -198,22 +196,22 @@ template void Reporter::onSuiteBegin(SuiteInfo const& info) { - suite_results_ = SuiteResults{info.fullName()}; + suiteResults_ = SuiteResults{info.fullName()}; } template void Reporter::onSuiteEnd() { - results_.add(suite_results_); + results_.add(suiteResults_); } template void Reporter::onCaseBegin(std::string const& name) { - case_results_ = CaseResults(name); - os_ << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name)) + caseResults_ = CaseResults(name); + os_ << suiteResults_.name << (caseResults_.name.empty() ? "" : (" " + caseResults_.name)) << std::endl; } @@ -221,23 +219,23 @@ template void Reporter::onCaseEnd() { - suite_results_.add(case_results_); + suiteResults_.add(caseResults_); } template void Reporter::onPass() { - ++case_results_.total; + ++caseResults_.total; } template void Reporter::onFail(std::string const& reason) { - ++case_results_.failed; - ++case_results_.total; - os_ << "#" << case_results_.total << " failed" << (reason.empty() ? "" : ": ") << reason + ++caseResults_.failed; + ++caseResults_.total; + os_ << "#" << caseResults_.total << " failed" << (reason.empty() ? "" : ": ") << reason << std::endl; } diff --git a/include/xrpl/beast/unit_test/suite.h b/include/xrpl/beast/unit_test/suite.h index 999058b7f1..fded866da0 100644 --- a/include/xrpl/beast/unit_test/suite.h +++ b/include/xrpl/beast/unit_test/suite.h @@ -299,8 +299,8 @@ private: static Suite** pThisSuite() { - static Suite* kP_TS = nullptr; // NOLINT TODO - return &kP_TS; + static Suite* kPTs = nullptr; // NOLINT TODO + return &kPTs; } /** Runs the suite. */ 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/beast/utility/Zero.h b/include/xrpl/beast/utility/Zero.h index 7825bb96e0..f54345d437 100644 --- a/include/xrpl/beast/utility/Zero.h +++ b/include/xrpl/beast/utility/Zero.h @@ -27,7 +27,7 @@ struct Zero }; namespace { -constexpr Zero kZERO{}; +constexpr Zero kZero{}; } // namespace /** Default implementation of signum calls the method on the class. */ @@ -102,42 +102,42 @@ template bool operator==(Zero, T const& t) { - return t == kZERO; + return t == kZero; } template bool operator!=(Zero, T const& t) { - return t != kZERO; + return t != kZero; } template bool operator<(Zero, T const& t) { - return t > kZERO; + return t > kZero; } template bool operator>(Zero, T const& t) { - return t < kZERO; + return t < kZero; } template bool operator>=(Zero, T const& t) { - return t <= kZERO; + return t <= kZero; } template bool operator<=(Zero, T const& t) { - return t >= kZERO; + return t >= kZero; } } // namespace beast diff --git a/include/xrpl/beast/utility/rngfill.h b/include/xrpl/beast/utility/rngfill.h index 1bc8350d4f..1614a594c5 100644 --- a/include/xrpl/beast/utility/rngfill.h +++ b/include/xrpl/beast/utility/rngfill.h @@ -14,23 +14,23 @@ void rngfill(void* const buffer, std::size_t const bytes, Generator& g) { using result_type = typename Generator::result_type; - constexpr std::size_t kRESULT_SIZE = sizeof(result_type); + constexpr std::size_t kResultSize = sizeof(result_type); std::uint8_t* const bufferStart = static_cast(buffer); - std::size_t const completeIterations = bytes / kRESULT_SIZE; - std::size_t const bytesRemaining = bytes % kRESULT_SIZE; + std::size_t const completeIterations = bytes / kResultSize; + std::size_t const bytesRemaining = bytes % kResultSize; for (std::size_t count = 0; count < completeIterations; ++count) { result_type const v = g(); - std::size_t const offset = count * kRESULT_SIZE; - std::memcpy(bufferStart + offset, &v, kRESULT_SIZE); + std::size_t const offset = count * kResultSize; + std::memcpy(bufferStart + offset, &v, kResultSize); } if (bytesRemaining > 0) { result_type const v = g(); - std::size_t const offset = completeIterations * kRESULT_SIZE; + std::size_t const offset = completeIterations * kResultSize; std::memcpy(bufferStart + offset, &v, bytesRemaining); } } diff --git a/include/xrpl/beast/xor_shift_engine.h b/include/xrpl/beast/xor_shift_engine.h index 3a5345934e..45baecf101 100644 --- a/include/xrpl/beast/xor_shift_engine.h +++ b/include/xrpl/beast/xor_shift_engine.h @@ -26,12 +26,14 @@ public: result_type operator()(); - static result_type constexpr min() + static constexpr result_type + min() { return std::numeric_limits::min(); } - static result_type constexpr max() + static constexpr result_type + max() { return std::numeric_limits::max(); } diff --git a/include/xrpl/conditions/Condition.h b/include/xrpl/conditions/Condition.h index 0d45245585..66d1d24736 100644 --- a/include/xrpl/conditions/Condition.h +++ b/include/xrpl/conditions/Condition.h @@ -27,7 +27,7 @@ public: that were previously considered valid to no longer be allowed. */ - static constexpr std::size_t kMAX_SERIALIZED_CONDITION = 128; + static constexpr std::size_t kMaxSerializedCondition = 128; /** Load a condition from its binary form diff --git a/include/xrpl/conditions/Fulfillment.h b/include/xrpl/conditions/Fulfillment.h index 8b315297d7..fd8cd7d31e 100644 --- a/include/xrpl/conditions/Fulfillment.h +++ b/include/xrpl/conditions/Fulfillment.h @@ -16,7 +16,7 @@ public: that were previously considered valid to no longer be allowed. */ - static constexpr std::size_t kMAX_SERIALIZED_FULFILLMENT = 256; + static constexpr std::size_t kMaxSerializedFulfillment = 256; /** Load a fulfillment from its binary form diff --git a/include/xrpl/conditions/detail/PreimageSha256.h b/include/xrpl/conditions/detail/PreimageSha256.h index e3018f754c..c592ea37ee 100644 --- a/include/xrpl/conditions/detail/PreimageSha256.h +++ b/include/xrpl/conditions/detail/PreimageSha256.h @@ -23,7 +23,7 @@ public: While future versions of this code will never lower this limit, they may opt to raise it. */ - static constexpr std::size_t kMAX_PREIMAGE_LENGTH = 128; + static constexpr std::size_t kMaxPreimageLength = 128; /** Parse the payload for a PreimageSha256 condition @@ -65,7 +65,7 @@ public: return {}; } - if (s.size() > kMAX_PREIMAGE_LENGTH) + if (s.size() > kMaxPreimageLength) { ec = Error::PreimageTooLong; return {}; diff --git a/include/xrpl/core/Coro.ipp b/include/xrpl/core/Coro.ipp index 4b876dc68d..133caf37a9 100644 --- a/include/xrpl/core/Coro.ipp +++ b/include/xrpl/core/Coro.ipp @@ -6,7 +6,7 @@ namespace xrpl { /// Coroutine stack size (1.5 MB). Increased from 1 MB because /// ASAN-instrumented deep call stacks exceeded the original limit. -constexpr std::size_t kCORO_STACK_SIZE = 1536 * 1024; +constexpr std::size_t kCoroStackSize = 1536 * 1024; template JobQueue::Coro::Coro(CoroCreateT, JobQueue& jq, JobType type, std::string name, F&& f) @@ -14,7 +14,7 @@ JobQueue::Coro::Coro(CoroCreateT, JobQueue& jq, JobType type, std::string name, , type_(type) , name_(std::move(name)) , coro_( - boost::context::protected_fixedsize_stack(kCORO_STACK_SIZE), + boost::context::protected_fixedsize_stack(kCoroStackSize), [this, fn = std::forward(f)](boost::coroutines2::coroutine::push_type& doYield) { yield_ = &doYield; yield(); @@ -47,7 +47,7 @@ inline bool JobQueue::Coro::post() { { - std::scoped_lock const lk(mutex_run_); + std::scoped_lock const lk(mutexRun_); running_ = true; } @@ -58,7 +58,7 @@ JobQueue::Coro::post() } // The coroutine will not run. Clean up running_. - std::scoped_lock const lk(mutex_run_); + std::scoped_lock const lk(mutexRun_); running_ = false; cv_.notify_all(); return false; @@ -68,7 +68,7 @@ inline void JobQueue::Coro::resume() { { - std::scoped_lock const lk(mutex_run_); + std::scoped_lock const lk(mutexRun_); running_ = true; } { @@ -92,7 +92,7 @@ JobQueue::Coro::resume() } detail::getLocalValues().release(); detail::getLocalValues().reset(saved); - std::scoped_lock const lk(mutex_run_); + std::scoped_lock const lk(mutexRun_); running_ = false; cv_.notify_all(); } @@ -127,7 +127,7 @@ JobQueue::Coro::expectEarlyExit() inline void JobQueue::Coro::join() { - std::unique_lock lk(mutex_run_); + std::unique_lock lk(mutexRun_); cv_.wait(lk, [this]() { return !running_; }); } diff --git a/include/xrpl/core/Job.h b/include/xrpl/core/Job.h index b62488dec6..6af32eb2d8 100644 --- a/include/xrpl/core/Job.h +++ b/include/xrpl/core/Job.h @@ -127,7 +127,7 @@ private: std::function job_; std::shared_ptr loadEvent_; std::string name_; - clock_type::time_point queue_time_; + clock_type::time_point queueTime_; }; using JobCounter = ClosureCounter; diff --git a/include/xrpl/core/JobQueue.h b/include/xrpl/core/JobQueue.h index 2a96ea45fa..fc15e9a064 100644 --- a/include/xrpl/core/JobQueue.h +++ b/include/xrpl/core/JobQueue.h @@ -52,7 +52,7 @@ public: std::string name_; bool running_{false}; std::mutex mutex_; - std::mutex mutex_run_; + std::mutex mutexRun_; std::condition_variable cv_; boost::coroutines2::coroutine::push_type* yield_{}; boost::coroutines2::coroutine::pull_type coro_; @@ -246,7 +246,7 @@ private: // Statistics tracking perf::PerfLog& perfLog_; beast::insight::Collector::ptr collector_; - beast::insight::Gauge job_count_; + beast::insight::Gauge jobCount_; beast::insight::Hook hook_; std::condition_variable cv_; diff --git a/include/xrpl/core/JobTypes.h b/include/xrpl/core/JobTypes.h index 32a793c9dc..fb5c7988cb 100644 --- a/include/xrpl/core/JobTypes.h +++ b/include/xrpl/core/JobTypes.h @@ -101,8 +101,8 @@ public: static JobTypes const& instance() { - static JobTypes const kTYPES; - return kTYPES; + static JobTypes const kTypes; + return kTypes; } static std::string const& 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/Writer.h b/include/xrpl/json/Writer.h index 664a2a75c1..87e3e99c7e 100644 --- a/include/xrpl/json/Writer.h +++ b/include/xrpl/json/Writer.h @@ -161,7 +161,7 @@ public: * While the JSON spec doesn't explicitly disallow this, you should avoid * calling this method twice with the same tag for the same object. * - * If CHECK_JSON_WRITER is defined, this function throws an exception if if + * If CHECK_JSON_WRITER is defined, this function throws an exception if * the tag you use has already been used in this object. */ template diff --git a/include/xrpl/json/json_reader.h b/include/xrpl/json/json_reader.h index 8ce565dbbc..9251183281 100644 --- a/include/xrpl/json/json_reader.h +++ b/include/xrpl/json/json_reader.h @@ -67,27 +67,25 @@ public: [[nodiscard]] std::string getFormattedErrorMessages() const; - static constexpr unsigned kNEST_LIMIT{25}; + static constexpr unsigned kNestLimit{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..e9dcb8bcbe 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::kMinInt - Value::kMaxInt] + * - unsigned integer (range: 0 - Value::kMaxUInt) * - 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 @@ -140,18 +138,16 @@ public: using Int = json::Int; using ArrayIndex = UInt; - 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 Value const kNull; + static constexpr Int kMinInt = std::numeric_limits::min(); + static constexpr Int kMaxInt = std::numeric_limits::max(); + static constexpr UInt kMaxUInt = 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/BookDirs.h b/include/xrpl/ledger/BookDirs.h index afde6ee7b3..7eaede14ec 100644 --- a/include/xrpl/ledger/BookDirs.h +++ b/include/xrpl/ledger/BookDirs.h @@ -9,7 +9,7 @@ class BookDirs private: ReadView const* view_ = nullptr; uint256 const root_; - uint256 const next_quality_; + uint256 const nextQuality_; uint256 const key_; std::shared_ptr sle_ = nullptr; unsigned int entry_ = 0; @@ -67,15 +67,15 @@ private: friend class BookDirs; const_iterator(ReadView const& view, uint256 const& root, uint256 const& dirKey) - : view_(&view), root_(root), key_(dirKey), cur_key_(dirKey) + : view_(&view), root_(root), key_(dirKey), curKey_(dirKey) { } ReadView const* view_ = nullptr; uint256 root_; - uint256 next_quality_; + uint256 nextQuality_; uint256 key_; - uint256 cur_key_; + uint256 curKey_; std::shared_ptr sle_; unsigned int entry_ = 0; uint256 index_; diff --git a/include/xrpl/ledger/Ledger.h b/include/xrpl/ledger/Ledger.h index 2d6f48db2d..351f7d80e5 100644 --- a/include/xrpl/ledger/Ledger.h +++ b/include/xrpl/ledger/Ledger.h @@ -24,7 +24,7 @@ struct CreateGenesisT { explicit CreateGenesisT() = default; }; -extern CreateGenesisT const kCREATE_GENESIS; +extern CreateGenesisT const kCreateGenesis; /** Holds a ledger. diff --git a/include/xrpl/ledger/LedgerTiming.h b/include/xrpl/ledger/LedgerTiming.h index dce28bd44b..508403d760 100644 --- a/include/xrpl/ledger/LedgerTiming.h +++ b/include/xrpl/ledger/LedgerTiming.h @@ -12,7 +12,7 @@ namespace xrpl { Values should not be duplicated. @see getNextLedgerTimeResolution */ -std::chrono::seconds constexpr kLEDGER_POSSIBLE_TIME_RESOLUTIONS[] = { +constexpr std::chrono::seconds kLedgerPossibleTimeResolutions[] = { std::chrono::seconds{10}, std::chrono::seconds{20}, std::chrono::seconds{30}, @@ -21,16 +21,16 @@ std::chrono::seconds constexpr kLEDGER_POSSIBLE_TIME_RESOLUTIONS[] = { std::chrono::seconds{120}}; //! Initial resolution of ledger close time. -auto constexpr kLEDGER_DEFAULT_TIME_RESOLUTION = kLEDGER_POSSIBLE_TIME_RESOLUTIONS[2]; +constexpr auto kLedgerDefaultTimeResolution = kLedgerPossibleTimeResolutions[2]; //! Close time resolution in genesis ledger -auto constexpr kLEDGER_GENESIS_TIME_RESOLUTION = kLEDGER_POSSIBLE_TIME_RESOLUTIONS[0]; +constexpr auto kLedgerGenesisTimeResolution = kLedgerPossibleTimeResolutions[0]; //! How often we increase the close time resolution (in numbers of ledgers) -auto constexpr kINCREASE_LEDGER_TIME_RESOLUTION_EVERY = 8; +constexpr auto kIncreaseLedgerTimeResolutionEvery = 8; //! How often we decrease the close time resolution (in numbers of ledgers) -auto constexpr kDECREASE_LEDGER_TIME_RESOLUTION_EVERY = 1; +constexpr auto kDecreaseLedgerTimeResolutionEvery = 1; /** Calculates the close time resolution for the specified ledger. @@ -46,7 +46,7 @@ auto constexpr kDECREASE_LEDGER_TIME_RESOLUTION_EVERY = 1; @param ledgerSeq the sequence number of the new ledger @pre previousResolution must be a valid bin - from @ref kLEDGER_POSSIBLE_TIME_RESOLUTIONS + from @ref kLedgerPossibleTimeResolutions @tparam Rep Type representing number of ticks in std::chrono::duration @tparam Period An std::ratio representing tick period in @@ -67,30 +67,30 @@ getNextLedgerTimeResolution( using namespace std::chrono; // Find the current resolution: auto iter = std::find( - std::begin(kLEDGER_POSSIBLE_TIME_RESOLUTIONS), - std::end(kLEDGER_POSSIBLE_TIME_RESOLUTIONS), + std::begin(kLedgerPossibleTimeResolutions), + std::end(kLedgerPossibleTimeResolutions), previousResolution); XRPL_ASSERT( - iter != std::end(kLEDGER_POSSIBLE_TIME_RESOLUTIONS), + iter != std::end(kLedgerPossibleTimeResolutions), "xrpl::getNextLedgerTimeResolution : found time resolution"); // This should never happen, but just as a precaution - if (iter == std::end(kLEDGER_POSSIBLE_TIME_RESOLUTIONS)) + if (iter == std::end(kLedgerPossibleTimeResolutions)) return previousResolution; // If we did not previously agree, we try to decrease the resolution to // improve the chance that we will agree now. - if (!previousAgree && (ledgerSeq % Seq{kDECREASE_LEDGER_TIME_RESOLUTION_EVERY} == Seq{0})) + if (!previousAgree && (ledgerSeq % Seq{kDecreaseLedgerTimeResolutionEvery} == Seq{0})) { - if (++iter != std::end(kLEDGER_POSSIBLE_TIME_RESOLUTIONS)) + if (++iter != std::end(kLedgerPossibleTimeResolutions)) return *iter; } // If we previously agreed, we try to increase the resolution to determine // if we can continue to agree. - if (previousAgree && (ledgerSeq % Seq{kINCREASE_LEDGER_TIME_RESOLUTION_EVERY} == Seq{0})) + if (previousAgree && (ledgerSeq % Seq{kIncreaseLedgerTimeResolutionEvery} == Seq{0})) { - if (iter-- != std::begin(kLEDGER_POSSIBLE_TIME_RESOLUTIONS)) + if (iter-- != std::begin(kLedgerPossibleTimeResolutions)) return *iter; } diff --git a/include/xrpl/ledger/OpenView.h b/include/xrpl/ledger/OpenView.h index 59ab733211..18d1a9399c 100644 --- a/include/xrpl/ledger/OpenView.h +++ b/include/xrpl/ledger/OpenView.h @@ -23,7 +23,7 @@ namespace xrpl { inline constexpr struct OpenLedgerT { explicit constexpr OpenLedgerT() = default; -} kOPEN_LEDGER{}; +} kOpenLedger{}; /** Batch view construction tag. @@ -33,7 +33,7 @@ inline constexpr struct OpenLedgerT inline constexpr struct BatchViewT { explicit constexpr BatchViewT() = default; -} kBATCH_VIEW{}; +} kBatchView{}; //------------------------------------------------------------------------------ @@ -47,7 +47,7 @@ private: // Initial size for the monotonic_buffer_resource used for allocations // The size was chosen from the old `qalloc` code (which this replaces). // It is unclear how the size initially chosen in qalloc. - static constexpr size_t kINITIAL_BUFFER_SIZE = kilobytes(256); + static constexpr size_t kInitialBufferSize = kilobytes(256); class TxsIterImpl; @@ -76,7 +76,7 @@ private: // monotonic_resource_ must outlive `items_`. Make a pointer so it may be // easily moved. - std::unique_ptr monotonic_resource_; + std::unique_ptr monotonicResource_; txs_map txs_; Rules rules_; LedgerHeader header_; @@ -139,7 +139,7 @@ public: std::shared_ptr hold = nullptr); OpenView(OpenLedgerT, Rules const& rules, std::shared_ptr const& base) - : OpenView(kOPEN_LEDGER, &*base, rules, base) + : OpenView(kOpenLedger, &*base, rules, base) { } diff --git a/include/xrpl/ledger/View.h b/include/xrpl/ledger/View.h index 4958a89d8c..0d76c98a73 100644 --- a/include/xrpl/ledger/View.h +++ b/include/xrpl/ledger/View.h @@ -57,7 +57,7 @@ isVaultPseudoAccountFrozen( ReadView const& view, AccountID const& account, MPTIssue const& mptShare, - int depth); + std::uint8_t depth); [[nodiscard]] bool isLPTokenFrozen( diff --git a/include/xrpl/ledger/detail/RawStateTable.h b/include/xrpl/ledger/detail/RawStateTable.h index 169a7c505e..e4329bf6fc 100644 --- a/include/xrpl/ledger/detail/RawStateTable.h +++ b/include/xrpl/ledger/detail/RawStateTable.h @@ -19,17 +19,17 @@ public: // Initial size for the monotonic_buffer_resource used for allocations // The size was chosen from the old `qalloc` code (which this replaces). // It is unclear how the size initially chosen in qalloc. - static constexpr size_t kINITIAL_BUFFER_SIZE = kilobytes(256); + static constexpr size_t kInitialBufferSize = kilobytes(256); RawStateTable() - : monotonic_resource_{std::make_unique( - kINITIAL_BUFFER_SIZE)} - , items_{monotonic_resource_.get()} {}; + : monotonicResource_{std::make_unique( + kInitialBufferSize)} + , items_{monotonicResource_.get()} {}; RawStateTable(RawStateTable const& rhs) - : monotonic_resource_{std::make_unique( - kINITIAL_BUFFER_SIZE)} - , items_{rhs.items_, monotonic_resource_.get()} + : monotonicResource_{std::make_unique( + kInitialBufferSize)} + , items_{rhs.items_, monotonicResource_.get()} , dropsDestroyed_{rhs.dropsDestroyed_} {}; RawStateTable(RawStateTable&&) = default; @@ -101,7 +101,7 @@ private: boost::container::pmr::polymorphic_allocator>>; // monotonic_resource_ must outlive `items_`. Make a pointer so it may be // easily moved. - std::unique_ptr monotonic_resource_; + std::unique_ptr monotonicResource_; items_t items_; XRPAmount dropsDestroyed_{0}; diff --git a/include/xrpl/ledger/helpers/AMMHelpers.h b/include/xrpl/ledger/helpers/AMMHelpers.h index c62437bf75..a146ef753b 100644 --- a/include/xrpl/ledger/helpers/AMMHelpers.h +++ b/include/xrpl/ledger/helpers/AMMHelpers.h @@ -25,11 +25,11 @@ namespace detail { Number reduceOffer(auto const& amount) { - static Number const kREDUCED_OFFER_PCT(9999, -4); + static Number const kReducedOfferPct(9999, -4); // Make sure the result is always less than amount or zero. NumberRoundModeGuard const mg(Number::RoundingMode::TowardsZero); - return amount * kREDUCED_OFFER_PCT; + return amount * kReducedOfferPct; } } // namespace detail @@ -177,7 +177,7 @@ getAMMOfferStartWithTakerGets( Quality const& targetQuality, std::uint16_t const& tfee) { - if (targetQuality.rate() == beast::kZERO) + if (targetQuality.rate() == beast::kZero) return std::nullopt; NumberRoundModeGuard const mg(Number::RoundingMode::ToNearest); @@ -244,7 +244,7 @@ getAMMOfferStartWithTakerPays( Quality const& targetQuality, std::uint16_t tfee) { - if (targetQuality.rate() == beast::kZERO) + if (targetQuality.rate() == beast::kZero) return std::nullopt; NumberRoundModeGuard const mg(Number::RoundingMode::ToNearest); 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..859981cf05 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 @@ -111,7 +111,7 @@ escrowUnlockApplyHelper( // whereas in a normal payment, the transfer fee is taken on top of the // sending amount. auto finalAmt = amount; - if ((!senderIssuer && !receiverIssuer) && lockedRate != kPARITY_RATE) + if ((!senderIssuer && !receiverIssuer) && lockedRate != kParityRate) { // compute transfer fee, if any auto const xferFee = @@ -211,7 +211,7 @@ escrowUnlockApplyHelper( // whereas in a normal payment, the transfer fee is taken on top of the // sending amount. auto finalAmt = amount; - if ((!senderIssuer && !receiverIssuer) && lockedRate != kPARITY_RATE) + if ((!senderIssuer && !receiverIssuer) && lockedRate != kParityRate) { // compute transfer fee, if any auto const xferFee = amount.value() - divideRound(amount, lockedRate, amount.asset(), true); diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h index 83ce8e5efa..b7a1ed6bf2 100644 --- a/include/xrpl/ledger/helpers/LendingHelpers.h +++ b/include/xrpl/ledger/helpers/LendingHelpers.h @@ -4,13 +4,43 @@ #include #include +#include + namespace xrpl { +/** + * Broker cover preclaim precision guard (fixCleanup3_2_0). + * + * Prevents a "silent sub-ULP no-op" where a deposit, withdrawal, or clawback + * amount is so small that it rounds to zero at `sfCoverAvailable`'s scale. + * Without this guard, both the pseudo trust-line and `sfCoverAvailable` would + * identically absorb the rounded zero, resulting in a successful transaction + * (tesSUCCESS) where no funds actually moved. + * + * @param view Read view (rules used for amendment gating). + * @param sleBroker The loan broker SLE (read-only). + * @param vaultAsset The underlying vault asset (the broker's cover asset). + * @param amount The effective subtraction/addition amount. + * @param j Journal for logging. + * @param logPrefix Transactor name for log diagnostics. + * + * @return `tecPRECISION_LOSS` if the request rounds to zero at cover scale. + * `tesSUCCESS` if the amendment is disabled or the request is safely supra-ULP. + */ +[[nodiscard]] TER +canApplyToBrokerCover( + ReadView const& view, + SLE::const_ref sleBroker, + Asset const& vaultAsset, + STAmount const& amount, + beast::Journal j, + std::string_view logPrefix); + // Lending protocol has dependencies, so capture them here. bool checkLendingProtocolDependencies(Rules const& rules, STTx const& tx); -static constexpr std::uint32_t kSECONDS_IN_YEAR = 365 * 24 * 60 * 60; +static constexpr std::uint32_t kSecondsInYear = 365 * 24 * 60 * 60; Number loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval); @@ -42,14 +72,14 @@ struct LoanPaymentParts // The amount of principal paid that reduces the loan balance. // This amount is subtracted from sfPrincipalOutstanding in the Loan object // and paid to the Vault - Number principalPaid = kNUM_ZERO; + Number principalPaid = kNumZero; // The total amount of interest paid to the Vault. // This includes: // - Tracked interest from the amortization schedule // - Untracked interest (e.g., late payment penalty interest) // This value is always non-negative. - Number interestPaid = kNUM_ZERO; + Number interestPaid = kNumZero; // The change in the loan's total value outstanding. // - If valueChange < 0: Loan value decreased @@ -62,7 +92,7 @@ struct LoanPaymentParts // - Late payments add penalty interest to the loan value // - Early full payment may increase or decrease the loan value based on // terms - Number valueChange = kNUM_ZERO; + Number valueChange = kNumZero; /* The total amount of fees paid to the Broker. * This includes: @@ -70,7 +100,7 @@ struct LoanPaymentParts * - Untracked fees (e.g., late payment fees, service fees, origination * fees) This value is always non-negative. */ - Number feePaid = kNUM_ZERO; + Number feePaid = kNumZero; LoanPaymentParts& operator+=(LoanPaymentParts const& other); @@ -161,7 +191,7 @@ adjustImpreciseNumber( { value = roundToAsset(asset, value + adjustment, vaultScale); - if (*value < beast::kZERO) + if (*value < beast::kZero) value = 0; } @@ -169,10 +199,25 @@ inline int getAssetsTotalScale(SLE::const_ref vaultSle) { if (!vaultSle) - return Number::kMIN_EXPONENT - 1; // LCOV_EXCL_LINE + return Number::kMinExponent - 1; // LCOV_EXCL_LINE return scale(vaultSle->at(sfAssetsTotal), vaultSle->at(sfAsset)); } +// Compute the minimum required broker cover, rounded consistently. +// DebtTotal is a broker-level aggregate maintained at vault scale, so the +// rounding must also use vault scale — never an individual loan's scale. +inline Number +minimumBrokerCover(Number const& debtTotal, TenthBips32 coverRateMinimum, SLE::const_ref vaultSle) +{ + XRPL_ASSERT( + vaultSle && vaultSle->getType() == ltVAULT, "xrpl::minimumBrokerCover : valid Vault sle"); + NumberRoundModeGuard const mg(Number::RoundingMode::Upward); + return roundToAsset( + vaultSle->at(sfAsset), + tenthBipsOfValue(debtTotal, coverRateMinimum), + getAssetsTotalScale(vaultSle)); +} + TER checkLoanGuards( Asset const& vaultAsset, @@ -184,6 +229,7 @@ checkLoanGuards( LoanState computeTheoreticalLoanState( + Rules const& rules, Number const& periodicPayment, Number const& periodicRate, std::uint32_t const paymentRemaining, @@ -310,7 +356,7 @@ struct ExtendedPaymentComponents : public PaymentComponents // borrower is sufficient to cover all components of the payment. Number totalDue; - ExtendedPaymentComponents(PaymentComponents const& p, Number fee, Number interest = kNUM_ZERO) + ExtendedPaymentComponents(PaymentComponents const& p, Number fee, Number interest = kNumZero) : PaymentComponents(p) , untrackedManagementFee(fee) , untrackedInterest(interest) @@ -353,6 +399,7 @@ struct LoanStateDeltas Expected, TER> tryOverpayment( + Rules const& rules, Asset const& asset, std::int32_t loanScale, ExtendedPaymentComponents const& overpaymentComponents, @@ -363,11 +410,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 +431,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 +470,7 @@ computeOverpaymentComponents( PaymentComponents computePaymentComponents( + Rules const& rules, Asset const& asset, std::int32_t scale, Number const& totalValueOutstanding, @@ -438,6 +494,7 @@ operator+(LoanState const& lhs, detail::LoanStateDeltas const& rhs); LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, TenthBips32 interestRate, @@ -448,6 +505,7 @@ computeLoanProperties( LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, Number const& periodicRate, diff --git a/include/xrpl/ledger/helpers/MPTokenHelpers.h b/include/xrpl/ledger/helpers/MPTokenHelpers.h index 6544b18dd1..c709badab8 100644 --- a/include/xrpl/ledger/helpers/MPTokenHelpers.h +++ b/include/xrpl/ledger/helpers/MPTokenHelpers.h @@ -27,14 +27,18 @@ isGlobalFrozen(ReadView const& view, MPTIssue const& mptIssue); isIndividualFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue); [[nodiscard]] bool -isFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth = 0); +isFrozen( + ReadView const& view, + AccountID const& account, + MPTIssue const& mptIssue, + std::uint8_t depth = 0); [[nodiscard]] bool isAnyFrozen( ReadView const& view, std::initializer_list const& accounts, MPTIssue const& mptIssue, - int depth = 0); + std::uint8_t depth = 0); //------------------------------------------------------------------------------ // @@ -88,7 +92,7 @@ requireAuth( MPTIssue const& mptIssue, AccountID const& account, AuthType authType = AuthType::Legacy, - int depth = 0); + std::uint8_t depth = 0); /** Enforce account has MPToken to match its authorization. * @@ -104,22 +108,77 @@ enforceMPTokenAuthorization( XRPAmount const& priorBalance, beast::Journal j); -/** Check if the destination account is allowed - * to receive MPT. Return tecNO_AUTH if it doesn't - * and tesSUCCESS otherwise. +/** Resolve the underlying asset of a vault share. + * + * Reads sfReferenceHolding from @p sleShareIssuance to determine which + * asset the vault wraps. @p sleHolding must be the SLE that + * sfReferenceHolding points to — either an ltMPTOKEN (returns its + * MPTIssue) or an ltRIPPLE_STATE (returns its low/high Issue). + * + * @pre Both SLEs must exist and @p sleHolding must be of type ltMPTOKEN + * or ltRIPPLE_STATE. Passing any other type is undefined behaviour. + * @param sleShareIssuance MPTokenIssuance SLE for the vault share token. + * @param sleHolding SLE referenced by sfReferenceHolding. + * @return The underlying Asset (MPTIssue or Issue). + */ +[[nodiscard]] Asset +assetOfHolding(SLE const& sleShareIssuance, SLE const& sleHolding); + +/** Check whether @p to may receive the given MPT from @p from. + * + * The check passes when any of the following is true: + * - @p waive is WaiveMPTCanTransfer::Yes (recovery-path exemption), or + * - @p from or @p to is the issuer, or + * - lsfMPTCanTransfer is set on the MPTokenIssuance. + * + * For vault shares (MPTokenIssuances that carry sfReferenceHolding) the + * check recurses into the underlying asset's transferability. This + * recursion is defensive; vault-of-vault-shares is rejected at vault + * creation, so in practice depth never exceeds 1. + * + * @param view Ledger state to read from. + * @param mptIssue The MPT issuance being transferred. + * @param from Sending account. + * @param to Receiving account. + * @param waive WaiveMPTCanTransfer::Yes skips the lsfMPTCanTransfer + * check. Use for recovery paths (e.g. unwinding SAV or + * Lending Protocol positions after an issuer revokes + * transferability). + * @param depth Recursion depth; bounded at kMaxAssetCheckDepth. + * @return tesSUCCESS if the transfer is allowed, tecNO_AUTH otherwise. */ [[nodiscard]] TER canTransfer( ReadView const& view, MPTIssue const& mptIssue, AccountID const& from, - AccountID const& to); + AccountID const& to, + WaiveMPTCanTransfer waive = WaiveMPTCanTransfer::No, + std::uint8_t depth = 0); -/** Check if Asset can be traded on DEX. return tecNO_PERMISSION - * if it doesn't and tesSUCCESS otherwise. +/** Check whether @p asset may be traded on the DEX. + * + * For IOU assets the check delegates to the existing offer/AMM freeze + * logic. For MPT assets it checks lsfMPTCanTrade on the MPTokenIssuance. + * Vault shares recurse into the underlying asset's tradability via + * sfReferenceHolding; depth is bounded at kMaxAssetCheckDepth. + * + * @param view Ledger state to read from. + * @param asset The asset to check. + * @param depth Recursion depth; bounded at kMaxAssetCheckDepth. + * @return tesSUCCESS if trading is allowed, tecNO_PERMISSION otherwise. */ [[nodiscard]] TER -canTrade(ReadView const& view, Asset const& asset); +canTrade(ReadView const& view, Asset const& asset, std::uint8_t depth = 0); + +/** Convenience to combine canTrade/Transfer. Returns tesSUCCESS if Asset is Issue. + */ +[[nodiscard]] TER +canMPTTradeAndTransfer( + ReadView const& v, + Asset const& asset, + AccountID const& from, + AccountID const& to); //------------------------------------------------------------------------------ // @@ -227,17 +286,4 @@ issuerFundsToSelfIssue(ReadView const& view, MPTIssue const& issue); void issuerSelfDebitHookMPT(ApplyView& view, MPTIssue const& issue, std::uint64_t amount); -//------------------------------------------------------------------------------ -// -// MPT DEX -// -//------------------------------------------------------------------------------ - -/* Return true if a transaction is allowed for the specified MPT/account. The - * function checks MPTokenIssuance and MPToken objects flags to determine if the - * transaction is allowed. - */ -TER -checkMPTTxAllowed(ReadView const& v, TxType tx, Asset const& asset, AccountID const& accountID); - } // namespace xrpl diff --git a/include/xrpl/ledger/helpers/RippleStateHelpers.h b/include/xrpl/ledger/helpers/RippleStateHelpers.h index 17b0f7673e..2616a6d5c9 100644 --- a/include/xrpl/ledger/helpers/RippleStateHelpers.h +++ b/include/xrpl/ledger/helpers/RippleStateHelpers.h @@ -93,7 +93,7 @@ isFrozen(ReadView const& view, AccountID const& account, Issue const& issue) // Overload with depth parameter for uniformity with MPTIssue version. // The depth parameter is ignored for IOUs since they don't have vault recursion. [[nodiscard]] inline bool -isFrozen(ReadView const& view, AccountID const& account, Issue const& issue, int /*depth*/) +isFrozen(ReadView const& view, AccountID const& account, Issue const& issue, std::uint8_t /*depth*/) { return isFrozen(view, account, issue); } @@ -110,7 +110,7 @@ isDeepFrozen( ReadView const& view, AccountID const& account, Issue const& issue, - int = 0 /*ignored*/) + std::uint8_t = 0 /*ignored*/) { return isDeepFrozen(view, account, issue.currency, issue.account); } diff --git a/include/xrpl/ledger/helpers/TokenHelpers.h b/include/xrpl/ledger/helpers/TokenHelpers.h index 3d41ac47cd..f736e51d28 100644 --- a/include/xrpl/ledger/helpers/TokenHelpers.h +++ b/include/xrpl/ledger/helpers/TokenHelpers.h @@ -34,6 +34,15 @@ enum class WaiveTransferFee : bool { No = false, Yes }; /** Controls whether accountSend is allowed to overflow OutstandingAmount **/ enum class AllowMPTOverflow : bool { No = false, Yes }; +/** Controls whether canTransfer enforces lsfMPTCanTransfer on MPTs. + * + * Default is No (enforce). Use Yes at call sites that must remain available + * even when an MPT issuer has cleared lsfMPTCanTransfer - for example, + * unwinding existing positions in SAV or the Lending Protocol. Has no + * effect on the IOU branch of canTransfer. + */ +enum class WaiveMPTCanTransfer : bool { No = false, Yes }; + /* Check if MPToken (for MPT) or trust line (for IOU) exists: * - StrongAuth - before checking if authorization is required * - WeakAuth @@ -54,16 +63,26 @@ enum class AuthType { StrongAuth, WeakAuth, Legacy }; [[nodiscard]] bool isGlobalFrozen(ReadView const& view, Asset const& asset); +[[nodiscard]] TER +checkGlobalFrozen(ReadView const& view, Asset const& asset); + [[nodiscard]] bool isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset); +[[nodiscard]] TER +checkIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset); + /** * isFrozen check is recursive for MPT shares in a vault, descending to * assets in the vault, up to maxAssetCheckDepth recursion depth. This is * purely defensive, as we currently do not allow such vaults to be created. */ [[nodiscard]] bool -isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0); +isFrozen( + ReadView const& view, + AccountID const& account, + Asset const& asset, + std::uint8_t depth = 0); [[nodiscard]] TER checkFrozen(ReadView const& view, AccountID const& account, Issue const& issue); @@ -85,14 +104,14 @@ isAnyFrozen( ReadView const& view, std::initializer_list const& accounts, Asset const& asset, - int depth = 0); + std::uint8_t depth = 0); [[nodiscard]] bool isDeepFrozen( ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, - int depth = 0); + std::uint8_t depth = 0); /** * isFrozen check is recursive for MPT shares in a vault, descending to @@ -100,7 +119,11 @@ isDeepFrozen( * purely defensive, as we currently do not allow such vaults to be created. */ [[nodiscard]] bool -isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0); +isDeepFrozen( + ReadView const& view, + AccountID const& account, + Asset const& asset, + std::uint8_t depth = 0); [[nodiscard]] TER checkDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue); @@ -234,7 +257,13 @@ requireAuth( AuthType authType = AuthType::Legacy); [[nodiscard]] TER -canTransfer(ReadView const& view, Asset const& asset, AccountID const& from, AccountID const& to); +canTransfer( + ReadView const& view, + Asset const& asset, + AccountID const& from, + AccountID const& to, + WaiveMPTCanTransfer waive = WaiveMPTCanTransfer::No, + std::uint8_t depth = 0); //------------------------------------------------------------------------------ // diff --git a/include/xrpl/net/HTTPClient.h b/include/xrpl/net/HTTPClient.h index ea0c5d72cd..f059b19047 100644 --- a/include/xrpl/net/HTTPClient.h +++ b/include/xrpl/net/HTTPClient.h @@ -20,7 +20,7 @@ class HTTPClient public: explicit HTTPClient() = default; - static constexpr auto kMAX_CLIENT_HEADER_BYTES = kilobytes(32); + static constexpr auto kMaxClientHeaderBytes = kilobytes(32); static void initializeSSLContext( diff --git a/include/xrpl/net/HTTPClientSSLContext.h b/include/xrpl/net/HTTPClientSSLContext.h index d1744bbce4..ca1983f141 100644 --- a/include/xrpl/net/HTTPClientSSLContext.h +++ b/include/xrpl/net/HTTPClientSSLContext.h @@ -21,13 +21,13 @@ public: bool sslVerify, beast::Journal j, boost::asio::ssl::context_base::method method = boost::asio::ssl::context::sslv23) - : ssl_context_{method}, j_(j), verify_{sslVerify} + : sslContext_{method}, j_(j), verify_{sslVerify} { boost::system::error_code ec; if (sslVerifyFile.empty()) { - registerSSLCerts(ssl_context_, ec, j_); + registerSSLCerts(sslContext_, ec, j_); if (ec && sslVerifyDir.empty()) { @@ -37,12 +37,12 @@ public: } else { - ssl_context_.load_verify_file(sslVerifyFile); + sslContext_.load_verify_file(sslVerifyFile); } if (!sslVerifyDir.empty()) { - ssl_context_.add_verify_path(sslVerifyDir, ec); + sslContext_.add_verify_path(sslVerifyDir, ec); if (ec) { @@ -55,7 +55,7 @@ public: boost::asio::ssl::context& context() { - return ssl_context_; + return sslContext_; } [[nodiscard]] bool @@ -153,7 +153,7 @@ public: } private: - boost::asio::ssl::context ssl_context_; + boost::asio::ssl::context sslContext_; beast::Journal const j_; bool const verify_; }; diff --git a/include/xrpl/nodestore/Backend.h b/include/xrpl/nodestore/Backend.h index 124cd99db5..0061890237 100644 --- a/include/xrpl/nodestore/Backend.h +++ b/include/xrpl/nodestore/Backend.h @@ -83,10 +83,6 @@ public: virtual Status fetch(uint256 const& hash, std::shared_ptr* pObject) = 0; - /** Fetch a batch synchronously. */ - virtual std::pair>, Status> - fetchBatch(std::vector const& hashes) = 0; - /** Store a single object. Depending on the implementation this may happen immediately or deferred using a scheduled task. diff --git a/include/xrpl/nodestore/NodeObject.h b/include/xrpl/nodestore/NodeObject.h index 2a216606c4..04ba391b2b 100644 --- a/include/xrpl/nodestore/NodeObject.h +++ b/include/xrpl/nodestore/NodeObject.h @@ -29,7 +29,7 @@ enum class NodeObjectType : std::uint32_t { class NodeObject : public CountedObject { public: - static constexpr std::size_t kKEY_BYTES = 32; + static constexpr std::size_t kKeyBytes = 32; private: // This hack is used to make the constructor effectively private diff --git a/include/xrpl/nodestore/Types.h b/include/xrpl/nodestore/Types.h index 2b5d9ac770..21c01e9111 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 kBatchWritePreallocationSize = 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 kBatchWriteLimitSize = 65536; /** Return codes from Backend operations. */ enum class Status { diff --git a/include/xrpl/nodestore/detail/DatabaseNodeImp.h b/include/xrpl/nodestore/detail/DatabaseNodeImp.h index add66c51a7..dd94b27075 100644 --- a/include/xrpl/nodestore/detail/DatabaseNodeImp.h +++ b/include/xrpl/nodestore/detail/DatabaseNodeImp.h @@ -67,9 +67,6 @@ public: backend_->sync(); } - std::vector> - fetchBatch(std::vector const& hashes); - void asyncFetch( uint256 const& hash, diff --git a/include/xrpl/nodestore/detail/codec.h b/include/xrpl/nodestore/detail/codec.h index 4dedc54902..49238fa34a 100644 --- a/include/xrpl/nodestore/detail/codec.h +++ b/include/xrpl/nodestore/detail/codec.h @@ -55,7 +55,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf) using std::runtime_error; using namespace nudb::detail; std::pair result; - std::array::kMAX> vi{}; + std::array::kMax> vi{}; auto const n = writeVarint(vi.data(), inSize); auto const outMax = LZ4_compressBound(inSize); std::uint8_t* out = reinterpret_cast(bf(n + outMax)); @@ -254,12 +254,12 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf) } } - std::array::kMAX> vi{}; + std::array::kMax> vi{}; - constexpr std::size_t kCODEC_TYPE = 1; - auto const vn = writeVarint(vi.data(), kCODEC_TYPE); + static constexpr std::size_t kCodecType = 1; + auto const vn = writeVarint(vi.data(), kCodecType); std::pair result; - switch (kCODEC_TYPE) + switch (kCodecType) { // case 0 was uncompressed data; we always compress now. case 1: // lz4 @@ -275,7 +275,7 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf) break; } default: - Throw("nodeobject codec: unknown=" + std::to_string(kCODEC_TYPE)); + Throw("nodeobject codec: unknown=" + std::to_string(kCodecType)); }; return result; } diff --git a/include/xrpl/nodestore/detail/varint.h b/include/xrpl/nodestore/detail/varint.h index c98b36e322..e6b78fcf08 100644 --- a/include/xrpl/nodestore/detail/varint.h +++ b/include/xrpl/nodestore/detail/varint.h @@ -25,7 +25,7 @@ struct varint_traits { explicit varint_traits() = default; - static std::size_t constexpr kMAX = (8 * sizeof(T) + 6) / 7; + static constexpr std::size_t kMax = (8 * sizeof(T) + 6) / 7; }; // Returns: Number of bytes consumed or 0 on error, diff --git a/include/xrpl/protocol/AMMCore.h b/include/xrpl/protocol/AMMCore.h index eb6bae9b37..a83c8bfa84 100644 --- a/include/xrpl/protocol/AMMCore.h +++ b/include/xrpl/protocol/AMMCore.h @@ -8,21 +8,21 @@ namespace xrpl { -std::uint16_t constexpr kTRADING_FEE_THRESHOLD = 1000; // 1% +constexpr std::uint16_t kTradingFeeThreshold = 1000; // 1% // Auction slot -std::uint32_t constexpr kTOTAL_TIME_SLOT_SECS = 24 * 3600; -std::uint16_t constexpr kAUCTION_SLOT_TIME_INTERVALS = 20; -std::uint16_t constexpr kAUCTION_SLOT_MAX_AUTH_ACCOUNTS = 4; -std::uint32_t constexpr kAUCTION_SLOT_FEE_SCALE_FACTOR = 100000; -std::uint32_t constexpr kAUCTION_SLOT_DISCOUNTED_FEE_FRACTION = 10; -std::uint32_t constexpr kAUCTION_SLOT_MIN_FEE_FRACTION = 25; -std::uint32_t constexpr kAUCTION_SLOT_INTERVAL_DURATION = - kTOTAL_TIME_SLOT_SECS / kAUCTION_SLOT_TIME_INTERVALS; +constexpr std::uint32_t kTotalTimeSlotSecs = 24 * 3600; +constexpr std::uint16_t kAuctionSlotTimeIntervals = 20; +constexpr std::uint16_t kAuctionSlotMaxAuthAccounts = 4; +constexpr std::uint32_t kAuctionSlotFeeScaleFactor = 100000; +constexpr std::uint32_t kAuctionSlotDiscountedFeeFraction = 10; +constexpr std::uint32_t kAuctionSlotMinFeeFraction = 25; +constexpr std::uint32_t kAuctionSlotIntervalDuration = + kTotalTimeSlotSecs / kAuctionSlotTimeIntervals; // Votes -std::uint16_t constexpr kVOTE_MAX_SLOTS = 8; -std::uint32_t constexpr kVOTE_WEIGHT_SCALE_FACTOR = 100000; +constexpr std::uint16_t kVoteMaxSlots = 8; +constexpr std::uint32_t kVoteWeightScaleFactor = 100000; class STObject; class STAmount; @@ -77,7 +77,7 @@ ammEnabled(Rules const&); inline Number getFee(std::uint16_t tfee) { - return Number{tfee} / kAUCTION_SLOT_FEE_SCALE_FACTOR; + return Number{tfee} / kAuctionSlotFeeScaleFactor; } /** Get fee multiplier (1 - tfee) diff --git a/include/xrpl/protocol/AccountID.h b/include/xrpl/protocol/AccountID.h index e22c3b8edd..4938812ffa 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 @@ -69,7 +69,7 @@ toIssuer(AccountID&, std::string const&); inline bool isXRP(AccountID const& c) { - return c == beast::kZERO; + return c == beast::kZero; } // DEPRECATED diff --git a/include/xrpl/protocol/AmountConversions.h b/include/xrpl/protocol/AmountConversions.h index 53b7dace3c..a5f7ec310f 100644 --- a/include/xrpl/protocol/AmountConversions.h +++ b/include/xrpl/protocol/AmountConversions.h @@ -96,9 +96,9 @@ inline MPTAmount toAmount(STAmount const& amt) { XRPL_ASSERT( - amt.holds() && amt.mantissa() <= kMAX_MP_TOKEN_AMOUNT && amt.exponent() == 0, + amt.holds() && amt.mantissa() <= kMaxMpTokenAmount && amt.exponent() == 0, "xrpl::toAmount : maximum mantissa"); - if (amt.mantissa() > kMAX_MP_TOKEN_AMOUNT || amt.exponent() != 0) + if (amt.mantissa() > kMaxMpTokenAmount || amt.exponent() != 0) Throw("toAmount: invalid mantissa or exponent"); bool const isNeg = amt.negative(); std::int64_t const sMant = isNeg ? -std::int64_t(amt.mantissa()) : amt.mantissa(); @@ -167,8 +167,8 @@ toAmount(Asset const& asset, Number const& n, Number::RoundingMode mode = Number } else { - constexpr bool kALWAYS_FALSE = !std::is_same_v; - static_assert(kALWAYS_FALSE, "Unsupported type for toAmount"); + static constexpr bool kAlwaysFalse = !std::is_same_v; + static_assert(kAlwaysFalse, "Unsupported type for toAmount"); } } @@ -178,30 +178,30 @@ toMaxAmount(Asset const& asset) { if constexpr (std::is_same_v) { - return IOUAmount(STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET); + return IOUAmount(STAmount::kMaxValue, STAmount::kMaxOffset); } else if constexpr (std::is_same_v) { - return XRPAmount(static_cast(STAmount::kMAX_NATIVE_N)); + return XRPAmount(static_cast(STAmount::kMaxNativeN)); } else if constexpr (std::is_same_v) { - return MPTAmount(kMAX_MP_TOKEN_AMOUNT); + return MPTAmount(kMaxMpTokenAmount); } else if constexpr (std::is_same_v) { return asset.visit( [](Issue const& issue) { if (isXRP(issue)) - return STAmount(issue, static_cast(STAmount::kMAX_NATIVE_N)); - return STAmount(issue, STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET); + return STAmount(issue, static_cast(STAmount::kMaxNativeN)); + return STAmount(issue, STAmount::kMaxValue, STAmount::kMaxOffset); }, - [](MPTIssue const& issue) { return STAmount(issue, kMAX_MP_TOKEN_AMOUNT); }); + [](MPTIssue const& issue) { return STAmount(issue, kMaxMpTokenAmount); }); } else { - constexpr bool kALWAYS_FALSE = !std::is_same_v; - static_assert(kALWAYS_FALSE, "Unsupported type for toMaxAmount"); + static constexpr bool kAlwaysFalse = !std::is_same_v; + static_assert(kAlwaysFalse, "Unsupported type for toMaxAmount"); } } @@ -233,8 +233,8 @@ getAsset(T const& amt) } else { - constexpr bool kALWAYS_FALSE = !std::is_same_v; - static_assert(kALWAYS_FALSE, "Unsupported type for getIssue"); + static constexpr bool kAlwaysFalse = !std::is_same_v; + static_assert(kAlwaysFalse, "Unsupported type for getIssue"); } } @@ -260,8 +260,8 @@ get(STAmount const& a) } else { - constexpr bool kALWAYS_FALSE = !std::is_same_v; - static_assert(kALWAYS_FALSE, "Unsupported type for get"); + constexpr bool kAlwaysFalse = !std::is_same_v; + static_assert(kAlwaysFalse, "Unsupported type for get"); } } diff --git a/include/xrpl/protocol/ApiVersion.h b/include/xrpl/protocol/ApiVersion.h index 3399152363..345049b377 100644 --- a/include/xrpl/protocol/ApiVersion.h +++ b/include/xrpl/protocol/ApiVersion.h @@ -35,49 +35,49 @@ namespace xrpl { namespace RPC { template -constexpr static std::integral_constant kAPI_VERSION = {}; +static constexpr std::integral_constant kApiVersion = {}; -constexpr static auto kAPI_INVALID_VERSION = kAPI_VERSION<0>; -constexpr static auto kAPI_MINIMUM_SUPPORTED_VERSION = kAPI_VERSION<1>; -constexpr static auto kAPI_MAXIMUM_SUPPORTED_VERSION = kAPI_VERSION<2>; -constexpr static auto kAPI_VERSION_IF_UNSPECIFIED = kAPI_VERSION<1>; -constexpr static auto kAPI_COMMAND_LINE_VERSION = kAPI_VERSION<1>; // TODO Bump to 2 later -constexpr static auto kAPI_BETA_VERSION = kAPI_VERSION<3>; -constexpr static auto kAPI_MAXIMUM_VALID_VERSION = kAPI_BETA_VERSION; +static constexpr auto kApiInvalidVersion = kApiVersion<0>; +static constexpr auto kApiMinimumSupportedVersion = kApiVersion<1>; +static constexpr auto kApiMaximumSupportedVersion = kApiVersion<2>; +static constexpr auto kApiVersionIfUnspecified = kApiVersion<1>; +static constexpr auto kApiCommandLineVersion = kApiVersion<1>; // TODO Bump to 2 later +static constexpr auto kApiBetaVersion = kApiVersion<3>; +static constexpr auto kApiMaximumValidVersion = kApiBetaVersion; -static_assert(kAPI_INVALID_VERSION < kAPI_MINIMUM_SUPPORTED_VERSION); +static_assert(kApiInvalidVersion < kApiMinimumSupportedVersion); static_assert( - kAPI_VERSION_IF_UNSPECIFIED >= kAPI_MINIMUM_SUPPORTED_VERSION && - kAPI_VERSION_IF_UNSPECIFIED <= kAPI_MAXIMUM_SUPPORTED_VERSION); + kApiVersionIfUnspecified >= kApiMinimumSupportedVersion && + kApiVersionIfUnspecified <= kApiMaximumSupportedVersion); static_assert( - kAPI_COMMAND_LINE_VERSION >= kAPI_MINIMUM_SUPPORTED_VERSION && - kAPI_COMMAND_LINE_VERSION <= kAPI_MAXIMUM_SUPPORTED_VERSION); -static_assert(kAPI_MAXIMUM_SUPPORTED_VERSION >= kAPI_MINIMUM_SUPPORTED_VERSION); -static_assert(kAPI_BETA_VERSION >= kAPI_MAXIMUM_SUPPORTED_VERSION); -static_assert(kAPI_MAXIMUM_VALID_VERSION >= kAPI_MAXIMUM_SUPPORTED_VERSION); + kApiCommandLineVersion >= kApiMinimumSupportedVersion && + kApiCommandLineVersion <= kApiMaximumSupportedVersion); +static_assert(kApiMaximumSupportedVersion >= kApiMinimumSupportedVersion); +static_assert(kApiBetaVersion >= kApiMaximumSupportedVersion); +static_assert(kApiMaximumValidVersion >= kApiMaximumSupportedVersion); inline void setVersion(json::Value& parent, unsigned int apiVersion, bool betaEnabled) { - XRPL_ASSERT(apiVersion != kAPI_INVALID_VERSION, "xrpl::RPC::setVersion : input is valid"); + XRPL_ASSERT(apiVersion != kApiInvalidVersion, "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) + if (apiVersion == kApiVersionIfUnspecified) { // API version numbers used in API version 1 - static beast::SemanticVersion const kFIRST_VERSION{"1.0.0"}; - static beast::SemanticVersion const kGOOD_VERSION{"1.0.0"}; - static beast::SemanticVersion const kLAST_VERSION{"1.0.0"}; + static beast::SemanticVersion const kFirstVersion{"1.0.0"}; + static beast::SemanticVersion const kGoodVersion{"1.0.0"}; + static beast::SemanticVersion const kLastVersion{"1.0.0"}; - retObj[jss::first] = kFIRST_VERSION.print(); - retObj[jss::good] = kGOOD_VERSION.print(); - retObj[jss::last] = kLAST_VERSION.print(); + retObj[jss::first] = kFirstVersion.print(); + retObj[jss::good] = kGoodVersion.print(); + retObj[jss::last] = kLastVersion.print(); } else { - retObj[jss::first] = kAPI_MINIMUM_SUPPORTED_VERSION.value; - retObj[jss::last] = betaEnabled ? kAPI_BETA_VERSION : kAPI_MAXIMUM_SUPPORTED_VERSION; + retObj[jss::first] = kApiMinimumSupportedVersion.value; + retObj[jss::last] = betaEnabled ? kApiBetaVersion : kApiMaximumSupportedVersion; } } @@ -98,9 +98,9 @@ setVersion(json::Value& parent, unsigned int apiVersion, bool betaEnabled) inline unsigned int getAPIVersionNumber(json::Value const& jv, bool betaEnabled) { - static json::Value const kMIN_VERSION(RPC::kAPI_MINIMUM_SUPPORTED_VERSION); + static json::Value const kMinVersion(RPC::kApiMinimumSupportedVersion); json::Value const maxVersion( - betaEnabled ? RPC::kAPI_BETA_VERSION : RPC::kAPI_MAXIMUM_SUPPORTED_VERSION); + betaEnabled ? RPC::kApiBetaVersion : RPC::kApiMaximumSupportedVersion); if (jv.isObject()) { @@ -109,18 +109,18 @@ getAPIVersionNumber(json::Value const& jv, bool betaEnabled) auto const specifiedVersion = jv[jss::api_version]; if (!specifiedVersion.isInt() && !specifiedVersion.isUInt()) { - return RPC::kAPI_INVALID_VERSION; + return RPC::kApiInvalidVersion; } auto const specifiedVersionInt = specifiedVersion.asInt(); - if (specifiedVersionInt < kMIN_VERSION || specifiedVersionInt > maxVersion) + if (specifiedVersionInt < kMinVersion || specifiedVersionInt > maxVersion) { - return RPC::kAPI_INVALID_VERSION; + return RPC::kApiInvalidVersion; } return specifiedVersionInt; } } - return RPC::kAPI_VERSION_IF_UNSPECIFIED; + return RPC::kApiVersionIfUnspecified; } } // namespace RPC @@ -128,33 +128,33 @@ getAPIVersionNumber(json::Value const& jv, bool betaEnabled) template void forApiVersions(Fn const& fn, Args&&... args) - requires // - (MaxVer >= MinVer) && // - (MinVer >= RPC::kAPI_MINIMUM_SUPPORTED_VERSION) && // - (RPC::kAPI_MAXIMUM_VALID_VERSION >= MaxVer) && requires { + requires // + (MaxVer >= MinVer) && // + (MinVer >= RPC::kApiMinimumSupportedVersion) && // + (RPC::kApiMaximumValidVersion >= MaxVer) && requires { fn(std::integral_constant{}, std::forward(args)...); fn(std::integral_constant{}, std::forward(args)...); } { - constexpr auto kSIZE = MaxVer + 1 - MinVer; + static constexpr auto kSize = MaxVer + 1 - MinVer; [&](std::index_sequence) { // NOLINTBEGIN(bugprone-use-after-move) (((void)fn( std::integral_constant{}, std::forward(args)...)), ...); // NOLINTEND(bugprone-use-after-move) - }(std::make_index_sequence{}); + }(std::make_index_sequence{}); } template void forAllApiVersions(Fn const& fn, Args&&... args) requires requires { - forApiVersions( + forApiVersions( fn, std::forward(args)...); } { - forApiVersions( + forApiVersions( fn, std::forward(args)...); } diff --git a/include/xrpl/protocol/Asset.h b/include/xrpl/protocol/Asset.h index e0f4aa08a2..ec9d8db02f 100644 --- a/include/xrpl/protocol/Asset.h +++ b/include/xrpl/protocol/Asset.h @@ -148,10 +148,10 @@ public: }; template -constexpr bool kIS_ISSUE_V = std::is_same_v; +constexpr bool kIsIssueV = std::is_same_v; template -constexpr bool kIS_MPTISSUE_V = std::is_same_v; +constexpr bool kIsMptissueV = std::is_same_v; inline json::Value toJson(Asset const& asset) @@ -242,7 +242,7 @@ operator<=>(Asset const& lhs, Asset const& rhs) { return std::weak_ordering(lhs <=> rhs); } - else if constexpr (kIS_ISSUE_V && kIS_MPTISSUE_V) + else if constexpr (kIsIssueV && kIsMptissueV) { return std::weak_ordering::greater; } diff --git a/include/xrpl/protocol/Book.h b/include/xrpl/protocol/Book.h index fc36abddc4..01dc40075b 100644 --- a/include/xrpl/protocol/Book.h +++ b/include/xrpl/protocol/Book.h @@ -140,8 +140,8 @@ private: using issue_hasher = std::hash; using mptissue_hasher = std::hash; - issue_hasher m_issue_hasher_; - mptissue_hasher m_mptissue_hasher_; + issue_hasher mIssueHasher_; + mptissue_hasher mMptissueHasher_; public: explicit hash() = default; @@ -151,11 +151,11 @@ public: { return asset.visit( [&](xrpl::Issue const& issue) { - value_type const result(m_issue_hasher_(issue)); + value_type const result(mIssueHasher_(issue)); return result; }, [&](xrpl::MPTIssue const& issue) { - value_type const result(m_mptissue_hasher_(issue)); + value_type const result(mMptissueHasher_(issue)); return result; }); } @@ -170,8 +170,8 @@ private: using asset_hasher = std::hash; using uint256_hasher = xrpl::uint256::hasher; - asset_hasher issue_hasher_; - uint256_hasher uint256_hasher_; + asset_hasher issueHasher_; + uint256_hasher uint256Hasher_; public: hash() = default; @@ -182,11 +182,11 @@ public: value_type operator()(argument_type const& value) const { - value_type result(issue_hasher_(value.in)); - boost::hash_combine(result, issue_hasher_(value.out)); + value_type result(issueHasher_(value.in)); + boost::hash_combine(result, issueHasher_(value.out)); if (value.domain) - boost::hash_combine(result, uint256_hasher_(*value.domain)); + boost::hash_combine(result, uint256Hasher_(*value.domain)); return result; } diff --git a/include/xrpl/protocol/ErrorCodes.h b/include/xrpl/protocol/ErrorCodes.h index a91adfc55a..f5e67fd572 100644 --- a/include/xrpl/protocol/ErrorCodes.h +++ b/include/xrpl/protocol/ErrorCodes.h @@ -172,24 +172,24 @@ struct ErrorInfo { // Default ctor needed to produce an empty std::array during constexpr eval. constexpr ErrorInfo() - : code(RpcUnknown), token("unknown"), message("An unknown error code."), http_status(200) + : code(RpcUnknown), token("unknown"), message("An unknown error code."), httpStatus(200) { } constexpr ErrorInfo(ErrorCodeI code, char const* token, char const* message) - : code(code), token(token), message(message), http_status(200) + : code(code), token(token), message(message), httpStatus(200) { } constexpr ErrorInfo(ErrorCodeI code, char const* token, char const* message, int httpStatus) - : code(code), token(token), message(message), http_status(httpStatus) + : code(code), token(token), message(message), httpStatus(httpStatus) { } ErrorCodeI code; json::StaticString token; json::StaticString message; - int http_status; + int httpStatus; }; /** Returns an ErrorInfo that reflects the error code. */ diff --git a/include/xrpl/protocol/Feature.h b/include/xrpl/protocol/Feature.h index 281e598bf7..5de8ca64a9 100644 --- a/include/xrpl/protocol/Feature.h +++ b/include/xrpl/protocol/Feature.h @@ -65,11 +65,11 @@ namespace xrpl { // Feature names must not exceed this length (in characters, excluding the null terminator). -static constexpr std::size_t kMAX_FEATURE_NAME_SIZE = 63; +static constexpr std::size_t kMaxFeatureNameSize = 63; // Reserve this exact feature-name length (in characters/bytes, excluding the null terminator) // so that a 32-byte uint256 (for example, in WASM or other interop contexts) can be used // as a compact, fixed-size feature selector without conflicting with human-readable names. -static constexpr std::size_t kRESERVED_FEATURE_NAME_SIZE = 32; +static constexpr std::size_t kReservedFeatureNameSize = 32; // Both validFeatureNameSize and validFeatureName are consteval functions that can be used in // static_asserts to validate feature names at compile time. They are only used inside @@ -81,14 +81,14 @@ validFeatureNameSize(auto fn) -> bool { constexpr char const* kN = fn(); // Note, std::strlen is not constexpr, we need to implement our own here. - constexpr std::size_t kLEN = [](auto n) { + constexpr std::size_t kLen = [](auto n) { std::size_t ret = 0; for (auto ptr = n; *ptr != '\0'; ret++, ++ptr) ; return ret; }(kN); - return kLEN != kRESERVED_FEATURE_NAME_SIZE && // - kLEN <= kMAX_FEATURE_NAME_SIZE; + return kLen != kReservedFeatureNameSize && // + kLen <= kMaxFeatureNameSize; } consteval auto @@ -136,7 +136,7 @@ namespace detail { // Feature.cpp. Because it's only used to reserve storage, and determine how // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than // the actual number of amendments. A LogicError on startup will verify this. -static constexpr std::size_t kNUM_FEATURES = +static constexpr std::size_t kNumFeatures = (0 + #include ); @@ -184,9 +184,9 @@ bitsetIndexToFeature(size_t i); std::string featureToName(uint256 const& f); -class FeatureBitset : private std::bitset +class FeatureBitset : private std::bitset { - using base = std::bitset; + using base = std::bitset; template void diff --git a/include/xrpl/protocol/Fees.h b/include/xrpl/protocol/Fees.h index c94ba31b8a..14bcc068bf 100644 --- a/include/xrpl/protocol/Fees.h +++ b/include/xrpl/protocol/Fees.h @@ -6,7 +6,7 @@ namespace xrpl { // Deprecated constant for backwards compatibility with pre-XRPFees amendment. // This was the reference fee units used in the old fee calculation. -inline constexpr std::uint32_t kFEE_UNITS_DEPRECATED = 10; +inline constexpr std::uint32_t kFeeUnitsDeprecated = 10; /** Reflects the fee settings for a particular ledger. diff --git a/include/xrpl/protocol/IOUAmount.h b/include/xrpl/protocol/IOUAmount.h index 9a5800d675..b057f1c245 100644 --- a/include/xrpl/protocol/IOUAmount.h +++ b/include/xrpl/protocol/IOUAmount.h @@ -91,7 +91,7 @@ public: inline IOUAmount::IOUAmount(beast::Zero) { - *this = beast::kZERO; + *this = beast::kZero; } inline IOUAmount::IOUAmount(mantissa_type mantissa, exponent_type exponent) diff --git a/include/xrpl/protocol/Indexes.h b/include/xrpl/protocol/Indexes.h index 14e7d95e23..887a208ec6 100644 --- a/include/xrpl/protocol/Indexes.h +++ b/include/xrpl/protocol/Indexes.h @@ -82,7 +82,7 @@ struct BookT Keylet operator()(Book const& b) const; }; -static BookT const kBOOK{}; +static BookT const kBook{}; /** The index of a trust line for a given currency @@ -126,7 +126,7 @@ struct NextT Keylet operator()(Keylet const& k) const; }; -static NextT const kNEXT{}; +static NextT const kNext{}; /** A ticket belonging to an account */ struct TicketT @@ -145,7 +145,7 @@ struct TicketT return {ltTICKET, key}; } }; -static TicketT const kTICKET{}; +static TicketT const kTicket{}; /** A SignerList */ Keylet @@ -373,7 +373,7 @@ struct KeyletDesc // This list should include all of the keylet functions that take a single // AccountID parameter. -std::array, 6> const kDIRECT_ACCOUNT_KEYLETS{ +std::array, 6> const kDirectAccountKeylets{ {{.function = &keylet::account, .expectedLEName = jss::AccountRoot, .includeInTests = false}, {.function = &keylet::ownerDir, .expectedLEName = jss::DirectoryNode, .includeInTests = true}, {.function = &keylet::signers, .expectedLEName = jss::SignerList, .includeInTests = true}, diff --git a/include/xrpl/protocol/Issue.h b/include/xrpl/protocol/Issue.h index 3b74b9132a..c8022698d3 100644 --- a/include/xrpl/protocol/Issue.h +++ b/include/xrpl/protocol/Issue.h @@ -96,16 +96,16 @@ operator<=>(Issue const& lhs, Issue const& rhs) inline Issue const& xrpIssue() { - static Issue const kISSUE{xrpCurrency(), xrpAccount()}; - return kISSUE; + static Issue const kIssue{xrpCurrency(), xrpAccount()}; + return kIssue; } /** Returns an asset specifier that represents no account and currency. */ inline Issue const& noIssue() { - static Issue const kISSUE{noCurrency(), noAccount()}; - return kISSUE; + static Issue const kIssue{noCurrency(), noAccount()}; + return kIssue; } inline bool diff --git a/include/xrpl/protocol/LedgerHeader.h b/include/xrpl/protocol/LedgerHeader.h index 68dd5e24b9..f05b11d1eb 100644 --- a/include/xrpl/protocol/LedgerHeader.h +++ b/include/xrpl/protocol/LedgerHeader.h @@ -26,12 +26,12 @@ struct LedgerHeader // // Closed means "tx set already determined" - uint256 hash = beast::kZERO; - uint256 txHash = beast::kZERO; - uint256 accountHash = beast::kZERO; - uint256 parentHash = beast::kZERO; + uint256 hash = beast::kZero; + uint256 txHash = beast::kZero; + uint256 accountHash = beast::kZero; + uint256 parentHash = beast::kZero; - XRPAmount drops = beast::kZERO; + XRPAmount drops = beast::kZero; // If validated is false, it means "not yet validated." // Once validated is true, it will never be set false at a later time. @@ -53,12 +53,12 @@ struct LedgerHeader }; // ledger close flags -static std::uint32_t const kS_LCF_NO_CONSENSUS_TIME = 0x01; +static std::uint32_t const kSLcfNoConsensusTime = 0x01; inline bool getCloseAgree(LedgerHeader const& info) { - return (info.closeFlags & kS_LCF_NO_CONSENSUS_TIME) == 0; + return (info.closeFlags & kSLcfNoConsensusTime) == 0; } void diff --git a/include/xrpl/protocol/MPTAmount.h b/include/xrpl/protocol/MPTAmount.h index b4907774d2..6ea36fc294 100644 --- a/include/xrpl/protocol/MPTAmount.h +++ b/include/xrpl/protocol/MPTAmount.h @@ -88,7 +88,7 @@ constexpr MPTAmount::MPTAmount(value_type value) : value_(value) constexpr MPTAmount::MPTAmount(beast::Zero) { - *this = beast::kZERO; + *this = beast::kZero; } constexpr MPTAmount& diff --git a/include/xrpl/protocol/MultiApiJson.h b/include/xrpl/protocol/MultiApiJson.h index 5a7dfcd731..9a4882ec55 100644 --- a/include/xrpl/protocol/MultiApiJson.h +++ b/include/xrpl/protocol/MultiApiJson.h @@ -15,14 +15,14 @@ namespace xrpl { namespace detail { template -constexpr bool kIS_INTEGRAL_CONSTANT = false; +constexpr bool kIsIntegralConstant = false; template -constexpr bool kIS_INTEGRAL_CONSTANT&> = true; +constexpr bool kIsIntegralConstant&> = true; template -constexpr bool kIS_INTEGRAL_CONSTANT const&> = true; +constexpr bool kIsIntegralConstant const&> = true; template -concept some_integral_constant = detail::kIS_INTEGRAL_CONSTANT; +concept some_integral_constant = detail::kIsIntegralConstant; // This class is designed to wrap a collection of _almost_ identical json::Value // objects, indexed by version (i.e. there is some mapping of version to object @@ -47,8 +47,8 @@ struct MultiApiJson return (v < MinVer) ? 0 : static_cast(v - MinVer); } - constexpr static std::size_t kSIZE = MaxVer + 1 - MinVer; - std::array val = {}; + static constexpr std::size_t kSize = MaxVer + 1 - MinVer; + std::array val = {}; explicit MultiApiJson(json::Value const& init = {}) { @@ -80,7 +80,7 @@ struct MultiApiJson if (count == 0) return IsMemberResult::None; - return count < kSIZE ? IsMemberResult::Some : IsMemberResult::All; + return count < kSize ? IsMemberResult::Some : IsMemberResult::All; } static constexpr struct VisitorT final @@ -100,7 +100,7 @@ struct MultiApiJson std::integral_constant, Args&&...> { - static_assert(valid(Version) && index(Version) >= 0 && index(Version) < kSIZE); + static_assert(valid(Version) && index(Version) >= 0 && index(Version) < kSize); return std::invoke(fn, json.val[index(Version)], version, std::forward(args)...); } @@ -111,7 +111,7 @@ struct MultiApiJson operator()(Json& json, std::integral_constant const, Fn fn) const -> std::invoke_result_t { - static_assert(valid(Version) && index(Version) >= 0 && index(Version) < kSIZE); + static_assert(valid(Version) && index(Version) >= 0 && index(Version) < kSize); return std::invoke(fn, json.val[index(Version)]); } @@ -124,7 +124,7 @@ struct MultiApiJson -> std::invoke_result_t { XRPL_ASSERT( - valid(version) && index(version) >= 0 && index(version) < kSIZE, + valid(version) && index(version) >= 0 && index(version) < kSize, "xrpl::detail::MultiApijson::operator() : valid " "version"); return std::invoke(fn, json.val[index(version)], version, std::forward(args)...); @@ -139,20 +139,20 @@ struct MultiApiJson -> std::invoke_result_t { XRPL_ASSERT( - valid(version) && index(version) >= 0 && index(version) < kSIZE, + valid(version) && index(version) >= 0 && index(version) < kSize, "xrpl::detail::MultiApijson::operator() : valid version"); return std::invoke(fn, json.val[index(version)]); } - } kVISITOR = {}; + } kVisitor = {}; auto visit() { return [self = this](auto... args) requires requires { - kVISITOR(std::declval(), std::declval()...); + kVisitor(std::declval(), std::declval()...); } - { return kVISITOR(*self, std::forward(args)...); }; + { return kVisitor(*self, std::forward(args)...); }; } [[nodiscard]] auto @@ -160,27 +160,27 @@ struct MultiApiJson { return [self = this](auto... args) requires requires { - kVISITOR(std::declval(), std::declval()...); + kVisitor(std::declval(), std::declval()...); } - { return kVISITOR(*self, std::forward(args)...); }; + { return kVisitor(*self, std::forward(args)...); }; } template auto visit(Args... args) -> std::invoke_result_t requires(sizeof...(args) > 0) && - requires { kVISITOR(*this, std::forward(args)...); } + requires { kVisitor(*this, std::forward(args)...); } { - return kVISITOR(*this, std::forward(args)...); + return kVisitor(*this, std::forward(args)...); } template [[nodiscard]] auto visit(Args... args) const -> std::invoke_result_t requires(sizeof...(args) > 0) && - requires { kVISITOR(*this, std::forward(args)...); } + requires { kVisitor(*this, std::forward(args)...); } { - return kVISITOR(*this, std::forward(args)...); + return kVisitor(*this, std::forward(args)...); } }; @@ -188,6 +188,6 @@ struct MultiApiJson // Wrapper for Json for all supported API versions. using MultiApiJson = - detail::MultiApiJson; + detail::MultiApiJson; } // namespace xrpl diff --git a/include/xrpl/protocol/PathAsset.h b/include/xrpl/protocol/PathAsset.h index 4c4a3f7af4..b51dc52b47 100644 --- a/include/xrpl/protocol/PathAsset.h +++ b/include/xrpl/protocol/PathAsset.h @@ -52,10 +52,10 @@ public: }; template -constexpr bool kIS_CURRENCY_V = std::is_same_v; +constexpr bool kIsCurrencyV = std::is_same_v; template -constexpr bool kIS_MPTID_V = std::is_same_v; +constexpr bool kIsMptidV = std::is_same_v; inline PathAsset::PathAsset(Asset const& asset) { diff --git a/include/xrpl/protocol/Protocol.h b/include/xrpl/protocol/Protocol.h index 50b2425016..6a96b2ccbe 100644 --- a/include/xrpl/protocol/Protocol.h +++ b/include/xrpl/protocol/Protocol.h @@ -19,40 +19,40 @@ namespace xrpl { @ingroup protocol */ /** Smallest legal byte size of a transaction. */ -std::size_t constexpr kTX_MIN_SIZE_BYTES = 32; +constexpr std::size_t kTxMinSizeBytes = 32; /** Largest legal byte size of a transaction. */ -std::size_t constexpr kTX_MAX_SIZE_BYTES = megabytes(1); +constexpr std::size_t kTxMaxSizeBytes = megabytes(1); /** The maximum number of unfunded offers to delete at once */ -std::size_t constexpr kUNFUNDED_OFFER_REMOVE_LIMIT = 1000; +constexpr std::size_t kUnfundedOfferRemoveLimit = 1000; /** The maximum number of expired offers to delete at once */ -std::size_t constexpr kEXPIRED_OFFER_REMOVE_LIMIT = 256; +constexpr std::size_t kExpiredOfferRemoveLimit = 256; /** The maximum number of metadata entries allowed in one transaction */ -std::size_t constexpr kOVERSIZE_META_DATA_CAP = 5200; +constexpr std::size_t kOversizeMetaDataCap = 5200; /** The maximum number of entries per directory page */ -std::size_t constexpr kDIR_NODE_MAX_ENTRIES = 32; +constexpr std::size_t kDirNodeMaxEntries = 32; /** The maximum number of pages allowed in a directory Made obsolete by fixDirectoryLimit amendment. */ -std::uint64_t constexpr kDIR_NODE_MAX_PAGES = 262144; +constexpr std::uint64_t kDirNodeMaxPages = 262144; /** The maximum number of items in an NFT page */ -std::size_t constexpr kDIR_MAX_TOKENS_PER_PAGE = 32; +constexpr std::size_t kDirMaxTokensPerPage = 32; /** The maximum number of owner directory entries for account to be deletable */ -std::size_t constexpr kMAX_DELETABLE_DIR_ENTRIES = 1000; +constexpr std::size_t kMaxDeletableDirEntries = 1000; /** The maximum number of token offers that can be canceled at once */ -std::size_t constexpr kMAX_TOKEN_OFFER_CANCEL_COUNT = 500; +constexpr std::size_t kMaxTokenOfferCancelCount = 500; /** The maximum number of offers in an offer directory for NFT to be burnable */ -std::size_t constexpr kMAX_DELETABLE_TOKEN_OFFER_ENTRIES = 500; +constexpr std::size_t kMaxDeletableTokenOfferEntries = 500; /** The maximum token transfer fee allowed. @@ -63,7 +63,7 @@ std::size_t constexpr kMAX_DELETABLE_TOKEN_OFFER_ENTRIES = 500; Note that for extremely low transfer fees values, it is possible that the calculated fee will be 0. */ -std::uint16_t constexpr kMAX_TRANSFER_FEE = 50000; +constexpr std::uint16_t kMaxTransferFee = 50000; /** There are 10,000 basis points (bips) in 100%. * @@ -81,32 +81,32 @@ std::uint16_t constexpr kMAX_TRANSFER_FEE = 50000; * * Example: 50% is 0.50 * bipsPerUnity = 5,000 bps. */ -Bips32 constexpr kBIPS_PER_UNITY(100 * 100); -static_assert(kBIPS_PER_UNITY == Bips32{10'000}); -TenthBips32 constexpr kTENTH_BIPS_PER_UNITY(kBIPS_PER_UNITY.value() * 10); -static_assert(kTENTH_BIPS_PER_UNITY == TenthBips32(100'000)); +constexpr Bips32 kBipsPerUnity(100 * 100); +static_assert(kBipsPerUnity == Bips32{10'000}); +constexpr TenthBips32 kTenthBipsPerUnity(kBipsPerUnity.value() * 10); +static_assert(kTenthBipsPerUnity == TenthBips32(100'000)); constexpr Bips32 percentageToBips(std::uint32_t percentage) { - return Bips32(percentage * kBIPS_PER_UNITY.value() / 100); + return Bips32(percentage * kBipsPerUnity.value() / 100); } constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage) { - return TenthBips32(percentage * kTENTH_BIPS_PER_UNITY.value() / 100); + return TenthBips32(percentage * kTenthBipsPerUnity.value() / 100); } template constexpr T bipsOfValue(T value, Bips bips) { - return value * bips.value() / kBIPS_PER_UNITY.value(); + return value * bips.value() / kBipsPerUnity.value(); } template constexpr T tenthBipsOfValue(T value, TenthBips bips) { - return value * bips.value() / kTENTH_BIPS_PER_UNITY.value(); + return value * bips.value() / kTenthBipsPerUnity.value(); } namespace Lending { @@ -114,54 +114,54 @@ namespace Lending { Valid values are between 0 and 10% inclusive. */ -TenthBips16 constexpr kMAX_MANAGEMENT_FEE_RATE( +constexpr TenthBips16 kMaxManagementFeeRate( unsafeCast(percentageToTenthBips(10).value())); -static_assert(kMAX_MANAGEMENT_FEE_RATE == TenthBips16(std::uint16_t(10'000u))); +static_assert(kMaxManagementFeeRate == TenthBips16(std::uint16_t(10'000u))); /** The maximum coverage rate required of a loan broker in 1/10 bips. Valid values are between 0 and 100% inclusive. */ -TenthBips32 constexpr kMAX_COVER_RATE = percentageToTenthBips(100); -static_assert(kMAX_COVER_RATE == TenthBips32(100'000u)); +constexpr TenthBips32 kMaxCoverRate = percentageToTenthBips(100); +static_assert(kMaxCoverRate == TenthBips32(100'000u)); /** The maximum overpayment fee on a loan in 1/10 bips. * Valid values are between 0 and 100% inclusive. */ -TenthBips32 constexpr kMAX_OVERPAYMENT_FEE = percentageToTenthBips(100); -static_assert(kMAX_OVERPAYMENT_FEE == TenthBips32(100'000u)); +constexpr TenthBips32 kMaxOverpaymentFee = percentageToTenthBips(100); +static_assert(kMaxOverpaymentFee == TenthBips32(100'000u)); /** Annualized interest rate of the Loan in 1/10 bips. * * Valid values are between 0 and 100% inclusive. */ -TenthBips32 constexpr kMAX_INTEREST_RATE = percentageToTenthBips(100); -static_assert(kMAX_INTEREST_RATE == TenthBips32(100'000u)); +constexpr TenthBips32 kMaxInterestRate = percentageToTenthBips(100); +static_assert(kMaxInterestRate == TenthBips32(100'000u)); /** The maximum premium added to the interest rate for late payments on a loan * in 1/10 bips. * * Valid values are between 0 and 100% inclusive. */ -TenthBips32 constexpr kMAX_LATE_INTEREST_RATE = percentageToTenthBips(100); -static_assert(kMAX_LATE_INTEREST_RATE == TenthBips32(100'000u)); +constexpr TenthBips32 kMaxLateInterestRate = percentageToTenthBips(100); +static_assert(kMaxLateInterestRate == TenthBips32(100'000u)); /** The maximum close interest rate charged for repaying a loan early in 1/10 * bips. * * Valid values are between 0 and 100% inclusive. */ -TenthBips32 constexpr kMAX_CLOSE_INTEREST_RATE = percentageToTenthBips(100); -static_assert(kMAX_CLOSE_INTEREST_RATE == TenthBips32(100'000u)); +constexpr TenthBips32 kMaxCloseInterestRate = percentageToTenthBips(100); +static_assert(kMaxCloseInterestRate == TenthBips32(100'000u)); /** The maximum overpayment interest rate charged on loan overpayments in 1/10 * bips. * * Valid values are between 0 and 100% inclusive. */ -TenthBips32 constexpr kMAX_OVERPAYMENT_INTEREST_RATE = percentageToTenthBips(100); -static_assert(kMAX_OVERPAYMENT_INTEREST_RATE == TenthBips32(100'000u)); +constexpr TenthBips32 kMaxOverpaymentInterestRate = percentageToTenthBips(100); +static_assert(kMaxOverpaymentInterestRate == TenthBips32(100'000u)); /** LoanPay transaction cost will be one base fee per X combined payments * @@ -172,7 +172,7 @@ static_assert(kMAX_OVERPAYMENT_INTEREST_RATE == TenthBips32(100'000u)); * This number was chosen arbitrarily, but should not be changed once released * without an amendment */ -static constexpr int kLOAN_PAYMENTS_PER_FEE_INCREMENT = 5; +static constexpr int kLoanPaymentsPerFeeIncrement = 5; /** Maximum number of combined payments that a LoanPay transaction will process * @@ -196,65 +196,65 @@ static constexpr int kLOAN_PAYMENTS_PER_FEE_INCREMENT = 5; * This number was chosen arbitrarily, but should not be changed once released * without an amendment */ -static constexpr int kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION = 100; +static constexpr int kLoanMaximumPaymentsPerTransaction = 100; } // namespace Lending /** The maximum length of a URI inside an NFT */ -std::size_t constexpr kMAX_TOKEN_URI_LENGTH = 256; +constexpr std::size_t kMaxTokenUriLength = 256; /** The maximum length of a Data element inside a DID */ -std::size_t constexpr kMAX_DID_DOCUMENT_LENGTH = 256; +constexpr std::size_t kMaxDidDocumentLength = 256; /** The maximum length of a URI inside a DID */ -std::size_t constexpr kMAX_DIDURI_LENGTH = 256; +constexpr std::size_t kMaxDidUriLength = 256; /** The maximum length of an Attestation inside a DID */ -std::size_t constexpr kMAX_DID_DATA_LENGTH = 256; +constexpr std::size_t kMaxDidDataLength = 256; /** The maximum length of a domain */ -std::size_t constexpr kMAX_DOMAIN_LENGTH = 256; +constexpr std::size_t kMaxDomainLength = 256; /** The maximum length of a URI inside a Credential */ -std::size_t constexpr kMAX_CREDENTIAL_URI_LENGTH = 256; +constexpr std::size_t kMaxCredentialUriLength = 256; /** The maximum length of a CredentialType inside a Credential */ -std::size_t constexpr kMAX_CREDENTIAL_TYPE_LENGTH = 64; +constexpr std::size_t kMaxCredentialTypeLength = 64; /** The maximum number of credentials can be passed in array */ -std::size_t constexpr kMAX_CREDENTIALS_ARRAY_SIZE = 8; +constexpr std::size_t kMaxCredentialsArraySize = 8; /** The maximum number of credentials can be passed in array for permissioned * domain */ -std::size_t constexpr kMAX_PERMISSIONED_DOMAIN_CREDENTIALS_ARRAY_SIZE = 10; +constexpr std::size_t kMaxPermissionedDomainCredentialsArraySize = 10; /** The maximum length of MPTokenMetadata */ -std::size_t constexpr kMAX_MP_TOKEN_METADATA_LENGTH = 1024; +constexpr std::size_t kMaxMpTokenMetadataLength = 1024; /** The maximum amount of MPTokenIssuance */ -std::uint64_t constexpr kMAX_MP_TOKEN_AMOUNT = 0x7FFF'FFFF'FFFF'FFFFull; -static_assert(Number::kMAX_REP >= kMAX_MP_TOKEN_AMOUNT); +constexpr std::uint64_t kMaxMpTokenAmount = 0x7FFF'FFFF'FFFF'FFFFull; +static_assert(Number::kMaxRep >= kMaxMpTokenAmount); /** The maximum length of Data payload */ -std::size_t constexpr kMAX_DATA_PAYLOAD_LENGTH = 256; +constexpr std::size_t kMaxDataPayloadLength = 256; /** Vault withdrawal policies */ -std::uint8_t constexpr kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE = 1; +constexpr std::uint8_t kVaultStrategyFirstComeFirstServe = 1; /** Default IOU scale factor for a Vault */ -std::uint8_t constexpr kVAULT_DEFAULT_IOU_SCALE = 6; +constexpr std::uint8_t kVaultDefaultIouScale = 6; /** Maximum scale factor for a Vault. The number is chosen to ensure that 1 IOU can be always converted to shares. 10^19 > maxMPTokenAmount (2^64-1) > 10^18 */ -std::uint8_t constexpr kVAULT_MAXIMUM_IOU_SCALE = 18; +constexpr std::uint8_t kVaultMaximumIouScale = 18; /** Maximum recursion depth for vault shares being put as an asset inside * another vault; counted from 0 */ -std::uint8_t constexpr kMAX_ASSET_CHECK_DEPTH = 5; +constexpr std::uint8_t kMaxAssetCheckDepth = 5; /** A ledger index. */ using LedgerIndex = std::uint32_t; -std::uint32_t constexpr kFLAG_LEDGER_INTERVAL = 256; +constexpr std::uint32_t kFlagLedgerInterval = 256; /** Returns true if the given ledgerIndex is a voting ledgerIndex */ bool @@ -273,38 +273,38 @@ using TxID = uint256; /** The maximum number of trustlines to delete as part of AMM account * deletion cleanup. */ -std::uint16_t constexpr kMAX_DELETABLE_AMM_TRUST_LINES = 512; +constexpr std::uint16_t kMaxDeletableAmmTrustLines = 512; /** The maximum length of a URI inside an Oracle */ -std::size_t constexpr kMAX_ORACLE_URI = 256; +constexpr std::size_t kMaxOracleUri = 256; /** The maximum length of a Provider inside an Oracle */ -std::size_t constexpr kMAX_ORACLE_PROVIDER = 256; +constexpr std::size_t kMaxOracleProvider = 256; /** The maximum size of a data series array inside an Oracle */ -std::size_t constexpr kMAX_ORACLE_DATA_SERIES = 10; +constexpr std::size_t kMaxOracleDataSeries = 10; /** The maximum length of a SymbolClass inside an Oracle */ -std::size_t constexpr kMAX_ORACLE_SYMBOL_CLASS = 16; +constexpr std::size_t kMaxOracleSymbolClass = 16; /** The maximum allowed time difference between lastUpdateTime and the time of the last closed ledger */ -std::size_t constexpr kMAX_LAST_UPDATE_TIME_DELTA = 300; +constexpr std::size_t kMaxLastUpdateTimeDelta = 300; /** The maximum price scaling factor */ -std::size_t constexpr kMAX_PRICE_SCALE = 20; +constexpr std::size_t kMaxPriceScale = 20; /** The maximum percentage of outliers to trim */ -std::size_t constexpr kMAX_TRIM = 25; +constexpr std::size_t kMaxTrim = 25; /** The maximum number of delegate permissions an account can grant */ -std::size_t constexpr kPERMISSION_MAX_SIZE = 10; +constexpr std::size_t kPermissionMaxSize = 10; /** The maximum number of transactions that can be in a batch. */ -std::size_t constexpr kMAX_BATCH_TX_COUNT = 8; +constexpr std::size_t kMaxBatchTxCount = 8; } // namespace xrpl diff --git a/include/xrpl/protocol/PublicKey.h b/include/xrpl/protocol/PublicKey.h index 75b898a71c..20693160d3 100644 --- a/include/xrpl/protocol/PublicKey.h +++ b/include/xrpl/protocol/PublicKey.h @@ -43,8 +43,8 @@ class PublicKey protected: // All the constructed public keys are valid, non-empty and contain 33 // bytes of data. - static constexpr std::size_t kSIZE = 33; - std::uint8_t buf_[kSIZE]{}; // should be large enough + static constexpr std::size_t kSize = 33; + std::uint8_t buf_[kSize]{}; // should be large enough public: using const_iterator = std::uint8_t const*; @@ -72,7 +72,7 @@ public: static std::size_t size() noexcept { - return kSIZE; + return kSize; } [[nodiscard]] const_iterator @@ -90,19 +90,19 @@ public: [[nodiscard]] const_iterator end() const noexcept { - return buf_ + kSIZE; + return buf_ + kSize; } [[nodiscard]] const_iterator cend() const noexcept { - return buf_ + kSIZE; + return buf_ + kSize; } [[nodiscard]] Slice slice() const noexcept { - return {buf_, kSIZE}; + return {buf_, kSize}; } operator Slice() const noexcept @@ -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/Quality.h b/include/xrpl/protocol/Quality.h index 115e4498df..e261025cb8 100644 --- a/include/xrpl/protocol/Quality.h +++ b/include/xrpl/protocol/Quality.h @@ -26,7 +26,7 @@ struct TAmounts { TAmounts() = default; - TAmounts(beast::Zero, beast::Zero) : in(beast::kZERO), out(beast::kZERO) + TAmounts(beast::Zero, beast::Zero) : in(beast::kZero), out(beast::kZero) { } @@ -38,7 +38,7 @@ struct TAmounts [[nodiscard]] bool empty() const noexcept { - return in <= beast::kZERO || out <= beast::kZERO; + return in <= beast::kZero || out <= beast::kZero; } TAmounts& @@ -94,8 +94,8 @@ public: // have lower unsigned integer representations. using value_type = std::uint64_t; - static int const kMIN_TICK_SIZE = 3; - static int const kMAX_TICK_SIZE = 16; + static int const kMinTickSize = 3; + static int const kMaxTickSize = 16; private: // This has the same representation as STAmount, see the comment on the @@ -316,10 +316,10 @@ TAmounts Quality::ceilIn(TAmounts const& amount, In const& limit) const { // Construct a function pointer to the function we want to call. - static constexpr Amounts (Quality::*kCEIL_IN_FN_PTR)(Amounts const&, STAmount const&) const = + static constexpr Amounts (Quality::*kCeilInFnPtr)(Amounts const&, STAmount const&) const = &Quality::ceilIn; - return ceilTAmountsHelper(amount, limit, amount.in, kCEIL_IN_FN_PTR); + return ceilTAmountsHelper(amount, limit, amount.in, kCeilInFnPtr); } template @@ -327,10 +327,10 @@ TAmounts Quality::ceilInStrict(TAmounts const& amount, In const& limit, bool roundUp) const { // Construct a function pointer to the function we want to call. - static constexpr Amounts (Quality::*kCEIL_IN_FN_PTR)(Amounts const&, STAmount const&, bool) - const = &Quality::ceilInStrict; + static constexpr Amounts (Quality::*kCeilInFnPtr)(Amounts const&, STAmount const&, bool) const = + &Quality::ceilInStrict; - return ceilTAmountsHelper(amount, limit, amount.in, kCEIL_IN_FN_PTR, roundUp); + return ceilTAmountsHelper(amount, limit, amount.in, kCeilInFnPtr, roundUp); } template @@ -338,10 +338,10 @@ TAmounts Quality::ceilOut(TAmounts const& amount, Out const& limit) const { // Construct a function pointer to the function we want to call. - static constexpr Amounts (Quality::*kCEIL_OUT_FN_PTR)(Amounts const&, STAmount const&) const = + static constexpr Amounts (Quality::*kCeilOutFnPtr)(Amounts const&, STAmount const&) const = &Quality::ceilOut; - return ceil_TAmounts_helper(amount, limit, amount.out, kCEIL_OUT_FN_PTR); + return ceil_TAmounts_helper(amount, limit, amount.out, kCeilOutFnPtr); } template @@ -349,10 +349,10 @@ TAmounts Quality::ceilOutStrict(TAmounts const& amount, Out const& limit, bool roundUp) const { // Construct a function pointer to the function we want to call. - static constexpr Amounts (Quality::*kCEIL_OUT_FN_PTR)(Amounts const&, STAmount const&, bool) + static constexpr Amounts (Quality::*kCeilOutFnPtr)(Amounts const&, STAmount const&, bool) const = &Quality::ceilOutStrict; - return ceilTAmountsHelper(amount, limit, amount.out, kCEIL_OUT_FN_PTR, roundUp); + return ceilTAmountsHelper(amount, limit, amount.out, kCeilOutFnPtr, roundUp); } /** Calculate the quality of a two-hop path given the two hops. diff --git a/include/xrpl/protocol/QualityFunction.h b/include/xrpl/protocol/QualityFunction.h index f7f92e50da..96d30735b8 100644 --- a/include/xrpl/protocol/QualityFunction.h +++ b/include/xrpl/protocol/QualityFunction.h @@ -72,7 +72,7 @@ QualityFunction::QualityFunction( std::uint32_t tfee, QualityFunction::AMMTag) { - if (amounts.in <= beast::kZERO || amounts.out <= beast::kZERO) + if (amounts.in <= beast::kZero || amounts.out <= beast::kZero) Throw("QualityFunction amounts are 0."); Number const cfee = feeMult(tfee); m_ = -cfee / amounts.in; diff --git a/include/xrpl/protocol/Rate.h b/include/xrpl/protocol/Rate.h index 5dcd62a295..504b17ed80 100644 --- a/include/xrpl/protocol/Rate.h +++ b/include/xrpl/protocol/Rate.h @@ -72,6 +72,6 @@ transferFeeAsRate(std::uint16_t fee); } // namespace nft /** A transfer rate signifying a 1:1 exchange */ -extern Rate const kPARITY_RATE; +extern Rate const kParityRate; } // namespace xrpl diff --git a/include/xrpl/protocol/SField.h b/include/xrpl/protocol/SField.h index 45e4d8932e..34fb66ce00 100644 --- a/include/xrpl/protocol/SField.h +++ b/include/xrpl/protocol/SField.h @@ -92,7 +92,7 @@ class STCurrency; // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) enum SerializedTypeID { XMACRO(TO_ENUM) }; -static std::map const kS_TYPE_MAP = {XMACRO(TO_MAP)}; +static std::map const kSTypeMap = {XMACRO(TO_MAP)}; #undef XMACRO #undef TO_ENUM @@ -129,26 +129,23 @@ 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 kSmdNever = 0x00; + static constexpr auto kSmdChangeOrig = 0x01; // original value when it changes + static constexpr auto kSmdChangeNew = 0x02; // new value when it changes + static constexpr auto kSmdDeleteFinal = 0x04; // final value when it is deleted + static constexpr auto kSmdCreate = 0x08; // value when it's created + static constexpr auto kSmdAlways = 0x10; // value when node containing it is affected at all + static constexpr auto kSmdBaseTen = 0x20; // value is treated as base 10, overriding behavior + static constexpr auto kSmdPseudoAccount = 0x40; // if this field is set in an ACCOUNT_ROOT + // _only_, then it is a pseudo-account + static constexpr auto kSmdNeedsAsset = 0x80; // This field needs to be associated with an + // asset before it is serialized as a ledger + // object. Intended for STNumber. + static constexpr auto kSmdDefault = + kSmdChangeOrig | kSmdChangeNew | kSmdDeleteFinal | kSmdCreate; enum class IsSigning : unsigned char { No, Yes }; - static IsSigning const kNOT_SIGNING = IsSigning::No; + static IsSigning const kNotSigning = IsSigning::No; int const fieldCodeMem; // (type<<16)|index // TODO: rename, clashes with function SerializedTypeID const fieldType; // STI_* @@ -175,7 +172,7 @@ public: SerializedTypeID tid, int fv, char const* fn, - int meta = SMdDefault, + int meta = kSmdDefault, IsSigning signing = IsSigning::Yes); explicit SField(PrivateAccessTagT, int fc, char const* fn); @@ -368,8 +365,8 @@ using SF_XCHAIN_BRIDGE = TypedField; #define UNTYPED_SFIELD(sfName, stiSuffix, fieldValue, ...) extern SField const sfName; #define TYPED_SFIELD(sfName, stiSuffix, fieldValue, ...) extern SF_##stiSuffix const sfName; -extern SField const kSF_INVALID; -extern SField const kSF_GENERIC; +extern SField const sfInvalid; // NOLINT(readability-identifier-naming) +extern SField const sfGeneric; // NOLINT(readability-identifier-naming) #include diff --git a/include/xrpl/protocol/STAmount.h b/include/xrpl/protocol/STAmount.h index 7fa6ef88ae..bf3e25eedb 100644 --- a/include/xrpl/protocol/STAmount.h +++ b/include/xrpl/protocol/STAmount.h @@ -3,11 +3,13 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include #include @@ -42,24 +44,24 @@ private: public: using value_type = STAmount; - constexpr static int kMIN_OFFSET = -96; - constexpr static int kMAX_OFFSET = 80; + static constexpr int kMinOffset = -96; + static constexpr int kMaxOffset = 80; // Maximum native value supported by the code - constexpr static std::uint64_t kMIN_VALUE = 1'000'000'000'000'000ull; - static_assert(isPowerOfTen(kMIN_VALUE)); - constexpr static std::uint64_t kMAX_VALUE = (kMIN_VALUE * 10) - 1; - static_assert(kMAX_VALUE == 9'999'999'999'999'999ull); - constexpr static std::uint64_t kMAX_NATIVE = 9'000'000'000'000'000'000ull; + static constexpr std::uint64_t kMinValue = 1'000'000'000'000'000ull; + static_assert(isPowerOfTen(kMinValue)); + static constexpr std::uint64_t kMaxValue = (kMinValue * 10) - 1; + static_assert(kMaxValue == 9'999'999'999'999'999ull); + static constexpr std::uint64_t kMaxNative = 9'000'000'000'000'000'000ull; // Max native value on network. - constexpr static std::uint64_t kMAX_NATIVE_N = 100'000'000'000'000'000ull; - constexpr static std::uint64_t kISSUED_CURRENCY = 0x8'000'000'000'000'000ull; - constexpr static std::uint64_t kPOSITIVE = 0x4'000'000'000'000'000ull; - constexpr static std::uint64_t kMP_TOKEN = 0x2'000'000'000'000'000ull; - constexpr static std::uint64_t kVALUE_MASK = ~(kPOSITIVE | kMP_TOKEN); + static constexpr std::uint64_t kMaxNativeN = 100'000'000'000'000'000ull; + static constexpr std::uint64_t kIssuedCurrency = 0x8'000'000'000'000'000ull; + static constexpr std::uint64_t kPositive = 0x4'000'000'000'000'000ull; + static constexpr std::uint64_t kMpToken = 0x2'000'000'000'000'000ull; + static constexpr std::uint64_t kValueMask = ~(kPositive | kMpToken); - static std::uint64_t const kU_RATE_ONE; + static std::uint64_t const kURateOne; //-------------------------------------------------------------------------- STAmount(SerialIter& sit, SField const& name); @@ -184,6 +186,24 @@ public: [[nodiscard]] STAmount const& value() const noexcept; + /** + * Checks if this amount evaluates to zero when constrained to a specific + * accounting scale. + * + * For XRP and MPT `roundToScale` is a no-op, returns true only when the amount itself is zero. + * The `scale` argument is ignored in that case. + * For IOU, the amount is rounded to the given scale using Number::RoundingMode::ToNearest mode + * and the result is checked for zero; if `scale <= exponent()`, `roundToScale` short-circuits + * and returns the value unchanged, so this returns false for any non-zero amount. + * + * @param scale The target accounting scale to evaluate against. + * @return `true` if this amount rounds to zero at the given scale, `false` otherwise. + * + * @see roundToScale + */ + [[nodiscard]] bool + isZeroAtScale(int scale) const; + //-------------------------------------------------------------------------- // // Operators @@ -241,7 +261,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; @@ -356,7 +376,7 @@ STAmount::STAmount(A const& asset, int mantissa, int exponent) // Legacy support for new-style amounts inline STAmount::STAmount(IOUAmount const& amount, Issue const& issue) - : asset_(issue), offset_(amount.exponent()), isNegative_(amount < beast::kZERO) + : asset_(issue), offset_(amount.exponent()), isNegative_(amount < beast::kZero) { if (isNegative_) { @@ -371,7 +391,7 @@ inline STAmount::STAmount(IOUAmount const& amount, Issue const& issue) } inline STAmount::STAmount(MPTAmount const& amount, MPTIssue const& mptIssue) - : asset_(mptIssue), offset_(0), isNegative_(amount < beast::kZERO) + : asset_(mptIssue), offset_(0), isNegative_(amount < beast::kZero) { if (isNegative_) { @@ -498,7 +518,7 @@ STAmount::zeroed() const inline STAmount:: operator bool() const noexcept { - return *this != beast::kZERO; + return *this != beast::kZero; } inline STAmount:: @@ -540,7 +560,7 @@ STAmount::fromNumber(A const& a, Number const& number) return STAmount{asset, intValue, 0, negative}; } - auto const [mantissa, exponent] = working.normalizeToRange(kMIN_VALUE, kMAX_VALUE); + auto const [mantissa, exponent] = working.normalizeToRange(kMinValue, kMaxValue); return STAmount{asset, mantissa, exponent, negative}; } @@ -548,7 +568,7 @@ STAmount::fromNumber(A const& a, Number const& number) inline void STAmount::negate() { - if (*this != beast::kZERO) + if (*this != beast::kZero) isNegative_ = !isNegative_; } @@ -575,12 +595,25 @@ STAmount::value() const noexcept return *this; } -inline bool +[[nodiscard]] inline bool isLegalNet(STAmount const& value) { - return !value.native() || (value.mantissa() <= STAmount::kMAX_NATIVE_N); + return !value.native() || (value.mantissa() <= STAmount::kMaxNativeN); } +[[nodiscard]] inline bool +isLegalMPT(STAmount const& value) +{ + return !value.holds() || + (!value.negative() && value.exponent() == 0 && value.mantissa() <= kMaxMpTokenAmount); +} + +/* Check recursively if an object has invalid MPTAmount or XRPAmount in STAmount field. + * Calls isLegalNet() and isLegalMPT(). + */ +[[nodiscard]] bool +hasInvalidAmount(STBase const& field, beast::Journal j); + //------------------------------------------------------------------------------ // // Operators diff --git a/include/xrpl/protocol/STBase.h b/include/xrpl/protocol/STBase.h index cba0bfbe74..6633253d3b 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 { @@ -65,22 +65,22 @@ struct JsonOptions } /// Returns JsonOptions binary negation, can be used with & (above) for set - /// difference e.g. `(options & ~JsonOptions::kINCLUDE_DATE)` + /// difference e.g. `(options & ~JsonOptions::kIncludeDate)` [[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..87c8cd4f45 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; } @@ -180,7 +180,7 @@ template bool STBitString::isDefault() const { - return value_ == beast::kZERO; + return value_ == beast::kZero; } } // namespace xrpl diff --git a/include/xrpl/protocol/STBlob.h b/include/xrpl/protocol/STBlob.h index 84f44f1b78..0667c54e30 100644 --- a/include/xrpl/protocol/STBlob.h +++ b/include/xrpl/protocol/STBlob.h @@ -24,7 +24,7 @@ public: STBlob(SField const& f, void const* data, std::size_t size); STBlob(SField const& f, Buffer&& b); STBlob(SField const& n); - STBlob(SerialIter&, SField const& name = kSF_GENERIC); + STBlob(SerialIter&, SField const& name = sfGeneric); [[nodiscard]] std::size_t size() const; 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..2557ab055b 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 kMaxParsedJsonDepth = 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 kMaxParsedJsonArraySize = 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/STPathSet.h b/include/xrpl/protocol/STPathSet.h index a1891164f6..1508dcb727 100644 --- a/include/xrpl/protocol/STPathSet.h +++ b/include/xrpl/protocol/STPathSet.h @@ -21,8 +21,8 @@ class STPathElement final : public CountedObject PathAsset assetID_; AccountID issuerID_; - bool is_offer_; - std::size_t hash_value_; + bool isOffer_; + std::size_t hashValue_; public: // Bitwise values (typeCurrency | typeMPT) @@ -235,9 +235,9 @@ private: // ------------ STPathElement ------------ -inline STPathElement::STPathElement() : type_(TypeNone), is_offer_(true) +inline STPathElement::STPathElement() : type_(TypeNone), isOffer_(true) { - hash_value_ = getHash(*this); + hashValue_ = getHash(*this); } inline STPathElement::STPathElement( @@ -248,11 +248,11 @@ inline STPathElement::STPathElement( { if (!account) { - is_offer_ = true; + isOffer_ = true; } else { - is_offer_ = false; + isOffer_ = false; accountID_ = *account; type_ |= TypeAccount; XRPL_ASSERT( @@ -272,7 +272,7 @@ inline STPathElement::STPathElement( XRPL_ASSERT(issuerID_ != noAccount(), "xrpl::STPathElement::STPathElement : issuer is set"); } - hash_value_ = getHash(*this); + hashValue_ = getHash(*this); } inline STPathElement::STPathElement( @@ -284,9 +284,9 @@ inline STPathElement::STPathElement( , accountID_(account) , assetID_(asset) , issuerID_(issuer) - , is_offer_(isXRP(accountID_)) + , isOffer_(isXRP(accountID_)) { - if (!is_offer_) + if (!isOffer_) type_ |= TypeAccount; if (forceAsset || !isXRP(assetID_)) @@ -295,7 +295,7 @@ inline STPathElement::STPathElement( if (!isXRP(issuer)) type_ |= TypeIssuer; - hash_value_ = getHash(*this); + hashValue_ = getHash(*this); } inline STPathElement::STPathElement( @@ -307,12 +307,12 @@ inline STPathElement::STPathElement( , accountID_(account) , assetID_(asset) , issuerID_(issuer) - , is_offer_(isXRP(accountID_)) + , isOffer_(isXRP(accountID_)) { assetID_.visit( [&](Currency const&) { type_ = type_ & (~Type::TypeMpt); }, [&](MPTID const&) { type_ = type_ & (~Type::TypeCurrency); }); - hash_value_ = getHash(*this); + hashValue_ = getHash(*this); } inline auto @@ -324,7 +324,7 @@ STPathElement::getNodeType() const inline bool STPathElement::isOffer() const { - return is_offer_; + return isOffer_; } inline bool @@ -404,7 +404,7 @@ STPathElement::getIssuerID() const inline bool STPathElement::operator==(STPathElement const& t) const { - return (type_ & TypeAccount) == (t.type_ & TypeAccount) && hash_value_ == t.hash_value_ && + return (type_ & TypeAccount) == (t.type_ & TypeAccount) && hashValue_ == t.hashValue_ && accountID_ == t.accountID_ && assetID_ == t.assetID_ && issuerID_ == t.issuerID_; } diff --git a/include/xrpl/protocol/STTx.h b/include/xrpl/protocol/STTx.h index d1bd32848f..4deedfafb7 100644 --- a/include/xrpl/protocol/STTx.h +++ b/include/xrpl/protocol/STTx.h @@ -27,11 +27,11 @@ enum class TxnSql : char { class STTx final : public STObject, public CountedObject { uint256 tid_; - TxType tx_type_; + TxType txType_; public: - static constexpr std::size_t kMIN_MULTI_SIGNERS = 1; - static constexpr std::size_t kMAX_MULTI_SIGNERS = 32; + static constexpr std::size_t kMinMultiSigners = 1; + static constexpr std::size_t kMaxMultiSigners = 32; STTx() = delete; STTx(STTx const& other) = default; @@ -187,7 +187,7 @@ inline STTx::STTx(SerialIter&& sit) // NOLINT(cppcoreguidelines-rvalue-referenc inline TxType STTx::getTxnType() const { - return tx_type_; + return txType_; } inline Blob diff --git a/include/xrpl/protocol/STValidation.h b/include/xrpl/protocol/STValidation.h index 27d5ef1051..91ce88b441 100644 --- a/include/xrpl/protocol/STValidation.h +++ b/include/xrpl/protocol/STValidation.h @@ -16,10 +16,10 @@ namespace xrpl { // Validation flags // This is a full (as opposed to a partial) validation -constexpr std::uint32_t kVF_FULL_VALIDATION = 0x00000001; +constexpr std::uint32_t kVfFullValidation = 0x00000001; // The signature is fully canonical -constexpr std::uint32_t kVF_FULLY_CANONICAL_SIG = 0x80000000; +constexpr std::uint32_t kVfFullyCanonicalSig = 0x80000000; class STValidation final : public STObject, public CountedObject { @@ -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"); } @@ -204,7 +204,7 @@ STValidation::STValidation( f(*this); // Finally, sign the validation and mark it as trusted: - setFlag(kVF_FULLY_CANONICAL_SIG); + setFlag(kVfFullyCanonicalSig); setFieldVL(sfSignature, signDigest(pk, sk, getSigningHash())); setTrusted(); diff --git a/include/xrpl/protocol/SecretKey.h b/include/xrpl/protocol/SecretKey.h index 9af27e9709..712b095f81 100644 --- a/include/xrpl/protocol/SecretKey.h +++ b/include/xrpl/protocol/SecretKey.h @@ -17,10 +17,10 @@ namespace xrpl { class SecretKey { public: - static constexpr std::size_t kSIZE = 32; + static constexpr std::size_t kSize = 32; private: - std::uint8_t buf_[kSIZE]{}; + std::uint8_t buf_[kSize]{}; public: using const_iterator = std::uint8_t const*; @@ -37,7 +37,7 @@ public: ~SecretKey(); - SecretKey(std::array const& data); + SecretKey(std::array const& data); SecretKey(Slice const& slice); [[nodiscard]] std::uint8_t const* diff --git a/include/xrpl/protocol/Serializer.h b/include/xrpl/protocol/Serializer.h index 385c09009a..ffe9afabe8 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()); } @@ -134,13 +134,13 @@ public: bool getInteger(Integer& number, int offset) { - static auto const kBYTES = sizeof(Integer); - if ((offset + kBYTES) > data_.size()) + static auto const kBytes = sizeof(Integer); + if ((offset + kBytes) > data_.size()) return false; number = 0; auto ptr = &data_[offset]; - for (auto i = 0; i < kBYTES; ++i) + for (auto i = 0; i < kBytes; ++i) { if (i) number <<= 8; @@ -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/SystemParameters.h b/include/xrpl/protocol/SystemParameters.h index 029c0418b5..1cc35a0f31 100644 --- a/include/xrpl/protocol/SystemParameters.h +++ b/include/xrpl/protocol/SystemParameters.h @@ -14,22 +14,22 @@ namespace xrpl { static inline std::string const& systemName() { - static std::string const kNAME = "xrpld"; - return kNAME; + static std::string const kName = "xrpld"; + return kName; } /** Configure the native currency. */ /** Number of drops in the genesis account. */ -constexpr XRPAmount kINITIAL_XRP{100'000'000'000 * kDROPS_PER_XRP}; -static_assert(kINITIAL_XRP.drops() == 100'000'000'000'000'000); -static_assert(Number::kMAX_REP >= kINITIAL_XRP.drops()); +constexpr XRPAmount kInitialXrp{100'000'000'000 * kDropsPerXrp}; +static_assert(kInitialXrp.drops() == 100'000'000'000'000'000); +static_assert(Number::kMaxRep >= kInitialXrp.drops()); /** Returns true if the amount does not exceed the initial XRP in existence. */ inline bool isLegalAmount(XRPAmount const& amount) { - return amount <= kINITIAL_XRP; + return amount <= kInitialXrp; } /** Returns true if the absolute value of the amount does not exceed the initial @@ -37,31 +37,31 @@ isLegalAmount(XRPAmount const& amount) inline bool isLegalAmountSigned(XRPAmount const& amount) { - return amount >= -kINITIAL_XRP && amount <= kINITIAL_XRP; + return amount >= -kInitialXrp && amount <= kInitialXrp; } /* The currency code for the native currency. */ static inline std::string const& systemCurrencyCode() { - static std::string const kCODE = "XRP"; - return kCODE; + static std::string const kCode = "XRP"; + return kCode; } /** The XRP ledger network's earliest allowed sequence */ -static constexpr std::uint32_t kXRP_LEDGER_EARLIEST_SEQ{32570u}; +static constexpr std::uint32_t kXrpLedgerEarliestSeq{32570u}; /** The XRP Ledger mainnet's earliest ledger with a FeeSettings object. Only * used in asserts and tests. */ -static constexpr std::uint32_t kXRP_LEDGER_EARLIEST_FEES{562177u}; +static constexpr std::uint32_t kXrpLedgerEarliestFees{562177u}; /** The minimum amount of support an amendment should have. */ -constexpr std::ratio<80, 100> kAMENDMENT_MAJORITY_CALC_THRESHOLD; +constexpr std::ratio<80, 100> kAmendmentMajorityCalcThreshold; /** The minimum amount of time an amendment must hold a majority */ -constexpr std::chrono::seconds const kDEFAULT_AMENDMENT_MAJORITY_TIME = weeks{2}; +constexpr std::chrono::seconds const kDefaultAmendmentMajorityTime = weeks{2}; } // namespace xrpl /** Default peer port (IANA registered) */ -inline std::uint16_t constexpr kDEFAULT_PEER_PORT{2459}; +inline constexpr std::uint16_t kDefaultPeerPort{2459}; diff --git a/include/xrpl/protocol/UintTypes.h b/include/xrpl/protocol/UintTypes.h index 6fb0648b5f..b38c544096 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& @@ -62,7 +62,7 @@ badCurrency(); inline bool isXRP(Currency const& c) { - return c == beast::kZERO; + return c == beast::kZero; } /** Returns "", "XRP", or three letter ISO code. */ diff --git a/include/xrpl/protocol/Units.h b/include/xrpl/protocol/Units.h index dd5cfdeffd..7fedc05a0d 100644 --- a/include/xrpl/protocol/Units.h +++ b/include/xrpl/protocol/Units.h @@ -300,13 +300,13 @@ public: using jsontype = std::conditional_t, json::Int, json::UInt>; - constexpr auto kMIN = std::numeric_limits::min(); - constexpr auto kMAX = std::numeric_limits::max(); + constexpr auto kMin = std::numeric_limits::min(); + constexpr auto kMax = std::numeric_limits::max(); - if (value_ < kMIN) - return kMIN; - if (value_ > kMAX) - return kMAX; + if (value_ < kMin) + return kMin; + if (value_ > kMax) + return kMax; return static_cast(value_); } else @@ -392,14 +392,14 @@ mulDivU(Source1 value, Dest mul, Source2 div) } using desttype = typename Dest::value_type; - constexpr auto kMAX = std::numeric_limits::max(); + constexpr auto kMax = std::numeric_limits::max(); // Shortcuts, since these happen a lot in the real world if (value == div) return mul; if (mul.value() == div.value()) { - if (value.value() > kMAX) + if (value.value() > kMax) return std::nullopt; return Dest{static_cast(value.value())}; } @@ -414,7 +414,7 @@ mulDivU(Source1 value, Dest mul, Source2 div) auto quotient = product / div.value(); - if (quotient > kMAX) + if (quotient > kMax) return std::nullopt; return Dest{static_cast(quotient)}; diff --git a/include/xrpl/protocol/XChainAttestations.h b/include/xrpl/protocol/XChainAttestations.h index d8a35a29e3..993f478b5e 100644 --- a/include/xrpl/protocol/XChainAttestations.h +++ b/include/xrpl/protocol/XChainAttestations.h @@ -357,7 +357,7 @@ private: // Set a max number of allowed attestations to limit the amount of memory // allocated and processing time. This number is much larger than the actual // number of attestation a server would ever expect. - static constexpr std::uint32_t kMAX_ATTESTATIONS = 256; + static constexpr std::uint32_t kMaxAttestations = 256; AttCollection attestations_; protected: diff --git a/include/xrpl/protocol/XRPAmount.h b/include/xrpl/protocol/XRPAmount.h index 067ea511da..f09ddc337a 100644 --- a/include/xrpl/protocol/XRPAmount.h +++ b/include/xrpl/protocol/XRPAmount.h @@ -202,13 +202,13 @@ public: std::is_signed_v && std::is_integral_v, "Expected XRPAmount to be a signed integral type"); - constexpr auto kMIN = std::numeric_limits::min(); - constexpr auto kMAX = std::numeric_limits::max(); + constexpr auto kMin = std::numeric_limits::min(); + constexpr auto kMax = std::numeric_limits::max(); - if (drops_ < kMIN) - return kMIN; - if (drops_ > kMAX) - return kMAX; + if (drops_ < kMin) + return kMin; + if (drops_ > kMax) + return kMax; return static_cast(drops_); } @@ -237,12 +237,12 @@ public: }; /** Number of drops per 1 XRP */ -constexpr XRPAmount kDROPS_PER_XRP{1'000'000}; +constexpr XRPAmount kDropsPerXrp{1'000'000}; constexpr double XRPAmount::decimalXRP() const { - return static_cast(drops_) / kDROPS_PER_XRP.drops(); + return static_cast(drops_) / kDropsPerXrp.drops(); } // Output XRPAmount as just the drops value. diff --git a/include/xrpl/protocol/detail/STVar.h b/include/xrpl/protocol/detail/STVar.h index 52045965fd..98a0b8dcd2 100644 --- a/include/xrpl/protocol/detail/STVar.h +++ b/include/xrpl/protocol/detail/STVar.h @@ -35,9 +35,9 @@ class STVar { private: // The largest "small object" we can accommodate - static std::size_t constexpr kMAX_SIZE = 72; + static constexpr std::size_t kMaxSize = 72; - std::aligned_storage::type d_ = {}; + std::aligned_storage::type d_ = {}; STBase* p_ = nullptr; public: @@ -51,12 +51,12 @@ public: STVar(STBase&& t) // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved) { - p_ = t.move(kMAX_SIZE, &d_); + p_ = t.move(kMaxSize, &d_); } STVar(STBase const& t) { - p_ = t.copy(kMAX_SIZE, &d_); + p_ = t.copy(kMaxSize, &d_); } STVar(DefaultObjectT, SField const& name); @@ -110,7 +110,7 @@ private: void construct(Args&&... args) { - if constexpr (sizeof(T) > kMAX_SIZE) + if constexpr (sizeof(T) > kMaxSize) { p_ = new T(std::forward(args)...); } diff --git a/include/xrpl/protocol/detail/b58_utils.h b/include/xrpl/protocol/detail/b58_utils.h index f860dc40c4..e800dbda06 100644 --- a/include/xrpl/protocol/detail/b58_utils.h +++ b/include/xrpl/protocol/detail/b58_utils.h @@ -155,16 +155,16 @@ inplaceBigintDivRem(std::span numerator, std::uint64_t divisor) [[nodiscard]] inline std::array b5810ToB58Be(std::uint64_t input) { - [[maybe_unused]] static constexpr std::uint64_t kB_58_10 = 430804206899405824; // 58^10; - XRPL_ASSERT(input < kB_58_10, "xrpl::b58_fast::detail::b5810ToB58Be : valid input"); - constexpr std::size_t kRESULT_SIZE = 10; - std::array result{}; + [[maybe_unused]] static constexpr std::uint64_t kB5810 = 430804206899405824; // 58^10; + XRPL_ASSERT(input < kB5810, "xrpl::b58_fast::detail::b5810ToB58Be : valid input"); + static constexpr std::size_t kResultSize = 10; + std::array result{}; int i = 0; while (input > 0) { std::uint64_t rem = 0; std::tie(input, rem) = divRem(input, 58); - result[kRESULT_SIZE - 1 - i] = rem; + result[kResultSize - 1 - i] = rem; i += 1; } 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/ledger_entries.macro b/include/xrpl/protocol/detail/ledger_entries.macro index bf641862d1..632038a9c5 100644 --- a/include/xrpl/protocol/detail/ledger_entries.macro +++ b/include/xrpl/protocol/detail/ledger_entries.macro @@ -84,7 +84,7 @@ LEDGER_ENTRY(ltNEGATIVE_UNL, 0x004e, NegativeUNL, nunl, ({ /** A ledger object which contains a list of NFTs - \sa keylet::nftpage_min, keylet::nftpage_max, keylet::nftpage + \sa keylet::nftpageMin, keylet::nftpageMax, keylet::nftpage */ LEDGER_ENTRY(ltNFTOKEN_PAGE, 0x0050, NFTokenPage, nft_page, ({ {sfPreviousPageMin, SoeOptional}, @@ -112,7 +112,7 @@ LEDGER_ENTRY(ltSIGNER_LIST, 0x0053, SignerList, signer_list, ({ /** A ledger object which describes a ticket. - \sa keylet::ticket + \sa keylet::kTicket */ LEDGER_ENTRY(ltTICKET, 0x0054, Ticket, ticket, ({ {sfAccount, SoeRequired}, @@ -400,6 +400,7 @@ LEDGER_ENTRY(ltMPTOKEN_ISSUANCE, 0x007e, MPTokenIssuance, mpt_issuance, ({ {sfPreviousTxnLgrSeq, SoeRequired}, {sfDomainID, SoeOptional}, {sfMutableFlags, SoeDefault}, + {sfReferenceHolding, SoeOptional}, })) /** A ledger object which tracks MPToken @@ -591,7 +592,7 @@ LEDGER_ENTRY(ltLOAN, 0x0089, Loan, loan, ({ // LoanBroker.ManagementFeeRate // The unrounded true total fee still owed to the broker. // - // Note the the "True" values may differ significantly from the tracked + // Note the "True" values may differ significantly from the tracked // rounded values. {sfPaymentRemaining, SoeDefault}, {sfPeriodicPayment, SoeRequired}, diff --git a/include/xrpl/protocol/detail/sfields.macro b/include/xrpl/protocol/detail/sfields.macro index 3637acc1c4..01bb4fc480 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::kSmdNever) 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::kSmdDeleteFinal) 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::kSmdBaseTen|SField::kSmdDefault) +TYPED_SFIELD(sfOutstandingAmount, UINT64, 25, SField::kSmdBaseTen|SField::kSmdDefault) +TYPED_SFIELD(sfMPTAmount, UINT64, 26, SField::kSmdBaseTen|SField::kSmdDefault) 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::kSmdBaseTen|SField::kSmdDefault) 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::kSmdDeleteFinal) TYPED_SFIELD(sfLedgerIndex, UINT256, 6) TYPED_SFIELD(sfWalletLocator, UINT256, 7) -TYPED_SFIELD(sfRootIndex, UINT256, 8, SField::SMdAlways) +TYPED_SFIELD(sfRootIndex, UINT256, 8, SField::kSmdAlways) 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::kSmdPseudoAccount | SField::kSmdDefault) // 256-bit (uncommon) TYPED_SFIELD(sfBookDirectory, UINT256, 16) @@ -200,30 +200,31 @@ 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::kSmdPseudoAccount | SField::kSmdDefault) TYPED_SFIELD(sfParentBatchID, UINT256, 36) TYPED_SFIELD(sfLoanBrokerID, UINT256, 37, - SField::SMdPseudoAccount | SField::SMdDefault) + SField::kSmdPseudoAccount | SField::kSmdDefault) TYPED_SFIELD(sfLoanID, UINT256, 38) +TYPED_SFIELD(sfReferenceHolding, UINT256, 39) // 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::kSmdNeedsAsset | SField::kSmdDefault) +TYPED_SFIELD(sfAssetsMaximum, NUMBER, 3, SField::kSmdNeedsAsset | SField::kSmdDefault) +TYPED_SFIELD(sfAssetsTotal, NUMBER, 4, SField::kSmdNeedsAsset | SField::kSmdDefault) +TYPED_SFIELD(sfLossUnrealized, NUMBER, 5, SField::kSmdNeedsAsset | SField::kSmdDefault) +TYPED_SFIELD(sfDebtTotal, NUMBER, 6, SField::kSmdNeedsAsset | SField::kSmdDefault) +TYPED_SFIELD(sfDebtMaximum, NUMBER, 7, SField::kSmdNeedsAsset | SField::kSmdDefault) +TYPED_SFIELD(sfCoverAvailable, NUMBER, 8, SField::kSmdNeedsAsset | SField::kSmdDefault) 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::kSmdNeedsAsset | SField::kSmdDefault) TYPED_SFIELD(sfPrincipalRequested, NUMBER, 14) -TYPED_SFIELD(sfTotalValueOutstanding, NUMBER, 15, SField::SMdNeedsAsset | SField::SMdDefault) +TYPED_SFIELD(sfTotalValueOutstanding, NUMBER, 15, SField::kSmdNeedsAsset | SField::kSmdDefault) TYPED_SFIELD(sfPeriodicPayment, NUMBER, 16) -TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER, 17, SField::SMdNeedsAsset | SField::SMdDefault) +TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER, 17, SField::kSmdNeedsAsset | SField::kSmdDefault) // int32 TYPED_SFIELD(sfLoanScale, INT32, 1) @@ -269,9 +270,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::kSmdDefault, SField::kNotSigning) TYPED_SFIELD(sfURI, VL, 5) -TYPED_SFIELD(sfSignature, VL, 6, SField::SMdDefault, SField::kNOT_SIGNING) +TYPED_SFIELD(sfSignature, VL, 6, SField::kSmdDefault, SField::kNotSigning) TYPED_SFIELD(sfDomain, VL, 7) TYPED_SFIELD(sfFundCode, VL, 8) TYPED_SFIELD(sfRemoveCode, VL, 9) @@ -284,7 +285,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::kSmdDefault, SField::kNotSigning) TYPED_SFIELD(sfUNLModifyValidator, VL, 19) TYPED_SFIELD(sfValidatorToDisable, VL, 20) TYPED_SFIELD(sfValidatorToReEnable, VL, 21) @@ -326,7 +327,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::kSmdNever) TYPED_SFIELD(sfHashes, VECTOR256, 2) TYPED_SFIELD(sfAmendments, VECTOR256, 3) TYPED_SFIELD(sfNFTokenOffers, VECTOR256, 4) @@ -387,13 +388,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::kSmdDefault, SField::kNotSigning) // 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::kSmdDefault, SField::kNotSigning) UNTYPED_SFIELD(sfSignerEntries, ARRAY, 4) UNTYPED_SFIELD(sfTemplate, ARRAY, 5) UNTYPED_SFIELD(sfNecessary, ARRAY, 6) @@ -421,4 +422,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::kSmdDefault, SField::kNotSigning) diff --git a/include/xrpl/protocol/detail/transactions.macro b/include/xrpl/protocol/detail/transactions.macro index 9bac9ef7db..450e2558cc 100644 --- a/include/xrpl/protocol/detail/transactions.macro +++ b/include/xrpl/protocol/detail/transactions.macro @@ -688,6 +688,7 @@ TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix, ({ {sfLedgerFixType, SoeRequired}, {sfOwner, SoeOptional}, + {sfBookDirectory, SoeOptional}, })) /** This transaction type creates a MPTokensIssuance instance */ diff --git a/include/xrpl/protocol/digest.h b/include/xrpl/protocol/digest.h index 6564237771..50bf2735fb 100644 --- a/include/xrpl/protocol/digest.h +++ b/include/xrpl/protocol/digest.h @@ -27,7 +27,7 @@ namespace xrpl { struct OpensslRipemd160Hasher { public: - static constexpr auto const kENDIAN = boost::endian::order::native; + static constexpr auto kEndian = boost::endian::order::native; using result_type = std::array; @@ -50,7 +50,7 @@ private: struct OpensslSha512Hasher { public: - static constexpr auto const kENDIAN = boost::endian::order::native; + static constexpr auto kEndian = boost::endian::order::native; using result_type = std::array; @@ -73,7 +73,7 @@ private: struct OpensslSha256Hasher { public: - static constexpr auto const kENDIAN = boost::endian::order::native; + static constexpr auto kEndian = boost::endian::order::native; using result_type = std::array; @@ -118,7 +118,7 @@ private: sha256_hasher h_; public: - static constexpr auto const kENDIAN = boost::endian::order::native; + static constexpr auto kEndian = boost::endian::order::native; using result_type = std::array; @@ -154,7 +154,7 @@ private: sha512_hasher h_; public: - static constexpr auto const kENDIAN = boost::endian::order::big; + static constexpr auto kEndian = boost::endian::order::big; using result_type = uint256; diff --git a/include/xrpl/protocol/nft.h b/include/xrpl/protocol/nft.h index ce73e244c1..1e79b3f285 100644 --- a/include/xrpl/protocol/nft.h +++ b/include/xrpl/protocol/nft.h @@ -29,11 +29,11 @@ toUInt32(Taxon t) return static_cast(t); } -constexpr std::uint16_t const kFLAG_BURNABLE = 0x0001; -constexpr std::uint16_t const kFLAG_ONLY_XRP = 0x0002; -constexpr std::uint16_t const kFLAG_CREATE_TRUST_LINES = 0x0004; -constexpr std::uint16_t const kFLAG_TRANSFERABLE = 0x0008; -constexpr std::uint16_t const kFLAG_MUTABLE = 0x0010; +constexpr std::uint16_t const kFlagBurnable = 0x0001; +constexpr std::uint16_t const kFlagOnlyXrp = 0x0002; +constexpr std::uint16_t const kFlagCreateTrustLines = 0x0004; +constexpr std::uint16_t const kFlagTransferable = 0x0008; +constexpr std::uint16_t const kFlagMutable = 0x0010; inline std::uint16_t getFlags(uint256 const& id) diff --git a/include/xrpl/protocol/nftPageMask.h b/include/xrpl/protocol/nftPageMask.h index d679c319fa..827df34cf3 100644 --- a/include/xrpl/protocol/nftPageMask.h +++ b/include/xrpl/protocol/nftPageMask.h @@ -8,7 +8,7 @@ namespace xrpl::nft { // NFT directory pages order their contents based only on the low 96 bits of // the NFToken value. This mask provides easy access to the necessary mask. -uint256 constexpr kPAGE_MASK( +constexpr uint256 kPageMask( std::string_view("0000000000000000000000000000000000000000ffffffffffffffffffffffff")); } // namespace xrpl::nft diff --git a/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h b/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h index 8377fdf1a4..7f772b1c74 100644 --- a/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h +++ b/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h @@ -278,6 +278,30 @@ public: { return this->sle_->isFieldPresent(sfMutableFlags); } + + /** + * @brief Get sfReferenceHolding (SoeOptional) + * @return The field value, or std::nullopt if not present. + */ + [[nodiscard]] + protocol_autogen::Optional + getReferenceHolding() const + { + if (hasReferenceHolding()) + return this->sle_->at(sfReferenceHolding); + return std::nullopt; + } + + /** + * @brief Check if sfReferenceHolding is present. + * @return True if the field is present, false otherwise. + */ + [[nodiscard]] + bool + hasReferenceHolding() const + { + return this->sle_->isFieldPresent(sfReferenceHolding); + } }; /** @@ -469,6 +493,17 @@ public: return *this; } + /** + * @brief Set sfReferenceHolding (SoeOptional) + * @return Reference to this builder for method chaining. + */ + MPTokenIssuanceBuilder& + setReferenceHolding(std::decay_t const& value) + { + object_[sfReferenceHolding] = value; + return *this; + } + /** * @brief Build and return the completed MPTokenIssuance wrapper. * @param index The ledger entry index. diff --git a/include/xrpl/protocol_autogen/transactions/LedgerStateFix.h b/include/xrpl/protocol_autogen/transactions/LedgerStateFix.h index 3c58815a02..52723ad5eb 100644 --- a/include/xrpl/protocol_autogen/transactions/LedgerStateFix.h +++ b/include/xrpl/protocol_autogen/transactions/LedgerStateFix.h @@ -83,6 +83,32 @@ public: { return this->tx_->isFieldPresent(sfOwner); } + + /** + * @brief Get sfBookDirectory (SoeOptional) + * @return The field value, or std::nullopt if not present. + */ + [[nodiscard]] + protocol_autogen::Optional + getBookDirectory() const + { + if (hasBookDirectory()) + { + return this->tx_->at(sfBookDirectory); + } + return std::nullopt; + } + + /** + * @brief Check if sfBookDirectory is present. + * @return True if the field is present, false otherwise. + */ + [[nodiscard]] + bool + hasBookDirectory() const + { + return this->tx_->isFieldPresent(sfBookDirectory); + } }; /** @@ -149,6 +175,17 @@ public: return *this; } + /** + * @brief Set sfBookDirectory (SoeOptional) + * @return Reference to this builder for method chaining. + */ + LedgerStateFixBuilder& + setBookDirectory(std::decay_t const& value) + { + object_[sfBookDirectory] = value; + return *this; + } + /** * @brief Build and return the LedgerStateFix wrapper. * @param publicKey The public key for signing. diff --git a/include/xrpl/rdb/DBInit.h b/include/xrpl/rdb/DBInit.h index 59806b2e85..10b04905f2 100644 --- a/include/xrpl/rdb/DBInit.h +++ b/include/xrpl/rdb/DBInit.h @@ -9,20 +9,20 @@ namespace xrpl { // These pragmas are built at startup and applied to all database // connections, unless otherwise noted. -inline constexpr char const* kCOMMON_DB_PRAGMA_JOURNAL{"PRAGMA journal_mode=%s;"}; -inline constexpr char const* kCOMMON_DB_PRAGMA_SYNC{"PRAGMA synchronous=%s;"}; -inline constexpr char const* kCOMMON_DB_PRAGMA_TEMP{"PRAGMA temp_store=%s;"}; +inline constexpr char const* kCommonDbPragmaJournal{"PRAGMA journal_mode=%s;"}; +inline constexpr char const* kCommonDbPragmaSync{"PRAGMA synchronous=%s;"}; +inline constexpr char const* kCommonDbPragmaTemp{"PRAGMA temp_store=%s;"}; // A warning will be logged if any lower-safety sqlite tuning settings // are used and at least this much ledger history is configured. This // includes full history nodes. This is because such a large amount of // data will be more difficult to recover if a rare failure occurs, // which are more likely with some of the other available tuning settings. -inline constexpr std::uint32_t kSQLITE_TUNING_CUTOFF = 10'000'000; +inline constexpr std::uint32_t kSqliteTuningCutoff = 10'000'000; // Ledger database holds ledgers and ledger confirmations -inline constexpr auto kLGR_DB_NAME{"ledger.db"}; +inline constexpr auto kLgrDbName{"ledger.db"}; -inline constexpr std::array kLGR_DB_INIT{ +inline constexpr std::array kLgrDbInit{ {"BEGIN TRANSACTION;", "CREATE TABLE IF NOT EXISTS Ledgers ( \ @@ -47,9 +47,9 @@ inline constexpr std::array kLGR_DB_INIT{ //////////////////////////////////////////////////////////////////////////////// // Transaction database holds transactions and public keys -inline constexpr auto kTX_DB_NAME{"transaction.db"}; +inline constexpr auto kTxDbName{"transaction.db"}; -inline constexpr std::array kTX_DB_INIT{ +inline constexpr std::array kTxDbInit{ {"BEGIN TRANSACTION;", "CREATE TABLE IF NOT EXISTS Transactions ( \ @@ -82,9 +82,9 @@ inline constexpr std::array kTX_DB_INIT{ //////////////////////////////////////////////////////////////////////////////// -inline constexpr auto kWALLET_DB_NAME{"wallet.db"}; +inline constexpr auto kWalletDbName{"wallet.db"}; -inline constexpr std::array kWALLET_DB_INIT{ +inline constexpr std::array kWalletDbInit{ {"BEGIN TRANSACTION;", // A node's identity must be persisted, including diff --git a/include/xrpl/resource/Fees.h b/include/xrpl/resource/Fees.h index dc14e3bd4d..55d539ac6a 100644 --- a/include/xrpl/resource/Fees.h +++ b/include/xrpl/resource/Fees.h @@ -6,28 +6,27 @@ namespace xrpl::Resource { /** Schedule of fees charged for imposing load on the server. */ /** @{ */ -extern Charge const kFEE_MALFORMED_REQUEST; // A request that we can immediately tell is invalid. -extern Charge const kFEE_REQUEST_NO_REPLY; // A request that we cannot satisfy. -extern Charge const - kFEE_INVALID_SIGNATURE; // An object whose signature we had to check that failed. -extern Charge const kFEE_USELESS_DATA; // Data we have no use for. -extern Charge const kFEE_INVALID_DATA; // Data we have to verify before rejecting. +extern Charge const kFeeMalformedRequest; // A request that we can immediately tell is invalid. +extern Charge const kFeeRequestNoReply; // A request that we cannot satisfy. +extern Charge const kFeeInvalidSignature; // An object whose signature we had to check that failed. +extern Charge const kFeeUselessData; // Data we have no use for. +extern Charge const kFeeInvalidData; // Data we have to verify before rejecting. // RPC loads -extern Charge const kFEE_MALFORMED_RPC; // An RPC request that we can immediately tell is invalid. -extern Charge const kFEE_REFERENCE_RPC; // A default "reference" unspecified load. -extern Charge const kFEE_EXCEPTION_RPC; // RPC load that causes an exception. -extern Charge const kFEE_MEDIUM_BURDEN_RPC; // A somewhat burdensome RPC load. -extern Charge const kFEE_HEAVY_BURDEN_RPC; // A very burdensome RPC load. +extern Charge const kFeeMalformedRpc; // An RPC request that we can immediately tell is invalid. +extern Charge const kFeeReferenceRpc; // A default "reference" unspecified load. +extern Charge const kFeeExceptionRpc; // RPC load that causes an exception. +extern Charge const kFeeMediumBurdenRpc; // A somewhat burdensome RPC load. +extern Charge const kFeeHeavyBurdenRpc; // A very burdensome RPC load. // Peer loads -extern Charge const kFEE_TRIVIAL_PEER; // Requires no reply. -extern Charge const kFEE_MODERATE_BURDEN_PEER; // Requires some work. -extern Charge const kFEE_HEAVY_BURDEN_PEER; // Extensive work. +extern Charge const kFeeTrivialPeer; // Requires no reply. +extern Charge const kFeeModerateBurdenPeer; // Requires some work. +extern Charge const kFeeHeavyBurdenPeer; // Extensive work. // Administrative -extern Charge const kFEE_WARNING; // The cost of receiving a warning. -extern Charge const kFEE_DROP; // The cost of being dropped for excess load. +extern Charge const kFeeWarning; // The cost of receiving a warning. +extern Charge const kFeeDrop; // The cost of being dropped for excess load. /** @} */ } // namespace xrpl::Resource diff --git a/include/xrpl/resource/detail/Entry.h b/include/xrpl/resource/detail/Entry.h index a821461e2e..361c8409c8 100644 --- a/include/xrpl/resource/detail/Entry.h +++ b/include/xrpl/resource/detail/Entry.h @@ -21,7 +21,7 @@ struct Entry : public beast::List::Node @param now Construction time of Entry. */ explicit Entry(clock_type::time_point const now) - : refcount(0), local_balance(now), remote_balance(0) + : refcount(0), localBalance(now), remoteBalance(0) { } @@ -46,7 +46,7 @@ struct Entry : public beast::List::Node int balance(clock_type::time_point const now) { - return local_balance.value(now) + remote_balance; + return localBalance.value(now) + remoteBalance; } // Add a charge and return normalized balance @@ -54,7 +54,7 @@ struct Entry : public beast::List::Node int add(int charge, clock_type::time_point const now) { - return local_balance.add(charge, now) + remote_balance; + return localBalance.add(charge, now) + remoteBalance; } // The public key of the peer @@ -67,10 +67,10 @@ struct Entry : public beast::List::Node int refcount; // Exponentially decaying balance of resource consumption - DecayingSample local_balance; + DecayingSample localBalance; // Normalized balance contribution from imports - int remote_balance; + int remoteBalance; // Time of the last warning clock_type::time_point lastWarningTime; diff --git a/include/xrpl/resource/detail/Key.h b/include/xrpl/resource/detail/Key.h index 935d44425e..7d24b33955 100644 --- a/include/xrpl/resource/detail/Key.h +++ b/include/xrpl/resource/detail/Key.h @@ -25,11 +25,11 @@ struct Key std::size_t operator()(Key const& v) const { - return addr_hash_(v.address); + return addrHash_(v.address); } private: - beast::Uhash<> addr_hash_; + beast::Uhash<> addrHash_; }; struct KeyEqual diff --git a/include/xrpl/resource/detail/Logic.h b/include/xrpl/resource/detail/Logic.h index 3bbe08724d..b11ac100f5 100644 --- a/include/xrpl/resource/detail/Logic.h +++ b/include/xrpl/resource/detail/Logic.h @@ -180,48 +180,48 @@ public: json::Value getJson() { - return getJson(WarningThreshold); + return getJson(kWarningThreshold); } - /** 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_) { - int const localBalance = inboundEntry.local_balance.value(now); - if ((localBalance + inboundEntry.remote_balance) >= threshold) + int const localBalance = inboundEntry.localBalance.value(now); + if ((localBalance + inboundEntry.remoteBalance) >= 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::remote] = inboundEntry.remoteBalance; entry[jss::type] = "inbound"; } } for (auto& outboundEntry : outbound_) { - int const localBalance = outboundEntry.local_balance.value(now); - if ((localBalance + outboundEntry.remote_balance) >= threshold) + int const localBalance = outboundEntry.localBalance.value(now); + if ((localBalance + outboundEntry.remoteBalance) >= 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::remote] = outboundEntry.remoteBalance; entry[jss::type] = "outbound"; } } for (auto& adminEntry : admin_) { - int const localBalance = adminEntry.local_balance.value(now); - if ((localBalance + adminEntry.remote_balance) >= threshold) + int const localBalance = adminEntry.localBalance.value(now); + if ((localBalance + adminEntry.remoteBalance) >= 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::remote] = adminEntry.remoteBalance; entry[jss::type] = "admin"; } } @@ -242,8 +242,8 @@ public: for (auto& inboundEntry : inbound_) { Gossip::Item item; - item.balance = inboundEntry.local_balance.value(now); - if (item.balance >= MinimumGossipBalance) + item.balance = inboundEntry.localBalance.value(now); + if (item.balance >= kMinimumGossipBalance) { item.address = inboundEntry.key->address; gossip.items.push_back(item); @@ -270,7 +270,7 @@ public: { // This is a new import Import& next(resultIt->second); - next.whenExpires = elapsed + kGOSSIP_EXPIRATION_SECONDS; + next.whenExpires = elapsed + kGossipExpirationSeconds; next.items.reserve(gossip.items.size()); for (auto const& gossipItem : gossip.items) @@ -278,7 +278,7 @@ public: Import::Item item; item.balance = gossipItem.balance; item.consumer = newInboundEndpoint(gossipItem.address); - item.consumer.entry().remote_balance += item.balance; + item.consumer.entry().remoteBalance += item.balance; next.items.push_back(item); } } @@ -288,21 +288,21 @@ public: // balances and then deduct the old remote balances. Import next; - next.whenExpires = elapsed + kGOSSIP_EXPIRATION_SECONDS; + next.whenExpires = elapsed + kGossipExpirationSeconds; next.items.reserve(gossip.items.size()); for (auto const& gossipItem : gossip.items) { Import::Item item; item.balance = gossipItem.balance; item.consumer = newInboundEndpoint(gossipItem.address); - item.consumer.entry().remote_balance += item.balance; + item.consumer.entry().remoteBalance += item.balance; next.items.push_back(item); } Import& prev(resultIt->second); for (auto& item : prev.items) { - item.consumer.entry().remote_balance -= item.balance; + item.consumer.entry().remoteBalance -= item.balance; } std::swap(next, prev); @@ -345,7 +345,7 @@ public: for (auto itemIter(import.items.begin()); itemIter != import.items.end(); ++itemIter) { - itemIter->consumer.entry().remote_balance -= itemIter->balance; + itemIter->consumer.entry().remoteBalance -= itemIter->balance; } iter = importTable_.erase(iter); @@ -363,10 +363,10 @@ public: static Disposition disposition(int balance) { - if (balance >= DropThreshold) + if (balance >= kDropThreshold) return Disposition::Drop; - if (balance >= WarningThreshold) + if (balance >= kWarningThreshold) return Disposition::Warn; return Disposition::Ok; @@ -417,26 +417,25 @@ public: // LCOV_EXCL_STOP } inactive_.pushBack(entry); - entry.whenExpires = clock_.now() + kSECONDS_UNTIL_EXPIRATION; + entry.whenExpires = clock_.now() + kSecondsUntilExpiration; } } Disposition charge(Entry& entry, Charge const& fee, std::string context = {}) { - static constexpr Charge::value_type kFEE_LOG_AS_WARN = 3000; - static constexpr Charge::value_type kFEE_LOG_AS_INFO = 1000; - static constexpr Charge::value_type kFEE_LOG_AS_DEBUG = 100; + static constexpr Charge::value_type kFeeLogAsWarn = 3000; + static constexpr Charge::value_type kFeeLogAsInfo = 1000; + static constexpr Charge::value_type kFeeLogAsDebug = 100; static_assert( - kFEE_LOG_AS_WARN > kFEE_LOG_AS_INFO && kFEE_LOG_AS_INFO > kFEE_LOG_AS_DEBUG && - kFEE_LOG_AS_DEBUG > 10); + kFeeLogAsWarn > kFeeLogAsInfo && kFeeLogAsInfo > kFeeLogAsDebug && kFeeLogAsDebug > 10); - static auto kGET_STREAM = [](Resource::Charge::value_type cost, beast::Journal& journal) { - if (cost >= kFEE_LOG_AS_WARN) + static auto kGetStream = [](Resource::Charge::value_type cost, beast::Journal& journal) { + if (cost >= kFeeLogAsWarn) return journal.warn(); - if (cost >= kFEE_LOG_AS_INFO) + if (cost >= kFeeLogAsInfo) return journal.info(); - if (cost >= kFEE_LOG_AS_DEBUG) + if (cost >= kFeeLogAsDebug) return journal.debug(); return journal.trace(); }; @@ -447,8 +446,7 @@ public: std::scoped_lock const _(lock_); clock_type::time_point const now(clock_.now()); int const balance(entry.add(fee.cost(), now)); - JLOG(kGET_STREAM(fee.cost(), journal_)) - << "Charging " << entry << " for " << fee << context; + JLOG(kGetStream(fee.cost(), journal_)) << "Charging " << entry << " for " << fee << context; return disposition(balance); } @@ -461,9 +459,9 @@ 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()) >= kWarningThreshold && elapsed != entry.lastWarningTime) { - charge(entry, kFEE_WARNING); + charge(entry, kFeeWarning); notify = true; entry.lastWarningTime = elapsed; } @@ -485,15 +483,15 @@ public: bool drop(false); clock_type::time_point const now(clock_.now()); int const balance(entry.balance(now)); - if (balance >= DropThreshold) + if (balance >= kDropThreshold) { JLOG(journal_.warn()) << "Consumer entry " << entry << " dropped with balance " - << balance << " at or above drop threshold " << DropThreshold; + << balance << " at or above drop threshold " << kDropThreshold; // Adding feeDrop at this point keeps the dropped connection // from re-connecting for at least a little while after it is // dropped. - charge(entry, kFEE_DROP); + charge(entry, kFeeDrop); ++stats_.drop; drop = true; } @@ -522,8 +520,8 @@ public: item["count"] = entry.refcount; item["name"] = entry.toString(); item["balance"] = entry.balance(now); - if (entry.remote_balance != 0) - item["remote_balance"] = entry.remote_balance; + if (entry.remoteBalance != 0) + item["remote_balance"] = entry.remoteBalance; } } diff --git a/include/xrpl/resource/detail/Tuning.h b/include/xrpl/resource/detail/Tuning.h index 3452005c35..7b2046f45c 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 kWarningThreshold = 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 kDropThreshold = 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 kDecayWindowSeconds = 32; + +// minimum balance to include a load source in gossip +static constexpr auto kMinimumGossipBalance = 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 kSecondsUntilExpiration{300}; // Number of seconds until imported gossip expires -std::chrono::seconds constexpr kGOSSIP_EXPIRATION_SECONDS{30}; +static constexpr std::chrono::seconds kGossipExpirationSeconds{30}; } // namespace xrpl::Resource diff --git a/include/xrpl/server/Handoff.h b/include/xrpl/server/Handoff.h index eba8c6c4de..b80a9c5745 100644 --- a/include/xrpl/server/Handoff.h +++ b/include/xrpl/server/Handoff.h @@ -21,7 +21,7 @@ struct Handoff bool moved = false; // If response is set, this determines the keep alive - bool keep_alive = false; + bool keepAlive = false; // When set, this will be sent back std::shared_ptr response; diff --git a/include/xrpl/server/LoadFeeTrack.h b/include/xrpl/server/LoadFeeTrack.h index 5ad3972836..aa32e70ac8 100644 --- a/include/xrpl/server/LoadFeeTrack.h +++ b/include/xrpl/server/LoadFeeTrack.h @@ -63,7 +63,7 @@ public: static std::uint32_t getLoadBase() { - return kLFT_NORMAL_FEE; + return kLftNormalFee; } std::uint32_t @@ -100,29 +100,29 @@ public: isLoadedLocal() const { std::scoped_lock const sl(lock_); - return (raiseCount_ != 0) || (localTxnLoadFee_ != kLFT_NORMAL_FEE); + return (raiseCount_ != 0) || (localTxnLoadFee_ != kLftNormalFee); } bool isLoadedCluster() const { std::scoped_lock const sl(lock_); - return (raiseCount_ != 0) || (localTxnLoadFee_ != kLFT_NORMAL_FEE) || - (clusterTxnLoadFee_ != kLFT_NORMAL_FEE); + return (raiseCount_ != 0) || (localTxnLoadFee_ != kLftNormalFee) || + (clusterTxnLoadFee_ != kLftNormalFee); } private: - static std::uint32_t constexpr kLFT_NORMAL_FEE = 256; // 256 is the minimum/normal load factor - static std::uint32_t constexpr kLFT_FEE_INC_FRACTION = 4; // increase fee by 1/4 - static std::uint32_t constexpr kLFT_FEE_DEC_FRACTION = 4; // decrease fee by 1/4 - static std::uint32_t constexpr kLFT_FEE_MAX = kLFT_NORMAL_FEE * 1000000; + static constexpr std::uint32_t kLftNormalFee = 256; // 256 is the minimum/normal load factor + static constexpr std::uint32_t kLftFeeIncFraction = 4; // increase fee by 1/4 + static constexpr std::uint32_t kLftFeeDecFraction = 4; // decrease fee by 1/4 + static constexpr std::uint32_t kLftFeeMax = kLftNormalFee * 1000000; beast::Journal const j_; std::mutex mutable lock_; - std::uint32_t localTxnLoadFee_{kLFT_NORMAL_FEE}; // Scale factor, lftNormalFee = normal fee - std::uint32_t remoteTxnLoadFee_{kLFT_NORMAL_FEE}; // Scale factor, lftNormalFee = normal fee - std::uint32_t clusterTxnLoadFee_{kLFT_NORMAL_FEE}; // Scale factor, lftNormalFee = normal fee + std::uint32_t localTxnLoadFee_{kLftNormalFee}; // Scale factor, lftNormalFee = normal fee + std::uint32_t remoteTxnLoadFee_{kLftNormalFee}; // Scale factor, lftNormalFee = normal fee + std::uint32_t clusterTxnLoadFee_{kLftNormalFee}; // Scale factor, lftNormalFee = normal fee std::uint32_t raiseCount_{0}; }; diff --git a/include/xrpl/server/Port.h b/include/xrpl/server/Port.h index 9207e0552b..ac9b855cf0 100644 --- a/include/xrpl/server/Port.h +++ b/include/xrpl/server/Port.h @@ -30,19 +30,19 @@ struct Port boost::asio::ip::address ip; std::uint16_t port = 0; std::set protocol; - std::vector admin_nets_v4; - std::vector admin_nets_v6; - std::vector secure_gateway_nets_v4; - std::vector secure_gateway_nets_v6; + std::vector adminNetsV4; + std::vector adminNetsV6; + std::vector secureGatewayNetsV4; + std::vector secureGatewayNetsV6; std::string user; std::string password; - std::string admin_user; - std::string admin_password; - std::string ssl_key; - std::string ssl_cert; - std::string ssl_chain; - std::string ssl_ciphers; - boost::beast::websocket::permessage_deflate pmd_options; + std::string adminUser; + std::string adminPassword; + std::string sslKey; + std::string sslCert; + std::string sslChain; + std::string sslCiphers; + boost::beast::websocket::permessage_deflate pmdOptions; std::shared_ptr context; // How many incoming connections are allowed on this @@ -50,7 +50,7 @@ struct Port int limit = 0; // Websocket disconnects if send queue exceeds this limit - std::uint16_t ws_queue_limit{}; + std::uint16_t wsQueueLimit{}; // Returns `true` if any websocket protocols are specified [[nodiscard]] bool @@ -78,22 +78,22 @@ struct ParsedPort std::set protocol; std::string user; std::string password; - std::string admin_user; - std::string admin_password; - std::string ssl_key; - std::string ssl_cert; - std::string ssl_chain; - std::string ssl_ciphers; - boost::beast::websocket::permessage_deflate pmd_options; + std::string adminUser; + std::string adminPassword; + std::string sslKey; + std::string sslCert; + std::string sslChain; + std::string sslCiphers; + boost::beast::websocket::permessage_deflate pmdOptions; int limit = 0; - std::uint16_t ws_queue_limit{}; + std::uint16_t wsQueueLimit{}; std::optional ip; std::optional port; - std::vector admin_nets_v4; - std::vector admin_nets_v6; - std::vector secure_gateway_nets_v4; - std::vector secure_gateway_nets_v6; + std::vector adminNetsV4; + std::vector adminNetsV6; + std::vector secureGatewayNetsV4; + std::vector secureGatewayNetsV6; }; void diff --git a/include/xrpl/server/detail/BaseHTTPPeer.h b/include/xrpl/server/detail/BaseHTTPPeer.h index 0260cd6b84..d26817bc45 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 kBufferSize = 4 * 1024; // size of read/write buffer + static constexpr auto kTimeoutSeconds = 30; // max seconds without completing a message + static constexpr auto kTimeoutSecondsLocal = 3; // used for localhost clients struct Buffer { @@ -65,13 +58,13 @@ protected: Handler& handler_; boost::asio::executor_work_guard work_; boost::asio::strand strand_; - endpoint_type remote_address_; + endpoint_type remoteAddress_; beast::Journal const journal_; std::string id_; std::size_t nid_; - boost::asio::streambuf read_buf_; + boost::asio::streambuf readBuf_; http_request_type message_; std::vector wq_; std::vector wq2_; @@ -80,9 +73,9 @@ protected: bool complete_ = false; boost::system::error_code ec_; - int request_count_ = 0; - std::size_t bytes_in_ = 0; - std::size_t bytes_out_ = 0; + int requestCount_ = 0; + std::size_t bytesIn_ = 0; + std::size_t bytesOut_ = 0; //-------------------------------------------------------------------------- @@ -158,7 +151,7 @@ protected: beast::IP::Endpoint remoteAddress() override { - return beast::IPAddressConversion::fromAsio(remote_address_); + return beast::IPAddressConversion::fromAsio(remoteAddress_); } http_request_type& @@ -198,23 +191,23 @@ BaseHTTPPeer::BaseHTTPPeer( , handler_(handler) , work_(boost::asio::make_work_guard(executor)) , strand_(boost::asio::make_strand(executor)) - , remote_address_(std::move(remoteAddress)) + , remoteAddress_(std::move(remoteAddress)) , journal_(journal) { - read_buf_.commit( - boost::asio::buffer_copy(read_buf_.prepare(boost::asio::buffer_size(buffers)), buffers)); - static std::atomic kSID; - nid_ = ++kSID; + readBuf_.commit( + boost::asio::buffer_copy(readBuf_.prepare(boost::asio::buffer_size(buffers)), buffers)); + static std::atomic kSid; + nid_ = ++kSid; id_ = std::string("#") + std::to_string(nid_) + " "; - JLOG(journal_.trace()) << id_ << "accept: " << remote_address_.address(); + JLOG(journal_.trace()) << id_ << "accept: " << remoteAddress_.address(); } template BaseHTTPPeer::~BaseHTTPPeer() { handler_.onClose(session(), ec_); - JLOG(journal_.trace()) << id_ << "destroyed: " << request_count_ - << ((request_count_ == 1) ? " request" : " requests"); + JLOG(journal_.trace()) << id_ << "destroyed: " << requestCount_ + << ((requestCount_ == 1) ? " request" : " requests"); } template @@ -252,7 +245,7 @@ BaseHTTPPeer::startTimer() boost::beast::get_lowest_layer(impl().stream_) .expires_after( std::chrono::seconds( - remote_address_.address().is_loopback() ? TimeoutSecondsLocal : TimeoutSeconds)); + remoteAddress_.address().is_loopback() ? kTimeoutSecondsLocal : kTimeoutSeconds)); } // Convenience for discarding the error code @@ -281,7 +274,7 @@ BaseHTTPPeer::doRead(yield_context doYield) complete_ = false; error_code ec; startTimer(); - boost::beast::http::async_read(impl().stream_, read_buf_, message_, doYield[ec]); + boost::beast::http::async_read(impl().stream_, readBuf_, message_, doYield[ec]); cancelTimer(); if (ec == boost::beast::http::error::end_of_stream) return doClose(); @@ -303,7 +296,7 @@ BaseHTTPPeer::onWrite(error_code const& ec, std::size_t bytesTran return onTimer(); if (ec) return fail(ec, "write"); - bytes_out_ += bytesTransferred; + bytesOut_ += bytesTransferred; { std::scoped_lock const lock(mutex_); wq2_.clear(); @@ -364,7 +357,7 @@ BaseHTTPPeer::doWriter( for (;;) { - if (!writer->prepare(BufferSize, resume)) + if (!writer->prepare(kBufferSize, 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..edde28981c 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; @@ -27,7 +27,7 @@ protected: Port const& port_; Handler& handler_; - endpoint_type remote_address_; + endpoint_type remoteAddress_; beast::WrappedSink sink_; beast::Journal const j_; @@ -65,7 +65,7 @@ BasePeer::BasePeer( beast::Journal journal) : port_(port) , handler_(handler) - , remote_address_(std::move(remoteAddress)) + , remoteAddress_(std::move(remoteAddress)) , sink_( journal.sink(), [] { diff --git a/include/xrpl/server/detail/BaseWSPeer.h b/include/xrpl/server/detail/BaseWSPeer.h index 0d592ff09f..13225dcba1 100644 --- a/include/xrpl/server/detail/BaseWSPeer.h +++ b/include/xrpl/server/detail/BaseWSPeer.h @@ -42,15 +42,15 @@ private: /// The socket has been closed, or will close after the next write /// finishes. Do not do any more writes, and don't try to close /// again. - bool do_close_ = false; + bool doClose_ = false; boost::beast::websocket::close_reason cr_; waitable_timer timer_; - bool close_on_timer_ = false; - bool ping_active_ = false; + bool closeOnTimer_ = false; + bool pingActive_ = false; boost::beast::websocket::ping_data payload_; error_code ec_; std::function - control_callback_; + controlCallback_; public: template @@ -85,7 +85,7 @@ public: [[nodiscard]] boost::asio::ip::tcp::endpoint const& remoteEndpoint() const override { - return this->remote_address_; + return this->remoteAddress_; } void @@ -173,14 +173,14 @@ BaseWSPeer::run() { if (!strand_.running_in_this_thread()) return post(strand_, std::bind(&BaseWSPeer::run, impl().shared_from_this())); - impl().ws_.set_option(port().pmd_options); + impl().ws_.set_option(port().pmdOptions); // Must manage the control callback memory outside of the `control_callback` // function - control_callback_ = + controlCallback_ = std::bind(&BaseWSPeer::onPingPong, this, std::placeholders::_1, std::placeholders::_2); - impl().ws_.control_callback(control_callback_); + impl().ws_.control_callback(controlCallback_); startTimer(); - close_on_timer_ = true; + closeOnTimer_ = true; impl().ws_.set_option(boost::beast::websocket::stream_base::decorator([](auto& res) { res.set(boost::beast::http::field::server, BuildInfo::getFullVersionString()); })); @@ -198,9 +198,9 @@ BaseWSPeer::send(std::shared_ptr w) { if (!strand_.running_in_this_thread()) return post(strand_, std::bind(&BaseWSPeer::send, impl().shared_from_this(), std::move(w))); - if (do_close_) + if (doClose_) return; - if (wq_.size() > port().ws_queue_limit) + if (wq_.size() > port().wsQueueLimit) { cr_.code = safeCast(boost::beast::websocket::close_code::policy_error); cr_.reason = "Policy error: client is too slow."; @@ -227,9 +227,9 @@ BaseWSPeer::close(boost::beast::websocket::close_reason const& re { if (!strand_.running_in_this_thread()) return post(strand_, [self = impl().shared_from_this(), reason] { self->close(reason); }); - if (do_close_) + if (doClose_) return; - do_close_ = true; + doClose_ = true; if (wq_.empty()) { impl().ws_.async_close( @@ -260,7 +260,7 @@ BaseWSPeer::onWsHandshake(error_code const& ec) { if (ec) return fail(ec, "on_ws_handshake"); - close_on_timer_ = false; + closeOnTimer_ = false; doRead(); } @@ -313,7 +313,7 @@ BaseWSPeer::onWriteFin(error_code const& ec) if (ec) return fail(ec, "write_fin"); wq_.pop_front(); - if (do_close_) + if (doClose_) { impl().ws_.async_close( cr_, @@ -368,12 +368,12 @@ void BaseWSPeer::startTimer() { // Max seconds without completing a message - static constexpr std::chrono::seconds kTIMEOUT{30}; - static constexpr std::chrono::seconds kTIMEOUT_LOCAL{3}; + static constexpr std::chrono::seconds kTimeout{30}; + static constexpr std::chrono::seconds kTimeoutLocal{3}; try { - timer_.expires_after(remoteEndpoint().address().is_loopback() ? kTIMEOUT_LOCAL : kTIMEOUT); + timer_.expires_after(remoteEndpoint().address().is_loopback() ? kTimeoutLocal : kTimeout); } catch (boost::system::system_error const& e) { @@ -409,7 +409,7 @@ BaseWSPeer::onPing(error_code const& ec) { if (ec == boost::asio::error::operation_aborted) return; - ping_active_ = false; + pingActive_ = false; if (!ec) return; fail(ec, "on_ping"); @@ -426,7 +426,7 @@ BaseWSPeer::onPingPong( boost::beast::string_view const p(payload_.begin()); if (payload == p) { - close_on_timer_ = false; + closeOnTimer_ = false; JLOG(this->j_.trace()) << "got matching pong"; } else @@ -444,11 +444,11 @@ BaseWSPeer::onTimer(error_code ec) return; if (!ec) { - if (!close_on_timer_ || !ping_active_) + if (!closeOnTimer_ || !pingActive_) { startTimer(); - close_on_timer_ = true; - ping_active_ = true; + closeOnTimer_ = true; + pingActive_ = true; // cryptographic is probably overkill.. beast::rngfill(payload_.begin(), payload_.size(), cryptoPrng()); impl().ws_.async_ping( diff --git a/include/xrpl/server/detail/Door.h b/include/xrpl/server/detail/Door.h index 811bf68a74..79d36cae0c 100644 --- a/include/xrpl/server/detail/Door.h +++ b/include/xrpl/server/detail/Door.h @@ -23,7 +23,6 @@ #include #include -#include #endif #include @@ -39,7 +38,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 +52,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_; @@ -61,7 +60,7 @@ private: boost::asio::io_context& ioc_; stream_type stream_; socket_type& socket_; - endpoint_type remote_address_; + endpoint_type remoteAddress_; boost::asio::strand strand_; beast::Journal const j_; @@ -90,16 +89,19 @@ private: acceptor_type acceptor_; boost::asio::strand strand_; bool ssl_{ - port_.protocol.count("https") > 0 || port_.protocol.count("wss") > 0 || - port_.protocol.count("wss2") > 0 || port_.protocol.count("peer") > 0}; + port_.protocol.contains("https") || port_.protocol.contains("wss") || + port_.protocol.contains("wss2") || port_.protocol.contains("peer")}; bool plain_{ - port_.protocol.count("http") > 0 || port_.protocol.count("ws") > 0 || - (port_.protocol.count("ws2") != 0u)}; - static constexpr std::chrono::milliseconds kINITIAL_ACCEPT_DELAY{50}; - static constexpr std::chrono::milliseconds kMAX_ACCEPT_DELAY{2000}; - std::chrono::milliseconds accept_delay_{kINITIAL_ACCEPT_DELAY}; - boost::asio::steady_timer backoff_timer_; - static constexpr double kFREE_FD_THRESHOLD = 0.70; + port_.protocol.contains("http") || port_.protocol.contains("ws") || + (port_.protocol.contains("ws2"))}; + static constexpr std::chrono::milliseconds kInitialAcceptDelay{50}; + static constexpr std::chrono::milliseconds kMaxAcceptDelay{2000}; + std::chrono::milliseconds acceptDelay_{kInitialAcceptDelay}; + boost::asio::steady_timer backoffTimer_; + static constexpr std::uint64_t kMaxUsedFdPercent = 70; + static constexpr std::chrono::milliseconds kFdSampleInterval{250}; + clock_type::time_point fdSampleAt_; + bool cachedThrottle_{false}; struct FDStats { @@ -164,7 +166,7 @@ Door::Detector::Detector( , ioc_(ioc) , stream_(std::move(stream)) , socket_(stream_.socket()) - , remote_address_(std::move(remoteAddress)) + , remoteAddress_(std::move(remoteAddress)) , strand_(boost::asio::make_strand(ioc_)) , j_(j) { @@ -199,18 +201,18 @@ Door::Detector::doDetect(boost::asio::yield_context doYield) if (ssl) { if (auto sp = ios().template emplace>( - port_, handler_, ioc_, j_, remote_address_, buf.data(), std::move(stream_))) + port_, handler_, ioc_, j_, remoteAddress_, buf.data(), std::move(stream_))) sp->run(); return; } if (auto sp = ios().template emplace>( - port_, handler_, ioc_, j_, remote_address_, buf.data(), std::move(stream_))) + port_, handler_, ioc_, j_, remoteAddress_, buf.data(), std::move(stream_))) sp->run(); return; } if (ec != boost::asio::error::operation_aborted) { - JLOG(j_.trace()) << "Error detecting ssl: " << ec.message() << " from " << remote_address_; + JLOG(j_.trace()) << "Error detecting ssl: " << ec.message() << " from " << remoteAddress_; } } @@ -279,7 +281,8 @@ Door::Door( , ioc_(ioContext) , acceptor_(ioContext) , strand_(boost::asio::make_strand(ioContext)) - , backoff_timer_(ioContext) + , backoffTimer_(ioContext) + , fdSampleAt_(clock_type::now() - kFdSampleInterval) { reOpen(); } @@ -302,7 +305,7 @@ Door::close() return boost::asio::post( strand_, std::bind(&Door::close, this->shared_from_this())); } - backoff_timer_.cancel(); + backoffTimer_.cancel(); error_code ec; acceptor_.close(ec); } @@ -338,11 +341,11 @@ Door::doAccept(boost::asio::yield_context doYield) { if (shouldThrottleForFds()) { - backoff_timer_.expires_after(accept_delay_); + JLOG(j_.warn()) << "Throttling do_accept for " << acceptDelay_.count() << "ms."; + backoffTimer_.expires_after(acceptDelay_); boost::system::error_code tec; - backoff_timer_.async_wait(doYield[tec]); - accept_delay_ = std::min(accept_delay_ * 2, kMAX_ACCEPT_DELAY); - JLOG(j_.warn()) << "Throttling do_accept for " << accept_delay_.count() << "ms."; + backoffTimer_.async_wait(doYield[tec]); + acceptDelay_ = std::min(acceptDelay_ * 2, kMaxAcceptDelay); continue; } @@ -359,14 +362,17 @@ Door::doAccept(boost::asio::yield_context doYield) if (ec == boost::asio::error::no_descriptors || ec == boost::asio::error::no_buffer_space) { - JLOG(j_.warn()) << "accept: Too many open files. Pausing for " - << accept_delay_.count() << "ms."; + char const* const cause = (ec == boost::asio::error::no_descriptors) + ? "too many open files" + : "kernel buffer space exhausted"; + JLOG(j_.warn()) << "accept: " << cause << ". Pausing for " << acceptDelay_.count() + << "ms."; - backoff_timer_.expires_after(accept_delay_); + backoffTimer_.expires_after(acceptDelay_); boost::system::error_code tec; - backoff_timer_.async_wait(doYield[tec]); + backoffTimer_.async_wait(doYield[tec]); - accept_delay_ = std::min(accept_delay_ * 2, kMAX_ACCEPT_DELAY); + acceptDelay_ = std::min(acceptDelay_ * 2, kMaxAcceptDelay); } else { @@ -375,7 +381,7 @@ Door::doAccept(boost::asio::yield_context doYield) continue; } - accept_delay_ = kINITIAL_ACCEPT_DELAY; + acceptDelay_ = kInitialAcceptDelay; if (ssl_ && plain_) { @@ -403,11 +409,11 @@ Door::queryFdStats() const return std::nullopt; s.limit = static_cast(rl.rlim_cur); #if BOOST_OS_LINUX - constexpr char const* kFD_DIR = "/proc/self/fd"; + static constexpr char const* kFdDir = "/proc/self/fd"; #else - constexpr char const* kFD_DIR = "/dev/fd"; + static constexpr char const* kFdDir = "/dev/fd"; #endif - if (DIR* d = ::opendir(kFD_DIR)) + if (DIR* d = ::opendir(kFdDir)) { std::uint64_t cnt = 0; while (::readdir(d) != nullptr) @@ -428,14 +434,15 @@ Door::shouldThrottleForFds() #if BOOST_OS_WINDOWS return false; #else - auto const stats = queryFdStats(); - if (!stats || stats->limit == 0) - return false; + auto const now = clock_type::now(); + if (now - fdSampleAt_ < kFdSampleInterval) + return cachedThrottle_; - auto const& s = *stats; - auto const free = (s.limit > s.used) ? (s.limit - s.used) : 0ull; - double const freeRatio = static_cast(free) / static_cast(s.limit); - return freeRatio < kFREE_FD_THRESHOLD; + fdSampleAt_ = now; + auto const stats = queryFdStats(); + cachedThrottle_ = + stats && stats->limit > 0 && stats->used * 100 > stats->limit * kMaxUsedFdPercent; + return cachedThrottle_; #endif } diff --git a/include/xrpl/server/detail/PlainHTTPPeer.h b/include/xrpl/server/detail/PlainHTTPPeer.h index 40f7fe2571..791ab91acf 100644 --- a/include/xrpl/server/detail/PlainHTTPPeer.h +++ b/include/xrpl/server/detail/PlainHTTPPeer.h @@ -82,7 +82,7 @@ template void PlainHTTPPeer::run() { - if (!this->handler_.onAccept(this->session(), this->remote_address_)) + if (!this->handler_.onAccept(this->session(), this->remoteAddress_)) { util::spawn(this->strand_, std::bind(&PlainHTTPPeer::doClose, this->shared_from_this())); return; @@ -103,7 +103,7 @@ PlainHTTPPeer::websocketUpgrade() auto ws = this->ios().template emplace>( this->port_, this->handler_, - this->remote_address_, + this->remoteAddress_, std::move(this->message_), std::move(stream_), this->journal_); @@ -114,20 +114,20 @@ template void PlainHTTPPeer::doRequest() { - ++this->request_count_; + ++this->requestCount_; auto const what = - this->handler_.onHandoff(this->session(), std::move(this->message_), this->remote_address_); + this->handler_.onHandoff(this->session(), std::move(this->message_), this->remoteAddress_); if (what.moved) return; boost::system::error_code ec; if (what.response) { // half-close on Connection: close - if (!what.keep_alive) + if (!what.keepAlive) socket_.shutdown(socket_type::shutdown_receive, ec); if (ec) return this->fail(ec, "request"); - return this->write(what.response, what.keep_alive); + return this->write(what.response, what.keepAlive); } // Perform half-close when Connection: close and not SSL diff --git a/include/xrpl/server/detail/SSLHTTPPeer.h b/include/xrpl/server/detail/SSLHTTPPeer.h index 2eec8ed60f..f3b047150f 100644 --- a/include/xrpl/server/detail/SSLHTTPPeer.h +++ b/include/xrpl/server/detail/SSLHTTPPeer.h @@ -26,7 +26,7 @@ private: using yield_context = boost::asio::yield_context; using error_code = boost::system::error_code; - std::unique_ptr stream_ptr_; + std::unique_ptr streamPtr_; stream_type& stream_; socket_type& socket_; @@ -80,8 +80,8 @@ SSLHTTPPeer::SSLHTTPPeer( journal, remoteAddress, buffers) - , stream_ptr_(std::make_unique(middle_type(std::move(stream)), *port.context)) - , stream_(*stream_ptr_) + , streamPtr_(std::make_unique(middle_type(std::move(stream)), *port.context)) + , stream_(*streamPtr_) , socket_(stream_.next_layer().socket()) { } @@ -91,7 +91,7 @@ template void SSLHTTPPeer::run() { - if (!this->handler_.onAccept(this->session(), this->remote_address_)) + if (!this->handler_.onAccept(this->session(), this->remoteAddress_)) { util::spawn(this->strand_, std::bind(&SSLHTTPPeer::doClose, this->shared_from_this())); return; @@ -110,9 +110,9 @@ SSLHTTPPeer::websocketUpgrade() auto ws = this->ios().template emplace>( this->port_, this->handler_, - this->remote_address_, + this->remoteAddress_, std::move(this->message_), - std::move(this->stream_ptr_), + std::move(this->streamPtr_), this->journal_); return ws; } @@ -124,8 +124,8 @@ SSLHTTPPeer::doHandshake(yield_context doYield) boost::system::error_code ec; stream_.set_verify_mode(boost::asio::ssl::verify_none); this->startTimer(); - this->read_buf_.consume( - stream_.async_handshake(stream_type::server, this->read_buf_.data(), doYield[ec])); + this->readBuf_.consume( + stream_.async_handshake(stream_type::server, this->readBuf_.data(), doYield[ec])); this->cancelTimer(); if (ec == boost::beast::error::timeout) return this->onTimer(); @@ -148,13 +148,13 @@ template void SSLHTTPPeer::doRequest() { - ++this->request_count_; + ++this->requestCount_; auto const what = this->handler_.onHandoff( - this->session(), std::move(stream_ptr_), std::move(this->message_), this->remote_address_); + this->session(), std::move(streamPtr_), std::move(this->message_), this->remoteAddress_); if (what.moved) return; if (what.response) - return this->write(what.response, what.keep_alive); + return this->write(what.response, what.keepAlive); // legacy this->handler_.onRequest(this->session()); } diff --git a/include/xrpl/server/detail/SSLWSPeer.h b/include/xrpl/server/detail/SSLWSPeer.h index 19b77ea932..cb03d5a796 100644 --- a/include/xrpl/server/detail/SSLWSPeer.h +++ b/include/xrpl/server/detail/SSLWSPeer.h @@ -28,7 +28,7 @@ class SSLWSPeer : public BaseWSPeer>, using stream_type = boost::beast::ssl_stream; using waitable_timer = boost::asio::basic_waitable_timer; - std::unique_ptr stream_ptr_; + std::unique_ptr streamPtr_; boost::beast::websocket::stream ws_; public: @@ -61,8 +61,8 @@ SSLWSPeer::SSLWSPeer( remoteEndpoint, std::move(request), journal) - , stream_ptr_(std::move(streamPtr)) - , ws_(*stream_ptr_) + , streamPtr_(std::move(streamPtr)) + , ws_(*streamPtr_) { } diff --git a/include/xrpl/server/detail/ServerImpl.h b/include/xrpl/server/detail/ServerImpl.h index ce3a1c19c7..48ffa26cfe 100644 --- a/include/xrpl/server/detail/ServerImpl.h +++ b/include/xrpl/server/detail/ServerImpl.h @@ -62,13 +62,11 @@ 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 kHistorySize = 100; Handler& handler_; beast::Journal const j_; - boost::asio::io_context& io_context_; + boost::asio::io_context& ioContext_; boost::asio::strand strand_; std::optional> work_; @@ -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_; @@ -106,7 +104,7 @@ public: boost::asio::io_context& getIoContext() { - return io_context_; + return ioContext_; } bool @@ -124,9 +122,9 @@ ServerImpl::ServerImpl( beast::Journal journal) : handler_(handler) , j_(journal) - , io_context_(ioContext) - , strand_(boost::asio::make_strand(io_context_)) - , work_(std::in_place, boost::asio::make_work_guard(io_context_)) + , ioContext_(ioContext) + , strand_(boost::asio::make_strand(ioContext_)) + , work_(std::in_place, boost::asio::make_work_guard(ioContext_)) { } @@ -152,7 +150,7 @@ ServerImpl::ports(std::vector const& ports) { ports_.push_back(port); auto& internalPort = ports_.back(); - if (auto sp = ios_.emplace>(handler_, io_context_, internalPort, j_)) + if (auto sp = ios_.emplace>(handler_, ioContext_, internalPort, j_)) { list_.push_back(sp); diff --git a/include/xrpl/server/detail/Spawn.h b/include/xrpl/server/detail/Spawn.h index 50760be761..2560a2718b 100644 --- a/include/xrpl/server/detail/Spawn.h +++ b/include/xrpl/server/detail/Spawn.h @@ -25,7 +25,7 @@ concept IsStrand = std:: * * @param ePtr The exception that was caught on the coroutine */ -inline constexpr auto kPROPAGATE_EXCEPTIONS = [](std::exception_ptr ePtr) { +inline constexpr auto kPropagateExceptions = [](std::exception_ptr ePtr) { if (ePtr) { try @@ -50,7 +50,7 @@ inline constexpr auto kPROPAGATE_EXCEPTIONS = [](std::exception_ptr ePtr) { /** * @brief Spawns a coroutine using `boost::asio::spawn` * - * @note This uses kPROPAGATE_EXCEPTIONS to force asio to propagate exceptions + * @note This uses kPropagateExceptions to force asio to propagate exceptions * through `io_context` * @note Since implicit strand was removed from boost::asio::spawn this helper * function adds the strand back @@ -68,14 +68,14 @@ spawn(Ctx&& ctx, F&& func) if constexpr (impl::IsStrand) { boost::asio::spawn( - std::forward(ctx), std::forward(func), impl::kPROPAGATE_EXCEPTIONS); + std::forward(ctx), std::forward(func), impl::kPropagateExceptions); } else { boost::asio::spawn( boost::asio::make_strand(boost::asio::get_associated_executor(std::forward(ctx))), std::forward(func), - impl::kPROPAGATE_EXCEPTIONS); + impl::kPropagateExceptions); } } 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..07290dfbd1 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 kDefaultCacheTargetSize = 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 = kDefaultCacheTargetSize, std::chrono::seconds expiration = std::chrono::minutes{2}) : cache_(name, targetSize, expiration, clock, j, collector), gen_(1) { diff --git a/include/xrpl/shamap/README.md b/include/xrpl/shamap/README.md index ae37d23ac3..8931a1b50c 100644 --- a/include/xrpl/shamap/README.md +++ b/include/xrpl/shamap/README.md @@ -231,7 +231,7 @@ The `fetchNodeNT()` method goes through three phases: will be 0. 2. If the node is not in the TreeNodeCache, we attempt to locate the node - in the historic data stored by the data base. The call to to + in the historic data stored by the data base. The call to `fetchNodeFromDB(hash)` does that work for us. 3. Finally if a filter exists, we check if it can supply the node. This is diff --git a/include/xrpl/shamap/SHAMap.h b/include/xrpl/shamap/SHAMap.h index ba48e1927b..f63fc95b27 100644 --- a/include/xrpl/shamap/SHAMap.h +++ b/include/xrpl/shamap/SHAMap.h @@ -94,10 +94,10 @@ private: public: /** Number of children each non-leaf node has (the 'radix tree' part of the * map) */ - static constexpr unsigned int kBRANCH_FACTOR = SHAMapInnerNode::kBRANCH_FACTOR; + static constexpr unsigned int kBranchFactor = SHAMapInnerNode::kBranchFactor; /** The depth of the hash map: data is only present in the leaves */ - static constexpr unsigned int kLEAF_DEPTH = 64; + static constexpr unsigned int kLeafDepth = 64; using DeltaItem = std::pair, boost::intrusive_ptr>; @@ -390,7 +390,7 @@ private: lastBelow( intr_ptr::SharedPtr node, SharedPtrNodeStack& stack, - int branch = kBRANCH_FACTOR) const; + int branch = kBranchFactor) const; // helper function for firstBelow and lastBelow SHAMapLeafNode* @@ -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/SHAMapAccountStateLeafNode.h b/include/xrpl/shamap/SHAMapAccountStateLeafNode.h index c006b2de37..c67b32d4e7 100644 --- a/include/xrpl/shamap/SHAMapAccountStateLeafNode.h +++ b/include/xrpl/shamap/SHAMapAccountStateLeafNode.h @@ -50,7 +50,7 @@ public: { s.addRaw(item_->slice()); s.addBitString(item_->key()); - s.add8(kWIRE_TYPE_ACCOUNT_STATE); + s.add8(kWireTypeAccountState); } void diff --git a/include/xrpl/shamap/SHAMapInnerNode.h b/include/xrpl/shamap/SHAMapInnerNode.h index ee2a18bf03..48416a93e6 100644 --- a/include/xrpl/shamap/SHAMapInnerNode.h +++ b/include/xrpl/shamap/SHAMapInnerNode.h @@ -15,7 +15,7 @@ class SHAMapInnerNode final : public SHAMapTreeNode, public CountedObject 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..ee74155ac4 100644 --- a/include/xrpl/shamap/SHAMapTreeNode.h +++ b/include/xrpl/shamap/SHAMapTreeNode.h @@ -7,6 +7,7 @@ #include #include +#include #include #include @@ -14,11 +15,14 @@ namespace xrpl { // These are wire-protocol identifiers used during serialization to encode the // type of a node. They should not be arbitrarily be changed. -static constexpr unsigned char const kWIRE_TYPE_TRANSACTION = 0; -static constexpr unsigned char const kWIRE_TYPE_ACCOUNT_STATE = 1; -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; +static constexpr unsigned char const kWireTypeTransaction = 0; +static constexpr unsigned char const kWireTypeAccountState = 1; +static constexpr unsigned char const kWireTypeInner = 2; +static constexpr unsigned char const kWireTypeCompressedInner = 3; +static constexpr unsigned char const kWireTypeTransactionWithMeta = 4; + +// Lower bound on SHAMap leaf item payload size, in bytes. +inline constexpr std::size_t kMinShaMapItemBytes = 12; enum class SHAMapNodeType { TnInner = 1, diff --git a/include/xrpl/shamap/SHAMapTxLeafNode.h b/include/xrpl/shamap/SHAMapTxLeafNode.h index eaac104c7e..72be5b1962 100644 --- a/include/xrpl/shamap/SHAMapTxLeafNode.h +++ b/include/xrpl/shamap/SHAMapTxLeafNode.h @@ -48,7 +48,7 @@ public: serializeForWire(Serializer& s) const final { s.addRaw(item_->slice()); - s.add8(kWIRE_TYPE_TRANSACTION); + s.add8(kWireTypeTransaction); } void diff --git a/include/xrpl/shamap/SHAMapTxPlusMetaLeafNode.h b/include/xrpl/shamap/SHAMapTxPlusMetaLeafNode.h index 5cf5b723b0..44562aeaba 100644 --- a/include/xrpl/shamap/SHAMapTxPlusMetaLeafNode.h +++ b/include/xrpl/shamap/SHAMapTxPlusMetaLeafNode.h @@ -50,7 +50,7 @@ public: { s.addRaw(item_->slice()); s.addBitString(item_->key()); - s.add8(kWIRE_TYPE_TRANSACTION_WITH_META); + s.add8(kWireTypeTransactionWithMeta); } void diff --git a/include/xrpl/shamap/detail/TaggedPointer.h b/include/xrpl/shamap/detail/TaggedPointer.h index d3c0a6542f..94dbe95284 100644 --- a/include/xrpl/shamap/detail/TaggedPointer.h +++ b/include/xrpl/shamap/detail/TaggedPointer.h @@ -47,9 +47,9 @@ private: */ std::uintptr_t tp_ = 0; /** bit-and with this mask to get the tag bits (lowest two bits) */ - static constexpr std::uintptr_t kTAG_MASK = 3; + static constexpr std::uintptr_t kTagMask = 3; /** bit-and with this mask to get the pointer bits (mask out the tag) */ - static constexpr std::uintptr_t kPTR_MASK = ~kTAG_MASK; + static constexpr std::uintptr_t kPtrMask = ~kTagMask; /** Deallocate memory and run destructors */ void @@ -205,7 +205,7 @@ popcnt16(std::uint16_t a) return __builtin_popcount(a); #else // fallback to table lookup - static auto constexpr const tbl = []() { + static constexpr auto tbl = []() { std::array ret{}; for (int i = 0; i != 256; ++i) { diff --git a/include/xrpl/shamap/detail/TaggedPointer.ipp b/include/xrpl/shamap/detail/TaggedPointer.ipp index d4b5ca3365..2e6e31fed8 100644 --- a/include/xrpl/shamap/detail/TaggedPointer.ipp +++ b/include/xrpl/shamap/detail/TaggedPointer.ipp @@ -14,130 +14,130 @@ namespace { // Given n children, an array of size `*std::lower_bound(boundaries.begin(), // boundaries.end(), n);` is used to store the children. Note that the last // element must be the number of children in a dense array. -constexpr std::array kBOUNDARIES{2, 4, 6, SHAMapInnerNode::kBRANCH_FACTOR}; +constexpr std::array kBoundaries{2, 4, 6, SHAMapInnerNode::kBranchFactor}; static_assert( - kBOUNDARIES.size() <= 4, + kBoundaries.size() <= 4, "The hashesAndChildren member uses a tagged array format with two bits " "reserved for the tag. This supports at most 4 values."); static_assert( - kBOUNDARIES.back() == SHAMapInnerNode::kBRANCH_FACTOR, + kBoundaries.back() == SHAMapInnerNode::kBranchFactor, "Last element of boundaries must be number of children in a dense array"); // Terminology: A chunk is the memory being allocated from a block. A block // contains multiple chunks. This is the terminology the boost documentation // uses. Pools use "Simple Segregated Storage" as their storage format. -constexpr size_t kELEMENT_SIZE_BYTES = +constexpr size_t kElementSizeBytes = (sizeof(SHAMapHash) + sizeof(intr_ptr::SharedPtr)); -constexpr size_t kBLOCK_SIZE_BYTES = kilobytes(512); +constexpr size_t kBlockSizeBytes = kilobytes(512); template -constexpr std::array +constexpr std::array initArrayChunkSizeBytes(std::index_sequence) { - return std::array{ - kBOUNDARIES[I] * kELEMENT_SIZE_BYTES..., + return std::array{ + kBoundaries[I] * kElementSizeBytes..., }; } -constexpr auto kARRAY_CHUNK_SIZE_BYTES = - initArrayChunkSizeBytes(std::make_index_sequence{}); +constexpr auto kArrayChunkSizeBytes = + initArrayChunkSizeBytes(std::make_index_sequence{}); template -constexpr std::array +constexpr std::array initArrayChunksPerBlock(std::index_sequence) { - return std::array{ - kBLOCK_SIZE_BYTES / kARRAY_CHUNK_SIZE_BYTES[I]..., + return std::array{ + kBlockSizeBytes / kArrayChunkSizeBytes[I]..., }; } -constexpr auto kCHUNKS_PER_BLOCK = - initArrayChunksPerBlock(std::make_index_sequence{}); +constexpr auto kChunksPerBlock = + initArrayChunksPerBlock(std::make_index_sequence{}); [[nodiscard]] inline std::uint8_t numAllocatedChildren(std::uint8_t n) { - XRPL_ASSERT(n <= SHAMapInnerNode::kBRANCH_FACTOR, "xrpl::numAllocatedChildren : valid input"); - return *std::ranges::lower_bound(kBOUNDARIES, n); + XRPL_ASSERT(n <= SHAMapInnerNode::kBranchFactor, "xrpl::numAllocatedChildren : valid input"); + return *std::ranges::lower_bound(kBoundaries, n); } [[nodiscard]] inline std::size_t boundariesIndex(std::uint8_t numChildren) { XRPL_ASSERT( - numChildren <= SHAMapInnerNode::kBRANCH_FACTOR, "xrpl::boundariesIndex : valid input"); - return std::distance(kBOUNDARIES.begin(), std::ranges::lower_bound(kBOUNDARIES, numChildren)); + numChildren <= SHAMapInnerNode::kBranchFactor, "xrpl::boundariesIndex : valid input"); + return std::distance(kBoundaries.begin(), std::ranges::lower_bound(kBoundaries, numChildren)); } template -std::array, kBOUNDARIES.size()> +std::array, kBoundaries.size()> initAllocateArrayFuns(std::index_sequence) { - return std::array, kBOUNDARIES.size()>{ + return std::array, kBoundaries.size()>{ boost::singleton_pool< boost::fast_pool_allocator_tag, - kARRAY_CHUNK_SIZE_BYTES[I], + kArrayChunkSizeBytes[I], boost::default_user_allocator_new_delete, std::mutex, - kCHUNKS_PER_BLOCK[I], - kCHUNKS_PER_BLOCK[I]>::malloc..., + kChunksPerBlock[I], + kChunksPerBlock[I]>::malloc..., }; } -std::array, kBOUNDARIES.size()> const kALLOCATE_ARRAY_FUNS = - initAllocateArrayFuns(std::make_index_sequence{}); +std::array, kBoundaries.size()> const kAllocateArrayFuns = + initAllocateArrayFuns(std::make_index_sequence{}); template -std::array, kBOUNDARIES.size()> +std::array, kBoundaries.size()> initFreeArrayFuns(std::index_sequence) { - return std::array, kBOUNDARIES.size()>{ + return std::array, kBoundaries.size()>{ static_cast(boost::singleton_pool< boost::fast_pool_allocator_tag, - kARRAY_CHUNK_SIZE_BYTES[I], + kArrayChunkSizeBytes[I], boost::default_user_allocator_new_delete, std::mutex, - kCHUNKS_PER_BLOCK[I], - kCHUNKS_PER_BLOCK[I]>::free)..., + kChunksPerBlock[I], + kChunksPerBlock[I]>::free)..., }; } -std::array, kBOUNDARIES.size()> const kFREE_ARRAY_FUNS = - initFreeArrayFuns(std::make_index_sequence{}); +std::array, kBoundaries.size()> const kFreeArrayFuns = + initFreeArrayFuns(std::make_index_sequence{}); template -std::array, kBOUNDARIES.size()> +std::array, kBoundaries.size()> initIsFromArrayFuns(std::index_sequence) { - return std::array, kBOUNDARIES.size()>{ + return std::array, kBoundaries.size()>{ boost::singleton_pool< boost::fast_pool_allocator_tag, - kARRAY_CHUNK_SIZE_BYTES[I], + kArrayChunkSizeBytes[I], boost::default_user_allocator_new_delete, std::mutex, - kCHUNKS_PER_BLOCK[I], - kCHUNKS_PER_BLOCK[I]>::is_from..., + kChunksPerBlock[I], + kChunksPerBlock[I]>::is_from..., }; } -std::array, kBOUNDARIES.size()> const kIS_FROM_ARRAY_FUNS = - initIsFromArrayFuns(std::make_index_sequence{}); +std::array, kBoundaries.size()> const kIsFromArrayFuns = + initIsFromArrayFuns(std::make_index_sequence{}); // This function returns an untagged pointer [[nodiscard]] inline std::pair allocateArrays(std::uint8_t numChildren) { auto const i = boundariesIndex(numChildren); - return {i, kALLOCATE_ARRAY_FUNS[i]()}; + return {i, kAllocateArrayFuns[i]()}; } // This function takes an untagged pointer inline void deallocateArrays(std::uint8_t boundaryIndex, void* p) { - XRPL_ASSERT(kIS_FROM_ARRAY_FUNS[boundaryIndex](p), "xrpl::deallocateArrays : valid inputs"); - kFREE_ARRAY_FUNS[boundaryIndex](p); + XRPL_ASSERT(kIsFromArrayFuns[boundaryIndex](p), "xrpl::deallocateArrays : valid inputs"); + kFreeArrayFuns[boundaryIndex](p); } // Used in `iterChildren` and elsewhere as the hash value for sparse arrays when // the hash isn't actually stored in the array. -SHAMapHash const kZERO_SHA_MAP_HASH; +SHAMapHash const kZeroShaMapHash; } // namespace @@ -146,17 +146,17 @@ void TaggedPointer::iterChildren(std::uint16_t isBranch, F&& f) const { auto [numAllocated, hashes, _] = getHashesAndChildren(); - if (numAllocated == SHAMapInnerNode::kBRANCH_FACTOR) + if (numAllocated == SHAMapInnerNode::kBranchFactor) { // dense case - for (int i = 0; i < SHAMapInnerNode::kBRANCH_FACTOR; ++i) + for (int i = 0; i < SHAMapInnerNode::kBranchFactor; ++i) f(hashes[i]); } else { // sparse case int curHashI = 0; - for (int i = 0; i < SHAMapInnerNode::kBRANCH_FACTOR; ++i) + for (int i = 0; i < SHAMapInnerNode::kBranchFactor; ++i) { if ((1 << i) & isBranch) { @@ -164,7 +164,7 @@ TaggedPointer::iterChildren(std::uint16_t isBranch, F&& f) const } else { - f(kZERO_SHA_MAP_HASH); + f(kZeroShaMapHash); } } } @@ -174,10 +174,10 @@ template void TaggedPointer::iterNonEmptyChildIndexes(std::uint16_t isBranch, F&& f) const { - if (capacity() == SHAMapInnerNode::kBRANCH_FACTOR) + if (capacity() == SHAMapInnerNode::kBranchFactor) { // dense case - for (int i = 0; i < SHAMapInnerNode::kBRANCH_FACTOR; ++i) + for (int i = 0; i < SHAMapInnerNode::kBranchFactor; ++i) { if ((1 << i) & isBranch) { @@ -189,7 +189,7 @@ TaggedPointer::iterNonEmptyChildIndexes(std::uint16_t isBranch, F&& f) const { // sparse case int curHashI = 0; - for (int i = 0; i < SHAMapInnerNode::kBRANCH_FACTOR; ++i) + for (int i = 0; i < SHAMapInnerNode::kBranchFactor; ++i) { if ((1 << i) & isBranch) { @@ -247,11 +247,11 @@ inline TaggedPointer::TaggedPointer(RawAllocateTag, std::uint8_t numChildren) { auto [tag, p] = allocateArrays(numChildren); XRPL_ASSERT( - tag < kBOUNDARIES.size(), + tag < kBoundaries.size(), "xrpl::TaggedPointer::TaggedPointer(RawAllocateTag, std::uint8_t) : " "maximum tag"); XRPL_ASSERT( - (reinterpret_cast(p) & kPTR_MASK) == reinterpret_cast(p), + (reinterpret_cast(p) & kPtrMask) == reinterpret_cast(p), "xrpl::TaggedPointer::TaggedPointer(RawAllocateTag, std::uint8_t) : " "valid pointer"); tp_ = reinterpret_cast(p) + tag; @@ -275,7 +275,7 @@ inline TaggedPointer::TaggedPointer( auto [srcDstNumAllocated, srcDstHashes, srcDstChildren] = getHashesAndChildren(); bool const srcDstIsDense = isDense(); int srcDstIndex = 0; - for (int i = 0; i < SHAMapInnerNode::kBRANCH_FACTOR; ++i) + for (int i = 0; i < SHAMapInnerNode::kBranchFactor; ++i) { auto const mask = (1 << i); bool const inSrc = (srcBranches & mask) != 0; @@ -354,7 +354,7 @@ inline TaggedPointer::TaggedPointer( bool const srcIsDense = src.isDense(); bool const dstIsDense = dst.isDense(); int srcIndex = 0, dstIndex = 0; - for (int i = 0; i < SHAMapInnerNode::kBRANCH_FACTOR; ++i) + for (int i = 0; i < SHAMapInnerNode::kBranchFactor; ++i) { auto const mask = (1 << i); bool const inSrc = (srcBranches & mask) != 0; @@ -440,7 +440,7 @@ inline TaggedPointer::TaggedPointer( std::tie(newNumAllocated, newHashes, newChildren) = newHashesAndChildren.getHashesAndChildren(); std::tie(std::ignore, oldHashes, oldChildren) = getHashesAndChildren(); - if (newNumAllocated == SHAMapInnerNode::kBRANCH_FACTOR) + if (newNumAllocated == SHAMapInnerNode::kBranchFactor) { // new arrays are dense, old arrays are sparse iterNonEmptyChildIndexes(isBranch, [&](auto branchNum, auto indexNum) { @@ -449,7 +449,7 @@ inline TaggedPointer::TaggedPointer( intr_ptr::SharedPtr{std::move(oldChildren[indexNum])}; }); // Run the constructors for the remaining elements - for (int i = 0; i < SHAMapInnerNode::kBRANCH_FACTOR; ++i) + for (int i = 0; i < SHAMapInnerNode::kBranchFactor; ++i) { if (((1 << i) & isBranch) != 0) continue; @@ -508,19 +508,19 @@ TaggedPointer::operator=(TaggedPointer&& other) [[nodiscard]] inline std::pair TaggedPointer::decode() const { - return {tp_ & kTAG_MASK, reinterpret_cast(tp_ & kPTR_MASK)}; + return {tp_ & kTagMask, reinterpret_cast(tp_ & kPtrMask)}; } [[nodiscard]] inline std::uint8_t TaggedPointer::capacity() const { - return kBOUNDARIES[tp_ & kTAG_MASK]; + return kBoundaries[tp_ & kTagMask]; } [[nodiscard]] inline bool TaggedPointer::isDense() const { - return (tp_ & kTAG_MASK) == kBOUNDARIES.size() - 1; + return (tp_ & kTagMask) == kBoundaries.size() - 1; } [[nodiscard]] inline std::tuple*> @@ -528,7 +528,7 @@ TaggedPointer::getHashesAndChildren() const { auto const [tag, ptr] = decode(); auto const hashes = reinterpret_cast(ptr); - std::uint8_t const numAllocated = kBOUNDARIES[tag]; + std::uint8_t const numAllocated = kBoundaries[tag]; auto const children = reinterpret_cast*>(hashes + numAllocated); return {numAllocated, hashes, children}; @@ -537,7 +537,7 @@ TaggedPointer::getHashesAndChildren() const [[nodiscard]] inline SHAMapHash* TaggedPointer::getHashes() const { - return reinterpret_cast(tp_ & kPTR_MASK); + return reinterpret_cast(tp_ & kPtrMask); }; [[nodiscard]] inline intr_ptr::SharedPtr* diff --git a/include/xrpl/tx/Transactor.h b/include/xrpl/tx/Transactor.h index cf8030b275..1440a5097f 100644 --- a/include/xrpl/tx/Transactor.h +++ b/include/xrpl/tx/Transactor.h @@ -115,7 +115,7 @@ protected: beast::WrappedSink sink_; beast::Journal const j_; - AccountID const account_; + AccountID const accountID_; XRPAmount preFeeBalance_{}; // Balance before fees. public: @@ -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 @@ -399,6 +398,15 @@ private: static NotTEC preflight2(PreflightContext const& ctx); + /** Universal validations + - Valid MPTAmount and XRPAmount + + Do not try to call preflightUniversal from preflight() in derived classes. See + the description of invokePreflight for details. + */ + static NotTEC + preflightUniversal(PreflightContext const& ctx); + /** Check transaction-specific invariants only. * * Walks every modified ledger entry via visitInvariantEntry, then @@ -464,6 +472,9 @@ Transactor::invokePreflight(PreflightContext const& ctx) if (auto const ret = preflight1(ctx, T::getFlagsMask(ctx))) return ret; + if (auto const ret = preflightUniversal(ctx)) + return ret; + if (auto const ret = T::preflight(ctx)) return ret; diff --git a/include/xrpl/tx/invariants/DirectoryInvariant.h b/include/xrpl/tx/invariants/DirectoryInvariant.h new file mode 100644 index 0000000000..96643ea465 --- /dev/null +++ b/include/xrpl/tx/invariants/DirectoryInvariant.h @@ -0,0 +1,27 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +#include + +namespace xrpl { + +class ValidBookDirectory +{ + bool badBookDirectory_ = false; + hash_set rootIndexes_; + +public: + void + visitEntry(bool, std::shared_ptr const&, std::shared_ptr const&); + + bool + finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&); +}; + +} // namespace xrpl diff --git a/include/xrpl/tx/invariants/InvariantCheck.h b/include/xrpl/tx/invariants/InvariantCheck.h index bc9608fd56..d4c0154269 100644 --- a/include/xrpl/tx/invariants/InvariantCheck.h +++ b/include/xrpl/tx/invariants/InvariantCheck.h @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -372,6 +373,21 @@ public: finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&); }; +/** Verify that MPT/XRP STAmounts are canonical in any ledger entries left after the + * transaction applies. + */ +class ValidAmounts +{ + std::vector> afterEntries_; + +public: + void + visitEntry(bool, std::shared_ptr const&, std::shared_ptr const&); + + [[nodiscard]] bool + finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&) const; +}; + // additional invariant checks can be declared above and then added to this // tuple using InvariantChecks = std::tuple< @@ -393,13 +409,16 @@ using InvariantChecks = std::tuple< ValidMPTIssuance, ValidPermissionedDomain, ValidPermissionedDEX, + ValidBookDirectory, ValidAMM, NoModifiedUnmodifiableFields, ValidPseudoAccounts, ValidLoanBroker, ValidLoan, ValidVault, - ValidMPTPayment>; + ValidMPTPayment, + ValidAmounts, + ValidMPTTransfer>; /** * @brief get a tuple of all invariant checks 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/MPTInvariant.h b/include/xrpl/tx/invariants/MPTInvariant.h index 7f405814e7..becb752126 100644 --- a/include/xrpl/tx/invariants/MPTInvariant.h +++ b/include/xrpl/tx/invariants/MPTInvariant.h @@ -2,10 +2,13 @@ #include #include +#include #include #include #include +#include +#include namespace xrpl { @@ -20,6 +23,18 @@ class ValidMPTIssuance // MPToken by an issuer bool mptCreatedByIssuer_ = false; + /// sfReferenceHolding is intended to be set exactly once at vault + /// creation and immutable thereafter; true when that rule was violated. + bool referenceHoldingSetOnCreate_ = false; + + /// True when sfReferenceHolding was mutated on an existing MPTokenIssuance. + bool referenceHoldingMutated_ = false; + + /// MPTokens and RippleStates deleted during apply. finalize() checks each + /// holder's AccountRoot to detect vault pseudo-account holdings deleted + /// outside VaultDelete. All these checks are gated on fixCleanup3_2_0. + std::vector> deletedHoldings_; + public: void visitEntry(bool, std::shared_ptr const&, std::shared_ptr const&); @@ -56,4 +71,42 @@ public: finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&); }; +class ValidMPTTransfer +{ + struct Value + { + std::optional amtBefore; + std::optional amtAfter; + }; + // MPTID: {holder: Value} + hash_map> amount_; + // Deleted MPToken + // MPToken key: true if MPTAuthorized is set + hash_map deletedAuthorized_; + +public: + void + visitEntry(bool, std::shared_ptr const&, std::shared_ptr const&); + + bool + finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&); + +private: + /** + * @brief Check whether a holder is authorized to send or receive an MPToken. + * + * Deleted MPToken SLEs are no longer present in the view by the time + * finalize() runs, so their authorization state is captured during + * visitEntry() and stored in deletedAuthorized_. For deleted MPTokens, + * returns true if reqAuth is false or lsfMPTAuthorized was set at deletion. + * For existing MPTokens, returns the result of requireAuth() + */ + [[nodiscard]] bool + isAuthorized( + ReadView const& view, + MPTID const& mptid, + AccountID const& holder, + bool requireAuth) const; +}; + } // namespace xrpl diff --git a/include/xrpl/tx/invariants/PermissionedDEXInvariant.h b/include/xrpl/tx/invariants/PermissionedDEXInvariant.h index da187779b2..654ed3e009 100644 --- a/include/xrpl/tx/invariants/PermissionedDEXInvariant.h +++ b/include/xrpl/tx/invariants/PermissionedDEXInvariant.h @@ -10,9 +10,10 @@ 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 regularOffersOld_ = false; // pre-fixCleanup3_2_0: also flags deleted offers + bool regularOffers_ = false; // post-fixCleanup3_2_0: excludes deleted offers + 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/invariants/VaultInvariant.h b/include/xrpl/tx/invariants/VaultInvariant.h index 7ca67f546d..ab55cd086a 100644 --- a/include/xrpl/tx/invariants/VaultInvariant.h +++ b/include/xrpl/tx/invariants/VaultInvariant.h @@ -35,15 +35,15 @@ namespace xrpl { */ class ValidVault { - Number static constexpr kZERO{}; + static constexpr Number kZero{}; struct Vault final { - uint256 key = beast::kZERO; + uint256 key = beast::kZero; Asset asset; AccountID pseudoId; AccountID owner; - uint192 shareMPTID = beast::kZERO; + uint192 shareMPTID = beast::kZero; Number assetsTotal = 0; Number assetsAvailable = 0; Number assetsMaximum = 0; @@ -64,7 +64,7 @@ class ValidVault public: struct DeltaInfo final { - Number delta = kNUM_ZERO; + Number delta = kNumZero; std::optional scale; // Compute the delta between two Numbers, taking the coarsest scale diff --git a/include/xrpl/tx/paths/AMMLiquidity.h b/include/xrpl/tx/paths/AMMLiquidity.h index 3211d0caa7..9abe37f868 100644 --- a/include/xrpl/tx/paths/AMMLiquidity.h +++ b/include/xrpl/tx/paths/AMMLiquidity.h @@ -31,7 +31,7 @@ template class AMMLiquidity { private: - inline static Number const kINITIAL_FIB_SEQ_PCT = Number(5) / 20000; + inline static Number const kInitialFibSeqPct = Number(5) / 20000; AMMContext& ammContext_; AccountID const ammAccountID_; std::uint32_t const tradingFee_; diff --git a/include/xrpl/tx/paths/Offer.h b/include/xrpl/tx/paths/Offer.h index 0a551f4c2d..2dab5bcebf 100644 --- a/include/xrpl/tx/paths/Offer.h +++ b/include/xrpl/tx/paths/Offer.h @@ -21,7 +21,7 @@ class TOffer private: SLE::pointer entry_; Quality quality_{}; - AccountID account_; + AccountID accountID_; Asset assetIn_; Asset assetOut_; @@ -53,7 +53,7 @@ public: [[nodiscard]] AccountID const& owner() const { - return account_; + return accountID_; } /** Returns the in and out amounts. @@ -69,9 +69,9 @@ public: [[nodiscard]] bool fullyConsumed() const { - if (amounts_.in <= beast::kZERO) + if (amounts_.in <= beast::kZero) return true; - if (amounts_.out <= beast::kZERO) + if (amounts_.out <= beast::kZero) return true; return false; } @@ -122,7 +122,7 @@ public: isFunded() const { // Offer owner is issuer; they have unlimited funds if IOU - return account_ == assetOut_.getIssuer() && assetOut_.holds(); + return accountID_ == assetOut_.getIssuer() && assetOut_.holds(); } static std::pair @@ -159,7 +159,7 @@ public: template TOffer::TOffer(SLE::pointer entry, Quality quality) - : entry_(std::move(entry)), quality_(quality), account_(entry_->getAccountID(sfAccount)) + : entry_(std::move(entry)), quality_(quality), accountID_(entry_->getAccountID(sfAccount)) { auto const tp = entry_->getFieldAmount(sfTakerPays); auto const tg = entry_->getFieldAmount(sfTakerGets); 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/paths/detail/Steps.h b/include/xrpl/tx/paths/detail/Steps.h index db9d3a6f3a..9909c4bdcd 100644 --- a/include/xrpl/tx/paths/detail/Steps.h +++ b/include/xrpl/tx/paths/detail/Steps.h @@ -460,7 +460,7 @@ public: [[nodiscard]] bool isZero(EitherAmount const& out) const override { - return get(out) == beast::kZERO; + return get(out) == beast::kZero; } [[nodiscard]] bool diff --git a/include/xrpl/tx/paths/detail/StrandFlow.h b/include/xrpl/tx/paths/detail/StrandFlow.h index f69e10e99a..31f0182258 100644 --- a/include/xrpl/tx/paths/detail/StrandFlow.h +++ b/include/xrpl/tx/paths/detail/StrandFlow.h @@ -28,8 +28,8 @@ template struct StrandResult { bool success = false; ///< Strand succeeded - TInAmt in = beast::kZERO; ///< Currency amount in - TOutAmt out = beast::kZERO; ///< Currency amount out + TInAmt in = beast::kZero; ///< Currency amount in + TOutAmt out = beast::kZero; ///< Currency amount out std::optional sandbox; ///< Resulting Sandbox state boost::container::flat_set ofrsToRm; ///< Offers to remove // Num offers consumed or partially consumed (includes expired and unfunded @@ -284,8 +284,8 @@ flow( template struct FlowResult { - TInAmt in = beast::kZERO; - TOutAmt out = beast::kZERO; + TInAmt in = beast::kZero; + TOutAmt out = beast::kZero; std::optional sandbox; boost::container::flat_set removableOffers; TER ter = temUNKNOWN; @@ -325,7 +325,7 @@ struct FlowResult inline std::optional qualityUpperBound(ReadView const& v, Strand const& strand) { - Quality q{STAmount::kU_RATE_ONE}; + Quality q{STAmount::kURateOne}; std::optional stepQ; DebtDirection dir = DebtDirection::Issues; for (auto const& step : strand) @@ -595,9 +595,9 @@ flow( // values if `remainingIn` is initialized through a copy constructor. We can // get similar warnings for `sendMax` if it is initialized in the most // natural way. Using `make_optional`, allows us to work around this bug. - TInAmt const sendMaxInit = sendMaxST ? toAmount(*sendMaxST) : TInAmt{beast::kZERO}; + TInAmt const sendMaxInit = sendMaxST ? toAmount(*sendMaxST) : TInAmt{beast::kZero}; std::optional const sendMax = - (sendMaxST && sendMaxInit >= beast::kZERO) ? std::make_optional(sendMaxInit) : std::nullopt; + (sendMaxST && sendMaxInit >= beast::kZero) ? std::make_optional(sendMaxInit) : std::nullopt; std::optional remainingIn = !!sendMax ? std::make_optional(sendMaxInit) : std::nullopt; // std::optional remainingIn{sendMax}; @@ -619,7 +619,7 @@ flow( auto sum = [](auto const& col) { using TResult = std::decay_t; if (col.empty()) - return TResult{beast::kZERO}; + return TResult{beast::kZero}; return std::accumulate(col.begin() + 1, col.end(), *col.begin()); }; @@ -627,7 +627,7 @@ flow( // successful boost::container::flat_set ofrsToRmOnFail; - while (remainingOut > beast::kZERO && (!remainingIn || *remainingIn > beast::kZERO)) + while (remainingOut > beast::kZero && (!remainingIn || *remainingIn > beast::kZero)) { ++curTry; if (curTry >= maxTries) @@ -679,7 +679,7 @@ flow( offersConsidered += f.ofrsUsed; - if (!f.success || f.out == beast::kZERO) + if (!f.success || f.out == beast::kZero) continue; if (flowDebugInfo) @@ -800,7 +800,7 @@ flow( return {tecPATH_PARTIAL, actualIn, actualOut, std::move(ofrsToRmOnFail)}; } } - else if (actualOut == beast::kZERO) + else if (actualOut == beast::kZero) { return {tecPATH_DRY, std::move(ofrsToRmOnFail)}; } @@ -816,7 +816,7 @@ flow( // fixFillOrKill amendment: // Handles 2. 1. is handled above and falls through for tfSell. XRPL_ASSERT(remainingIn, "xrpl::flow : nonzero remainingIn"); - if (remainingIn && *remainingIn != beast::kZERO) + if (remainingIn && *remainingIn != beast::kZero) return {tecPATH_PARTIAL, actualIn, actualOut, std::move(ofrsToRmOnFail)}; } diff --git a/include/xrpl/tx/transactors/account/AccountDelete.h b/include/xrpl/tx/transactors/account/AccountDelete.h index 1491ae09d9..d2cbfa5ad2 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 kConsequencesFactory = 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..002779db64 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 kConsequencesFactory = 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..a9f1ce715d 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 kConsequencesFactory = 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..760f6e9358 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 kConsequencesFactory = 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..1033dee188 100644 --- a/include/xrpl/tx/transactors/bridge/XChainBridge.h +++ b/include/xrpl/tx/transactors/bridge/XChainBridge.h @@ -5,14 +5,14 @@ namespace xrpl { -constexpr size_t kXBRIDGE_MAX_ACCOUNT_CREATE_CLAIMS = 128; +constexpr size_t kXbridgeMaxAccountCreateClaims = 128; // Attach a new bridge to a door account. Once this is done, the cross-chain // transfer transactions may be used to transfer funds from this account. class XChainCreateBridge : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kConsequencesFactory = 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 kConsequencesFactory = 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 kConsequencesFactory = 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 kConsequencesFactory = 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 kConsequencesFactory = 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 kConsequencesFactory = 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 kConsequencesFactory = 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 kConsequencesFactory = 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..5fdaa7e527 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 kConsequencesFactory = 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..ad9de1e4c3 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 kConsequencesFactory = 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..e03677e5f5 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 kConsequencesFactory = 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..97838f8a0a 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 kConsequencesFactory = 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..7493aa4dc5 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 kConsequencesFactory = 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..4d9b4ddd18 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 kConsequencesFactory = 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..c93c48e970 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 kConsequencesFactory = 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..9328c48e79 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 kConsequencesFactory = 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..7ac03ebb28 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 kConsequencesFactory = ConsequencesFactoryType::Normal; explicit AMMClawback(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/dex/AMMContext.h b/include/xrpl/tx/transactors/dex/AMMContext.h index 3d13547b52..65954044be 100644 --- a/include/xrpl/tx/transactors/dex/AMMContext.h +++ b/include/xrpl/tx/transactors/dex/AMMContext.h @@ -18,11 +18,11 @@ public: // Restrict number of AMM offers. If this restriction is removed // then need to restrict in some other way because AMM offers are // not counted in the BookStep offer counter. - constexpr static std::uint8_t kMAX_ITERATIONS = 30; + static constexpr std::uint8_t kMaxIterations = 30; private: // Tx account owner is required to get the AMM trading fee in BookStep - AccountID account_; + AccountID accountID_; // true if payment has multiple paths bool multiPath_{false}; // Is true if AMM offer is consumed during a payment engine iteration. @@ -31,7 +31,8 @@ private: std::uint16_t ammIters_{0}; public: - AMMContext(AccountID const& account, bool multiPath) : account_(account), multiPath_(multiPath) + AMMContext(AccountID const& account, bool multiPath) + : accountID_(account), multiPath_(multiPath) { } ~AMMContext() = default; @@ -68,7 +69,7 @@ public: [[nodiscard]] bool maxItersReached() const { - return ammIters_ >= kMAX_ITERATIONS; + return ammIters_ >= kMaxIterations; } [[nodiscard]] std::uint16_t @@ -80,7 +81,7 @@ public: [[nodiscard]] AccountID account() const { - return account_; + return accountID_; } /** Strand execution may fail. Reset the flag at the start diff --git a/include/xrpl/tx/transactors/dex/AMMCreate.h b/include/xrpl/tx/transactors/dex/AMMCreate.h index 485273ca17..04d6fe6f60 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 kConsequencesFactory = 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..ff5776e3b7 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 kConsequencesFactory = 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..9be53167f2 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 kConsequencesFactory = 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..1b5946aae1 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 kConsequencesFactory = 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..9e6eb62d51 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 kConsequencesFactory = 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..b2641049e6 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 kConsequencesFactory = 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..efae5312e2 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 kConsequencesFactory = ConsequencesFactoryType::Custom; /** Construct a Transactor subclass that creates an offer in the ledger. */ explicit OfferCreate(ApplyContext& ctx) : Transactor(ctx) @@ -85,6 +85,7 @@ private: Keylet const& offerIndex, STAmount const& saTakerPays, STAmount const& saTakerGets, + std::uint64_t openRate, std::function)> const& setDir); }; diff --git a/include/xrpl/tx/transactors/did/DIDDelete.h b/include/xrpl/tx/transactors/did/DIDDelete.h index 2699307b39..c750d4c95e 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 kConsequencesFactory = 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..b2c3d97c81 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 kConsequencesFactory = 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..92b55374d5 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 kConsequencesFactory = 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..2e9da89896 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 kConsequencesFactory = ConsequencesFactoryType::Custom; explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx) { @@ -16,6 +16,9 @@ public: static TxConsequences makeTxConsequences(PreflightContext const& ctx); + static bool + checkExtraFeatures(PreflightContext const& ctx); + static NotTEC preflight(PreflightContext const& ctx); diff --git a/include/xrpl/tx/transactors/escrow/EscrowFinish.h b/include/xrpl/tx/transactors/escrow/EscrowFinish.h index 0fc6b46311..806f947b8b 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 kConsequencesFactory = 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..1b86ac41e7 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 kConsequencesFactory = 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..63e96457dc 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 kConsequencesFactory = 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..e3182c0851 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 kConsequencesFactory = 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..464a43e398 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 kConsequencesFactory = 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..72a339951b 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 kConsequencesFactory = 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..8dd9c4601b 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 kConsequencesFactory = 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..08c873a5e7 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 kConsequencesFactory = 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..561550e889 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 kConsequencesFactory = 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..304c077f3d 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 kConsequencesFactory = ConsequencesFactoryType::Normal; explicit LoanSet(ApplyContext& ctx) : Transactor(ctx) { @@ -53,16 +53,16 @@ public: beast::Journal const& j) override; public: - static std::uint32_t constexpr kMIN_PAYMENT_TOTAL = 1; - static std::uint32_t constexpr kDEFAULT_PAYMENT_TOTAL = 1; - static_assert(kDEFAULT_PAYMENT_TOTAL >= kMIN_PAYMENT_TOTAL); + static constexpr std::uint32_t kMinPaymentTotal = 1; + static constexpr std::uint32_t kDefaultPaymentTotal = 1; + static_assert(kDefaultPaymentTotal >= kMinPaymentTotal); - static std::uint32_t constexpr kMIN_PAYMENT_INTERVAL = 60; - static std::uint32_t constexpr kDEFAULT_PAYMENT_INTERVAL = 60; - static_assert(kDEFAULT_PAYMENT_INTERVAL >= kMIN_PAYMENT_INTERVAL); + static constexpr std::uint32_t kMinPaymentInterval = 60; + static constexpr std::uint32_t kDefaultPaymentInterval = 60; + static_assert(kDefaultPaymentInterval >= kMinPaymentInterval); - static std::uint32_t constexpr kDEFAULT_GRACE_PERIOD = 60; - static_assert(kDEFAULT_GRACE_PERIOD >= kMIN_PAYMENT_INTERVAL); + static constexpr std::uint32_t kDefaultGracePeriod = 60; + static_assert(kDefaultGracePeriod >= kMinPaymentInterval); }; //------------------------------------------------------------------------------ diff --git a/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h b/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h index 7c77b02277..3c98d55141 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 kConsequencesFactory = 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..4665a17aa7 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 kConsequencesFactory = 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..3eae44b389 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 kConsequencesFactory = 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..20ccefc2cb 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 kConsequencesFactory = 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..1a0deae29d 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 kConsequencesFactory = 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..5b197d72b4 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 kConsequencesFactory = 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..e83a334b87 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 kConsequencesFactory = 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..12c022470b 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 kConsequencesFactory = 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..fbf22f8ca8 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 kConsequencesFactory = 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..ef42b67fa4 100644 --- a/include/xrpl/tx/transactors/payment/Payment.h +++ b/include/xrpl/tx/transactors/payment/Payment.h @@ -7,13 +7,13 @@ namespace xrpl { class Payment : public Transactor { /* The largest number of paths we allow */ - static std::size_t const kMAX_PATH_SIZE = 6; + static std::size_t const kMaxPathSize = 6; /* The longest path we allow */ - static std::size_t const kMAX_PATH_LENGTH = 8; + static std::size_t const kMaxPathLength = 8; public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kConsequencesFactory = 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..98d4638e51 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 kConsequencesFactory = 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..73059a7e46 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 kConsequencesFactory = 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..587ee9f778 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 kConsequencesFactory = 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..77834f7683 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 kConsequencesFactory = 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..47c35800dd 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 kConsequencesFactory = 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..e190714725 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 kConsequencesFactory = ConsequencesFactoryType::Normal; explicit Batch(ApplyContext& ctx) : Transactor(ctx) { @@ -47,7 +47,7 @@ public: ReadView const& view, beast::Journal const& j) override; - static constexpr auto kDISABLED_TX_TYPES = std::to_array({ + static constexpr auto kDisabledTxTypes = std::to_array({ ttVAULT_CREATE, ttVAULT_SET, ttVAULT_DELETE, diff --git a/include/xrpl/tx/transactors/system/Change.h b/include/xrpl/tx/transactors/system/Change.h index fc68fd55c2..33df426593 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 kConsequencesFactory = 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..6fbae6fc6a 100644 --- a/include/xrpl/tx/transactors/system/LedgerStateFix.h +++ b/include/xrpl/tx/transactors/system/LedgerStateFix.h @@ -9,9 +9,10 @@ class LedgerStateFix : public Transactor public: enum class FixType : std::uint16_t { NfTokenPageLink = 1, + BookExchangeRate = 2, }; - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kConsequencesFactory = 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..4991d1d08b 100644 --- a/include/xrpl/tx/transactors/system/TicketCreate.h +++ b/include/xrpl/tx/transactors/system/TicketCreate.h @@ -7,9 +7,9 @@ namespace xrpl { class TicketCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom}; + static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Custom; - constexpr static std::uint32_t kMIN_VALID_COUNT = 1; + static constexpr std::uint32_t kMinValidCount = 1; // A note on how the maxValidCount was determined. The goal is for // a single TicketCreate transaction to not use more compute power than @@ -31,7 +31,7 @@ public: // about the same compute time as a single compute-intensive payment. // // October 2018. - constexpr static std::uint32_t kMAX_VALID_COUNT = 250; + static constexpr std::uint32_t kMaxValidCount = 250; // The maximum number of Tickets an account may hold. If a // TicketCreate would cause an account to own more than this many @@ -39,7 +39,7 @@ public: // // The number was chosen arbitrarily and is an effort toward avoiding // ledger-stuffing with Tickets. - constexpr static std::uint32_t kMAX_TICKET_THRESHOLD = 250; + static constexpr std::uint32_t kMaxTicketThreshold = 250; explicit TicketCreate(ApplyContext& ctx) : Transactor(ctx) { diff --git a/include/xrpl/tx/transactors/token/Clawback.h b/include/xrpl/tx/transactors/token/Clawback.h index e21f98bd7a..7c99cef0d2 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 kConsequencesFactory = 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..b2cfa74f6e 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 kConsequencesFactory = 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..6c59d85548 100644 --- a/include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h +++ b/include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h @@ -6,28 +6,33 @@ namespace xrpl { +// NOLINTBEGIN(readability-redundant-member-init) struct MPTCreateArgs { std::optional priorBalance; AccountID const& account; std::uint32_t sequence = 0; std::uint32_t flags = 0; - std::optional maxAmount = - std::nullopt; // NOLINT(readability-redundant-member-init) - std::optional assetScale = - std::nullopt; // NOLINT(readability-redundant-member-init) - std::optional transferFee = - std::nullopt; // NOLINT(readability-redundant-member-init) + std::optional maxAmount = std::nullopt; + std::optional assetScale = std::nullopt; + std::optional transferFee = std::nullopt; std::optional const& metadata{}; - std::optional domainId = std::nullopt; // NOLINT(readability-redundant-member-init) - std::optional mutableFlags = - std::nullopt; // NOLINT(readability-redundant-member-init) + std::optional domainId = std::nullopt; + std::optional mutableFlags = std::nullopt; + // Set only by callers that issue an MPT representing a wrapped asset + // (e.g. VaultCreate's share token). The keylet must point to an + // existing MPToken or RippleState owned by `account`. Surfaces on + // the resulting MPTokenIssuance via the optional sfReferenceHolding + // field. Used by readers (canTransfer, canTrade, freezing) to + // inherit the underlying asset's transferability. + std::optional referenceHolding = std::nullopt; }; +// NOLINTEND(readability-redundant-member-init) class MPTokenIssuanceCreate : public Transactor { public: - static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal}; + static constexpr auto kConsequencesFactory = 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..65682c8f5e 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 kConsequencesFactory = 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..7397183bbf 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 kConsequencesFactory = 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..d439b676b5 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 kConsequencesFactory = 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..4b9e283571 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 kConsequencesFactory = 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..bbe80b49c1 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 kConsequencesFactory = 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..d8fccd6024 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 kConsequencesFactory = 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..f1a81c928e 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 kConsequencesFactory = 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..48178f5048 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 kConsequencesFactory = 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..7461752ff2 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 kConsequencesFactory = 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/package/README.md b/package/README.md new file mode 100644 index 0000000000..2089e32e64 --- /dev/null +++ b/package/README.md @@ -0,0 +1,175 @@ +# Linux Packaging + +This directory contains all files needed to build RPM and Debian packages for `xrpld`. + +## Directory layout + +``` +package/ + build_pkg.sh Staging and build script (called by CMake targets and CI) + rpm/ + xrpld.spec RPM spec (xrpld_version/pkg_release passed via rpmbuild --define) + debian/ Debian control files (control, rules, install, links, conffiles, ...) + shared/ + xrpld.service systemd unit file (used by both RPM and DEB) + xrpld.sysusers sysusers.d config (used by both RPM and DEB) + xrpld.tmpfiles tmpfiles.d config (used by both RPM and DEB) + xrpld.logrotate logrotate config (installed to /etc/logrotate.d/xrpld) + update-xrpld auto-update script (installed to /usr/libexec/xrpld/, run by update-xrpld.timer) +``` + +## Prerequisites + +Packaging targets and their container images are declared in +[`.github/scripts/strategy-matrix/linux.json`](../.github/scripts/strategy-matrix/linux.json) +via a `"package": true` field on specific os entries. Today only +`linux/amd64` is emitted; the architecture is hardcoded in `generate.py` +and the workflow runner. The package format +(deb or rpm) is inferred at build time from the container's package manager +(`apt-get` -> deb, `dnf`/`yum` -> rpm). The image tag is composed as +`ghcr.io/xrplf/ci/{distro}-{version}:{compiler}-{cver}-sha-{image_sha}` — +the same scheme used by `reusable-build-test.yml`. Bump `image_sha` in +`linux.json` and both CI and local builds pick up the new image with no +workflow edits. + +| Package type | Image (derived from `linux.json`) | Tool required | +| ------------ | ---------------------------------------------------- | --------------------------------------------------------------- | +| RPM | `ghcr.io/xrplf/ci/rhel-9:gcc-12-sha-` | `rpmbuild` | +| DEB | `ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12-sha-` | `dpkg-buildpackage`, `debhelper (>= 13)`, `dh-sequence-systemd` | + +To print the exact image tags for the current `linux.json`: + +```bash +./.github/scripts/strategy-matrix/generate.py --packaging --config=.github/scripts/strategy-matrix/linux.json +``` + +## Building packages + +### Via CI + +Caller workflows (`on-pr.yml`, `on-tag.yml`, `on-trigger.yml`) call +`reusable-strategy-matrix.yml` with `mode: packaging` to generate the matrix of +`{artifact_name, os}` entries, then fan out to +`reusable-package.yml` per entry. That workflow downloads the pre-built `xrpld` +binary artifact, detects the package format from the container, and calls +`build_pkg.sh` directly — no CMake configure or build step is needed inside +the packaging job. + +### Locally (mirrors CI) + +With an `xrpld` binary already built at `build/xrpld`, run the packaging step +inside the same container CI uses. The image tag is derived from `linux.json` +so you don't need to hardcode a SHA. + +```bash +# From the repo root. Pick any image flagged with `"package": true` in +# linux.json; the package format is inferred from the container's package +# manager. Example for the rpm-producing image: +IMAGE=$(jq -r ' + .os | map(select(.package == true))[0] | + "ghcr.io/xrplf/ci/\(.distro_name)-\(.distro_version):\(.compiler_name)-\(.compiler_version)-sha-\(.image_sha)" +' .github/scripts/strategy-matrix/linux.json) + +VERSION=2.4.0-local +PKG_RELEASE=1 + +docker run --rm \ + -v "$(pwd):/src" \ + -w /src \ + "$IMAGE" \ + ./package/build_pkg.sh --pkg-version "$VERSION" --pkg-release "$PKG_RELEASE" + +# Output: +# build/debbuild/*.deb (DEB + dbgsym .ddeb) +# build/rpmbuild/RPMS/x86_64/*.rpm +``` + +### Via CMake (host-side target) + +If you run CMake configure on a host that has `rpmbuild` or `dpkg-buildpackage` +installed natively, you can use the CMake target directly — no container +needed, but the host toolchain replaces the pinned CI image: + +```bash +cmake \ + -Dxrpld=ON \ + -Dxrpld_version=2.4.0-local \ + -Dtests=OFF \ + .. + +cmake --build . --target package # deb on Debian/Ubuntu, rpm on RHEL +``` + +The `cmake/XrplPackaging.cmake` module defines the target only if at least one +of `rpmbuild` / `dpkg-buildpackage` is present; `build_pkg.sh` then infers the +package format from the host's package manager. The packaging script installs +to FHS-standard paths (`/usr/bin`, `/etc/xrpld`, etc.) regardless of +`CMAKE_INSTALL_PREFIX`. + +## How `build_pkg.sh` works + +`build_pkg.sh` accepts long-form flags, each of which can also be set via an +environment variable. Flags override env vars; env vars override the built-in +defaults. Run `./package/build_pkg.sh --help` for the same table: + +| Flag | Env var | Default | Purpose | +| -------------------------- | ------------------- | ----------------------------- | ----------------------------------- | +| `--src-dir DIR` | `SRC_DIR` | `$PWD` | repo root | +| `--build-dir DIR` | `BUILD_DIR` | `$PWD/build` | directory holding pre-built `xrpld` | +| `--pkg-version STR` | `PKG_VERSION` | parsed from `xrpld --version` | version string, e.g. `3.2.0-b1` | +| `--pkg-release N` | `PKG_RELEASE` | `1` | package release number | +| `--source-date-epoch SECS` | `SOURCE_DATE_EPOCH` | latest git commit ctime | reproducibility timestamp | + +The package format (`deb` or `rpm`) is inferred from the host's package +manager (`apt-get` -> deb, `dnf`/`yum` -> rpm). Hosts without one of those +fail early. + +Flags are for explicit invocation; environment variables are intended for +CMake/systemd/CI integration. The CI workflow and the CMake `package` target +both invoke `build_pkg.sh` with no flags, configuring it entirely via env +(see `cmake/XrplPackaging.cmake`). + +It resolves `SRC_DIR` and `BUILD_DIR` to absolute paths, then calls +`stage_common()` to copy the binary, config files, and shared support files +into the staging area, and invokes the platform build tool. + +### RPM + +1. Creates the standard `rpmbuild/{BUILD,BUILDROOT,RPMS,SOURCES,SPECS,SRPMS}` tree inside the build directory. +2. Copies `xrpld.spec` and all source files (binary, configs, service files) into `SOURCES/`. +3. Runs `rpmbuild -bb --define "xrpld_version ..." --define "pkg_release ..."`. The spec uses manual `install` commands to place files. +4. Output: `rpmbuild/RPMS/x86_64/xrpld-*.rpm` + +### DEB + +1. Creates a staging source tree at `debbuild/source/` inside the build directory. +2. Stages the binary, configs, `README.md`, and `LICENSE.md`. +3. Copies `package/debian/` control files into `debbuild/source/debian/`. +4. Copies shared service/sysusers/tmpfiles into `debian/` where `dh_installsystemd`, `dh_installsysusers`, and `dh_installtmpfiles` pick them up automatically. +5. Generates a minimal `debian/changelog` (pre-release versions use `~` instead of `-`). +6. Runs `dpkg-buildpackage -b --no-sign`. `debian/rules` uses manual `install` commands. +7. Output: `debbuild/*.deb` and `debbuild/*.ddeb` (dbgsym package) + +## Post-build verification + +```bash +# DEB +dpkg-deb -c debbuild/*.deb | grep -E 'systemd|sysusers|tmpfiles' +lintian -I debbuild/*.deb + +# RPM +rpm -qlp rpmbuild/RPMS/x86_64/*.rpm +``` + +## Reproducibility + +The following environment variables improve build reproducibility. They are not +set automatically by `build_pkg.sh`; set them manually if needed: + +```bash +export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct) +export TZ=UTC +export LC_ALL=C.UTF-8 +export GZIP=-n +export DEB_BUILD_OPTIONS="noautodbgsym reproducible=+fixfilepath" +``` diff --git a/package/build_pkg.sh b/package/build_pkg.sh new file mode 100755 index 0000000000..adac2dc169 --- /dev/null +++ b/package/build_pkg.sh @@ -0,0 +1,196 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Build an RPM or Debian package from a pre-built xrpld binary. +# +# Flags override env vars; env vars override defaults. Env vars are intended +# for CMake/systemd/CI integration; flags are for explicit invocation. + +usage() { + cat <<'EOF' +Usage: build_pkg.sh [options] + +Options (each can also be set via the env var shown): + --src-dir DIR repo root [SRC_DIR; default: $PWD] + --build-dir DIR directory holding xrpld [BUILD_DIR; default: $PWD/build] + --pkg-version STR version, e.g. 3.2.0-b1 [PKG_VERSION; default: parsed from xrpld --version] + --pkg-release N package release number [PKG_RELEASE; default: 1] + --source-date-epoch SECS reproducibility timestamp [SOURCE_DATE_EPOCH; default: latest git commit ctime] + -h, --help show this help and exit +EOF +} + +need_arg() { + if [[ $# -lt 2 || "$2" == --* ]]; then + echo "Missing value for $1" >&2 + exit 2 + fi +} + +# Seed from env. CLI parsing below overrides these directly. +SRC_DIR="${SRC_DIR:-}" +BUILD_DIR="${BUILD_DIR:-}" +PKG_VERSION="${PKG_VERSION:-}" +PKG_RELEASE="${PKG_RELEASE:-}" +SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-}" + +while [[ $# -gt 0 ]]; do + case "$1" in + --src-dir) need_arg "$@"; SRC_DIR="$2"; shift 2 ;; + --build-dir) need_arg "$@"; BUILD_DIR="$2"; shift 2 ;; + --pkg-version) need_arg "$@"; PKG_VERSION="$2"; shift 2 ;; + --pkg-release) need_arg "$@"; PKG_RELEASE="$2"; shift 2 ;; + --source-date-epoch) need_arg "$@"; SOURCE_DATE_EPOCH="$2"; shift 2 ;; + -h|--help) usage; exit 0 ;; + *) + echo "Unknown argument: $1" >&2 + usage >&2 + exit 2 + ;; + esac +done + +SRC_DIR="$(cd "${SRC_DIR:-${PWD}}" && pwd)" +BUILD_DIR="$(cd "${BUILD_DIR:-${PWD}/build}" && pwd)" +PKG_RELEASE="${PKG_RELEASE:-1}" + +if [[ -z "${PKG_VERSION}" ]]; then + PKG_VERSION="$("${BUILD_DIR}/xrpld" --version | awk 'NR==1 {print $3; exit}')" +fi + +if [[ -z "${PKG_VERSION}" ]]; then + echo "PKG_VERSION is empty (not provided and could not be derived)." >&2 + exit 1 +fi + +VERSION="${PKG_VERSION}" + +if command -v apt-get >/dev/null 2>&1; then + pkg_type=deb +elif command -v dnf >/dev/null 2>&1 || command -v yum >/dev/null 2>&1; then + pkg_type=rpm +else + echo "Cannot infer pkg_type: no apt-get, dnf, or yum on PATH." >&2 + exit 1 +fi + +if [[ -z "${SOURCE_DATE_EPOCH}" ]]; then + if git -C "$SRC_DIR" rev-parse --is-inside-work-tree >/dev/null 2>&1; then + SOURCE_DATE_EPOCH="$(git -C "$SRC_DIR" log -1 --format=%ct)" + else + SOURCE_DATE_EPOCH="$(date +%s)" + fi +fi + +export SOURCE_DATE_EPOCH +CHANGELOG_DATE="$(date -u -R -d "@$SOURCE_DATE_EPOCH")" + +# Split VERSION at the first '-' into base and optional pre-release suffix. +# Examples: "3.2.0" -> ("3.2.0", ""); "3.2.0-b1" -> ("3.2.0", "b1"). +VER_BASE="${VERSION%%-*}" +VER_SUFFIX="${VERSION#*-}" +[[ "${VER_SUFFIX}" == "${VERSION}" ]] && VER_SUFFIX="" + +# Reject multi-segment suffixes (e.g. "beta-1", "rc1-15-gabc123"). The RPM +# Release field forbids '-', and the convention here is single-token suffixes +# like b1 or rc2. Fail early with a clear message rather than letting either +# rpmbuild blow up or silently mangling dashes into dots. +if [[ "${VER_SUFFIX}" == *-* ]]; then + echo "build_pkg.sh: multi-segment pre-release in VERSION='${VERSION}' (suffix '${VER_SUFFIX}')." >&2 + echo "Use single-token suffixes like 3.2.0-b1 or 3.2.0-rc2." >&2 + exit 1 +fi + +SHARED="${SRC_DIR}/package/shared" +DEBIAN_DIR="${SRC_DIR}/package/debian" + +# Stage files that both packaging systems consume using the same filenames. +stage_common() { + local dest="$1" + mkdir -p "${dest}" + + cp "${BUILD_DIR}/xrpld" "${dest}/xrpld" + cp "${SRC_DIR}/cfg/xrpld-example.cfg" "${dest}/xrpld.cfg" + cp "${SRC_DIR}/cfg/validators-example.txt" "${dest}/validators.txt" + cp "${SRC_DIR}/LICENSE.md" "${dest}/LICENSE.md" + cp "${SRC_DIR}/README.md" "${dest}/README.md" + + cp "${SHARED}/xrpld.service" "${dest}/xrpld.service" + cp "${SHARED}/xrpld.sysusers" "${dest}/xrpld.sysusers" + cp "${SHARED}/xrpld.tmpfiles" "${dest}/xrpld.tmpfiles" + cp "${SHARED}/xrpld.logrotate" "${dest}/xrpld.logrotate" + cp "${SHARED}/update-xrpld" "${dest}/update-xrpld" + cp "${SHARED}/update-xrpld.service" "${dest}/update-xrpld.service" + cp "${SHARED}/update-xrpld.timer" "${dest}/update-xrpld.timer" + cp "${SHARED}/50-xrpld.preset" "${dest}/50-xrpld.preset" +} + +build_rpm() { + local topdir="${BUILD_DIR}/rpmbuild" + rm -rf "${topdir}" + mkdir -p "${topdir}"/{BUILD,BUILDROOT,RPMS,SOURCES,SPECS,SRPMS} + + cp "${SRC_DIR}/package/rpm/xrpld.spec" "${topdir}/SPECS/xrpld.spec" + stage_common "${topdir}/SOURCES" + + # RPM Version can't contain '-'. A pre-release goes in Release with a + # leading "0." so 3.2.0-b1 sorts before the final 3.2.0-. + # The order is "0.." (e.g. 0.1.b6) — the Fedora/EPEL + # convention. Reversing to "0.." (e.g. 0.b6.1) breaks + # rpmvercmp against the former because numeric segments outrank alphabetic + # ones, so "0.1.b5" would sort newer than "0.b6.1". + local rpm_release="${PKG_RELEASE}" + [[ -n "${VER_SUFFIX}" ]] && rpm_release="0.${PKG_RELEASE}.${VER_SUFFIX}" + + set -x + rpmbuild -bb \ + --define "_topdir ${topdir}" \ + --define "xrpld_version ${VER_BASE}" \ + --define "xrpld_release ${rpm_release}" \ + "${topdir}/SPECS/xrpld.spec" +} + +build_deb() { + local staging="${BUILD_DIR}/debbuild/source" + rm -rf "${staging}" + mkdir -p "${staging}" + + stage_common "${staging}" + cp -r "${DEBIAN_DIR}" "${staging}/debian" + + # Debhelper auto-discovers these only from debian/. + cp "${staging}/xrpld.service" "${staging}/debian/xrpld.service" + cp "${staging}/xrpld.sysusers" "${staging}/debian/xrpld.sysusers" + cp "${staging}/xrpld.tmpfiles" "${staging}/debian/xrpld.tmpfiles" + cp "${staging}/xrpld.logrotate" "${staging}/debian/xrpld.logrotate" + cp "${staging}/update-xrpld.service" "${staging}/debian/xrpld.update-xrpld.service" + cp "${staging}/update-xrpld.timer" "${staging}/debian/xrpld.update-xrpld.timer" + + # Debian '~' marks a pre-release; 3.2.0~b1 sorts before 3.2.0. + local deb_full_version="${VER_BASE}${VER_SUFFIX:+~${VER_SUFFIX}}-${PKG_RELEASE}" + + # Derive release channel from the version suffix: + # (none) -> stable (tagged release) + # b0 -> develop (develop-branch build) + # b, rc -> unstable (pre-release) + local deb_distribution + case "${VER_SUFFIX}" in + "") deb_distribution="stable" ;; + b0) deb_distribution="develop" ;; + *) deb_distribution="unstable" ;; + esac + + cat > "${staging}/debian/changelog" < ${CHANGELOG_DATE} +EOF + + chmod +x "${staging}/debian/rules" + + set -x + ( cd "${staging}" && dpkg-buildpackage -b --no-sign -d ) +} + +"build_${pkg_type}" diff --git a/package/debian/control b/package/debian/control new file mode 100644 index 0000000000..45d2acbbea --- /dev/null +++ b/package/debian/control @@ -0,0 +1,23 @@ +Source: xrpld +Section: net +Priority: optional +Maintainer: XRPL Foundation +Rules-Requires-Root: no +Build-Depends: + debhelper-compat (= 13) +Standards-Version: 4.7.0 +Homepage: https://github.com/XRPLF/rippled +Vcs-Git: https://github.com/XRPLF/rippled.git +Vcs-Browser: https://github.com/XRPLF/rippled + +Package: xrpld +Section: net +Priority: optional +Architecture: any +Depends: + ${shlibs:Depends}, + ${misc:Depends} +Description: XRP Ledger daemon + Reference implementation of the XRP Ledger protocol. + Participates in the peer-to-peer network, processes transactions, + and maintains a local ledger copy. diff --git a/package/debian/copyright b/package/debian/copyright new file mode 100644 index 0000000000..ddaa719e3a --- /dev/null +++ b/package/debian/copyright @@ -0,0 +1,18 @@ +Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Upstream-Name: rippled +Source: https://github.com/XRPLF/rippled + +Files: * +Copyright: 2011-present, the XRP Ledger developers +License: ISC + Permission to use, copy, modify, and distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + . + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/package/debian/rules b/package/debian/rules new file mode 100644 index 0000000000..cd94da7e5b --- /dev/null +++ b/package/debian/rules @@ -0,0 +1,27 @@ +#!/usr/bin/make -f + +export DH_VERBOSE = 1 + +%: + dh $@ + +override_dh_auto_configure override_dh_auto_build override_dh_auto_test: + @: + +override_dh_installsystemd: + dh_installsystemd --no-stop-on-upgrade xrpld.service + dh_installsystemd --name=update-xrpld --no-start update-xrpld.service update-xrpld.timer + +execute_before_dh_installtmpfiles: + dh_installsysusers + +override_dh_installsysusers: + +override_dh_install: + install -D -m 0755 xrpld debian/xrpld/usr/bin/xrpld + install -D -m 0644 xrpld.cfg debian/xrpld/etc/xrpld/xrpld.cfg + install -D -m 0644 validators.txt debian/xrpld/etc/xrpld/validators.txt + install -D -m 0755 update-xrpld debian/xrpld/usr/libexec/xrpld/update-xrpld + +override_dh_dwz: + @: diff --git a/package/debian/source/format b/package/debian/source/format new file mode 100644 index 0000000000..163aaf8d82 --- /dev/null +++ b/package/debian/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/package/debian/xrpld.docs b/package/debian/xrpld.docs new file mode 100644 index 0000000000..1217b6db43 --- /dev/null +++ b/package/debian/xrpld.docs @@ -0,0 +1,2 @@ +README.md +LICENSE.md diff --git a/package/debian/xrpld.links b/package/debian/xrpld.links new file mode 100644 index 0000000000..10d34f5b8c --- /dev/null +++ b/package/debian/xrpld.links @@ -0,0 +1,2 @@ +# Legacy compat symlinks (remove next major release) +usr/bin/xrpld usr/local/bin/rippled diff --git a/package/rpm/xrpld.spec b/package/rpm/xrpld.spec new file mode 100644 index 0000000000..4933c724f7 --- /dev/null +++ b/package/rpm/xrpld.spec @@ -0,0 +1,100 @@ +Name: xrpld +Version: %{xrpld_version} +Release: %{xrpld_release}%{?dist} +Summary: XRP Ledger daemon + +License: ISC +URL: https://github.com/XRPLF/rippled + +ExclusiveArch: x86_64 aarch64 +BuildRequires: systemd-rpm-macros + +%undefine _debugsource_packages +%debug_package + +%build_mtime_policy clamp_to_source_date_epoch + +%{?systemd_requires} +%{?sysusers_requires_compat} + +%description +xrpld is the reference implementation of the XRP Ledger protocol. It +participates in the peer-to-peer XRP Ledger network, processes +transactions, and maintains the ledger database. + +%prep +: + +%build +: + +%install +install -Dm0755 %{_sourcedir}/xrpld %{buildroot}%{_bindir}/%{name} +install -Dm0644 %{_sourcedir}/xrpld.cfg %{buildroot}%{_sysconfdir}/%{name}/xrpld.cfg +install -Dm0644 %{_sourcedir}/validators.txt %{buildroot}%{_sysconfdir}/%{name}/validators.txt + +# systemd units, sysusers, tmpfiles, preset +install -Dm0644 %{_sourcedir}/xrpld.service %{buildroot}%{_unitdir}/xrpld.service +install -Dm0644 %{_sourcedir}/update-xrpld.service %{buildroot}%{_unitdir}/update-xrpld.service +install -Dm0644 %{_sourcedir}/update-xrpld.timer %{buildroot}%{_unitdir}/update-xrpld.timer +install -Dm0644 %{_sourcedir}/xrpld.sysusers %{buildroot}%{_sysusersdir}/xrpld.conf +install -Dm0644 %{_sourcedir}/xrpld.tmpfiles %{buildroot}%{_tmpfilesdir}/xrpld.conf +install -Dm0644 %{_sourcedir}/50-xrpld.preset %{buildroot}%{_presetdir}/50-xrpld.preset + +# Logrotate config +install -Dm0644 %{_sourcedir}/xrpld.logrotate %{buildroot}%{_sysconfdir}/logrotate.d/%{name} + +# Update helper +install -Dm0755 %{_sourcedir}/update-xrpld %{buildroot}%{_libexecdir}/%{name}/update-xrpld + +# Docs +install -Dm0644 %{_sourcedir}/LICENSE.md %{buildroot}%{_docdir}/%{name}/LICENSE.md +install -Dm0644 %{_sourcedir}/README.md %{buildroot}%{_docdir}/%{name}/README.md + +# Legacy compatibility for pre-FHS package layouts. +# TODO: remove after rippled fully deprecated. +install -d %{buildroot}/usr/local/bin +ln -s %{_bindir}/%{name} %{buildroot}/usr/local/bin/rippled + +%pre +%sysusers_create_package %{name} %{_sourcedir}/xrpld.sysusers + +%post +systemd-tmpfiles --create %{_tmpfilesdir}/xrpld.conf || : +%systemd_post xrpld.service update-xrpld.timer + +%preun +%systemd_preun xrpld.service update-xrpld.timer + +%postun +%systemd_postun_with_restart xrpld.service + +%files +%license %{_docdir}/%{name}/LICENSE.md +%doc %{_docdir}/%{name}/README.md + +%dir %{_sysconfdir}/%{name} +%dir %{_libexecdir}/%{name} + +%{_bindir}/%{name} + +%config(noreplace) %{_sysconfdir}/%{name}/xrpld.cfg +%config(noreplace) %{_sysconfdir}/%{name}/validators.txt +%config(noreplace) %{_sysconfdir}/logrotate.d/%{name} + +%{_libexecdir}/%{name}/update-xrpld + +%{_unitdir}/xrpld.service +%{_unitdir}/update-xrpld.service +%{_unitdir}/update-xrpld.timer +%{_presetdir}/50-xrpld.preset +%{_sysusersdir}/xrpld.conf +%{_tmpfilesdir}/xrpld.conf + +%ghost %dir /var/lib/%{name} +%ghost %dir /var/log/%{name} + + +# Legacy compatibility for pre-FHS package layouts. +# TODO: remove after rippled fully deprecated. +/usr/local/bin/rippled diff --git a/package/shared/50-xrpld.preset b/package/shared/50-xrpld.preset new file mode 100644 index 0000000000..6264e00131 --- /dev/null +++ b/package/shared/50-xrpld.preset @@ -0,0 +1,4 @@ +# /usr/lib/systemd/system-preset/50-xrpld.preset +enable xrpld.service +# Don't enable automatic updates +disable update-xrpld.timer diff --git a/package/shared/update-xrpld b/package/shared/update-xrpld new file mode 100755 index 0000000000..86be33118b --- /dev/null +++ b/package/shared/update-xrpld @@ -0,0 +1,152 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Optional: also write logs to a legacy file in addition to journald. +# By default, this script logs to systemd/journald, viewable via: +# journalctl -t update-xrpld +# +# Uncomment the line below if you need a flat file for compatibility with +# external tooling, manual inspection, or environments where journald logs +# are not persisted or easily accessible. +# +# Note: This duplicates all output (stdout/stderr) to both journald and the file. +# It is generally not needed on modern systems and may cause log file growth +# if left enabled long-term. +# +# Requires /var/log/xrpld/ to exist and be writable by the service (root). +# +# exec > >(tee -a /var/log/xrpld/update.log) 2>&1 + +PATH=/usr/sbin:/usr/bin:/sbin:/bin + +PKG_NAME=${PKG_NAME:-xrpld} + +log() { +# If running under systemd/journald, let it handle timestamps. + if [[ -n "${JOURNAL_STREAM:-}" ]]; then + printf '%s\n' "$*" + else + printf '%s %s\n' "$(date -u +'%Y-%m-%dT%H:%M:%SZ')" "$*" + fi +} + +require_root() { + if [[ ${EUID:-$(id -u)} -ne 0 ]]; then + log "RESULT: failed reason=not-root" + exit 1 + fi +} + +get_installed_version() { + if command -v dpkg-query >/dev/null 2>&1; then + dpkg-query -W -f='${Version}' "$PKG_NAME" 2>/dev/null || printf 'unknown' + elif command -v rpm >/dev/null 2>&1; then + rpm -q --qf '%{VERSION}-%{RELEASE}' "$PKG_NAME" 2>/dev/null || printf 'unknown' + else + printf 'unknown' + fi +} + +trap 'log "RESULT: failed reason=script-error exit_code=$?"' ERR + +apt_can_update() { + apt-get update -qq + apt-get -s --only-upgrade install "$PKG_NAME" 2>/dev/null | grep -q "^Inst ${PKG_NAME}\b" +} + +apt_apply_update() { + DEBIAN_FRONTEND=noninteractive apt-get install -y -qq \ + -o Dpkg::Options::="--force-confdef" \ + -o Dpkg::Options::="--force-confold" \ + "$PKG_NAME" +} + +get_rpm_pm() { + if command -v dnf >/dev/null 2>&1; then + printf 'dnf\n' + elif command -v yum >/dev/null 2>&1; then + printf 'yum\n' + else + return 1 + fi +} + +rpm_refresh_metadata() { + local pm=$1 + if [[ "$pm" == "dnf" ]]; then + dnf makecache --refresh -q >/dev/null + else + yum clean expire-cache -q >/dev/null + fi +} + +rpm_can_update() { + local pm=$1 + + rpm_refresh_metadata "$pm" + local rc=0 + set +e + "$pm" check-update -q "$PKG_NAME" >/dev/null 2>&1 + rc=$? + set -e + + if [[ $rc -eq 100 ]]; then + return 0 + elif [[ $rc -eq 0 ]]; then + return 1 + else + log "$pm check-update failed with exit code ${rc}." + exit 1 + fi +} + +rpm_apply_update() { + local pm=$1 + "$pm" update -y "$PKG_NAME" +} + +restart_service() { + # Preserve the operator's prior service state: if xrpld was intentionally + # stopped before the update, don't bring it back up just because the + # auto-update timer fired. + if systemctl is-active --quiet "${PKG_NAME}.service"; then + systemctl restart "${PKG_NAME}.service" + log "${PKG_NAME} service restarted successfully." + else + log "${PKG_NAME} service was not running; skipping restart to preserve prior state." + fi +} + +main() { + require_root + if command -v apt-get >/dev/null 2>&1; then + log "Checking for ${PKG_NAME} updates via apt" + if apt_can_update; then + log "Update available; installing." + apt_apply_update + restart_service + log "RESULT: updated ${PKG_NAME}=$(get_installed_version)" + else + log "RESULT: no-update ${PKG_NAME}=$(get_installed_version)" + fi + return + fi + + local rpm_pm="" + if rpm_pm="$(get_rpm_pm)"; then + log "Checking for ${PKG_NAME} updates via ${rpm_pm}" + if rpm_can_update "$rpm_pm"; then + log "Update available; installing" + rpm_apply_update "$rpm_pm" + restart_service + log "RESULT: updated ${PKG_NAME}=$(get_installed_version)" + else + log "RESULT: no-update ${PKG_NAME}=$(get_installed_version)" + fi + return + fi + log "RESULT: failed reason=no-package-manager" + exit 1 +} + +main "$@" diff --git a/package/shared/update-xrpld.service b/package/shared/update-xrpld.service new file mode 100644 index 0000000000..a964ca5482 --- /dev/null +++ b/package/shared/update-xrpld.service @@ -0,0 +1,16 @@ +[Unit] +Description=Check for and install xrpld package updates +Documentation=man:systemd.service(5) +Wants=network-online.target +After=network-online.target +ConditionPathExists=/usr/libexec/xrpld/update-xrpld +ConditionPathExists=/usr/bin/xrpld + +[Service] +Type=oneshot +ExecStart=/usr/bin/flock -n /run/lock/xrpld-update.lock /usr/libexec/xrpld/update-xrpld +StandardOutput=journal +StandardError=journal +SyslogIdentifier=update-xrpld +TimeoutStartSec=30min +PrivateTmp=true diff --git a/package/shared/update-xrpld.timer b/package/shared/update-xrpld.timer new file mode 100644 index 0000000000..21dabf1400 --- /dev/null +++ b/package/shared/update-xrpld.timer @@ -0,0 +1,10 @@ +[Unit] +Description=Daily xrpld update check + +[Timer] +OnCalendar=*-*-* 00:00:00 +RandomizedDelaySec=24h +Persistent=true + +[Install] +WantedBy=timers.target diff --git a/package/shared/xrpld.logrotate b/package/shared/xrpld.logrotate new file mode 100644 index 0000000000..0ae2b7783b --- /dev/null +++ b/package/shared/xrpld.logrotate @@ -0,0 +1,19 @@ +/var/log/xrpld/*.log { + daily + minsize 200M + rotate 7 + nocreate + missingok + notifempty + compress + compresscmd /usr/bin/gzip + compressext .gz + postrotate + # Only signal the daemon if it's actually running; otherwise the RPC + # call returns a transport error and logrotate marks the rotation as + # failed, generating recurring errors on stopped nodes. + if systemctl is-active --quiet xrpld; then + /usr/bin/xrpld --conf /etc/xrpld/xrpld.cfg logrotate + fi + endscript +} diff --git a/package/shared/xrpld.service b/package/shared/xrpld.service new file mode 100644 index 0000000000..72b6cc9938 --- /dev/null +++ b/package/shared/xrpld.service @@ -0,0 +1,22 @@ +[Unit] +Description=XRP Ledger Daemon +After=network-online.target +Wants=network-online.target +StartLimitIntervalSec=300 +StartLimitBurst=5 + +[Service] +Type=simple +ExecStart=/usr/bin/xrpld --net --silent --conf /etc/xrpld/xrpld.cfg +Restart=always +RestartSec=5s +NoNewPrivileges=true +ProtectSystem=full +ProtectHome=true +PrivateTmp=true +User=xrpld +Group=xrpld +LimitNOFILE=65536 + +[Install] +WantedBy=multi-user.target diff --git a/package/shared/xrpld.sysusers b/package/shared/xrpld.sysusers new file mode 100644 index 0000000000..4547ac6f3d --- /dev/null +++ b/package/shared/xrpld.sysusers @@ -0,0 +1 @@ +u xrpld - "XRP Ledger daemon" /var/lib/xrpld /sbin/nologin diff --git a/package/shared/xrpld.tmpfiles b/package/shared/xrpld.tmpfiles new file mode 100644 index 0000000000..ff9b4d95c2 --- /dev/null +++ b/package/shared/xrpld.tmpfiles @@ -0,0 +1,2 @@ +d /var/lib/xrpld 0750 xrpld xrpld - +d /var/log/xrpld 0750 xrpld xrpld - diff --git a/src/libxrpl/basics/BasicConfig.cpp b/src/libxrpl/basics/BasicConfig.cpp index c1997eb713..9fe79bdf4e 100644 --- a/src/libxrpl/basics/BasicConfig.cpp +++ b/src/libxrpl/basics/BasicConfig.cpp @@ -28,7 +28,7 @@ void Section::append(std::vector const& lines) { // '=' - static boost::regex const kRE1( + static boost::regex const kRe1( "^" // start of line "(?:\\s*)" // whitespace (optional) "([a-zA-Z][_a-zA-Z0-9]*)" // @@ -82,7 +82,7 @@ Section::append(std::vector const& lines) continue; boost::smatch match; - if (boost::regex_match(line, match, kRE1)) + if (boost::regex_match(line, match, kRe1)) { set(match[1], match[2]); } @@ -126,10 +126,10 @@ BasicConfig::section(std::string const& name) Section const& BasicConfig::section(std::string const& name) const { - static Section const kNONE(""); + static Section const kNone(""); auto const iter = map_.find(name); if (iter == map_.end()) - return kNONE; + return kNone; return iter->second; } diff --git a/src/libxrpl/basics/CountedObject.cpp b/src/libxrpl/basics/CountedObject.cpp index 1bf88687f8..f5b98354dc 100644 --- a/src/libxrpl/basics/CountedObject.cpp +++ b/src/libxrpl/basics/CountedObject.cpp @@ -7,9 +7,9 @@ namespace xrpl { CountedObjects& CountedObjects::getInstance() noexcept { - static CountedObjects kINSTANCE; + static CountedObjects kInstance; - return kINSTANCE; + return kInstance; } CountedObjects::CountedObjects() noexcept : count_(0), head_(nullptr) diff --git a/src/libxrpl/basics/Log.cpp b/src/libxrpl/basics/Log.cpp index a629d865b8..1079f91280 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() > kMaximumMessageCharacters) { - output.resize(MaximumMessageCharacters - 3); + output.resize(kMaximumMessageCharacters - 3); output += "..."; } @@ -440,8 +384,8 @@ public: static DebugSink& debugSink() { - static DebugSink kINST; - return kINST; + static DebugSink kInst; + return kInst; } std::unique_ptr diff --git a/src/libxrpl/basics/MallocTrim.cpp b/src/libxrpl/basics/MallocTrim.cpp index 6fb9ab611b..3831c8adae 100644 --- a/src/libxrpl/basics/MallocTrim.cpp +++ b/src/libxrpl/basics/MallocTrim.cpp @@ -86,7 +86,7 @@ mallocTrim(std::string_view tag, beast::Journal journal) // Keep glibc malloc_trim padding at 0 (default): 12h Mainnet tests across 0/256KB/1MB/16MB // showed no clear, consistent benefit from custom padding—0 provided the best overall balance // of RSS reduction and trim-latency stability without adding a tuning surface. - constexpr static std::size_t kTRIM_PAD = 0; + static constexpr std::size_t kTrimPad = 0; report.supported = true; @@ -114,7 +114,7 @@ mallocTrim(std::string_view tag, beast::Journal journal) auto const t0 = std::chrono::steady_clock::now(); - report.trimResult = detail::mallocTrimWithPad(kTRIM_PAD); + report.trimResult = detail::mallocTrimWithPad(kTrimPad); auto const t1 = std::chrono::steady_clock::now(); @@ -140,7 +140,7 @@ mallocTrim(std::string_view tag, beast::Journal journal) : (static_cast(rssAfterKB) - static_cast(rssBeforeKB)); JLOG(journal.debug()) << "malloc_trim tag=" << tagStr << " result=" << report.trimResult - << " pad=" << kTRIM_PAD << " bytes" + << " pad=" << kTrimPad << " bytes" << " rss_before=" << rssBeforeKB << "kB" << " rss_after=" << rssAfterKB << "kB" << " delta=" << deltaKB << "kB" @@ -150,7 +150,7 @@ mallocTrim(std::string_view tag, beast::Journal journal) } else { - report.trimResult = detail::mallocTrimWithPad(kTRIM_PAD); + report.trimResult = detail::mallocTrimWithPad(kTrimPad); } #endif diff --git a/src/libxrpl/basics/Number.cpp b/src/libxrpl/basics/Number.cpp index 08ead182bf..06bd78d8b0 100644 --- a/src/libxrpl/basics/Number.cpp +++ b/src/libxrpl/basics/Number.cpp @@ -28,7 +28,7 @@ using int128_t = __int128_t; namespace xrpl { thread_local Number::RoundingMode Number::mode = Number::RoundingMode::ToNearest; -thread_local std::reference_wrapper Number::kRANGE = kLARGE_RANGE; +thread_local std::reference_wrapper Number::kRange = kLargeRange; Number::RoundingMode Number::getround() @@ -45,7 +45,7 @@ Number::setround(RoundingMode inMode) MantissaRange::MantissaScale Number::getMantissaScale() { - return kRANGE.get().scale; + return kRange.get().scale; } void @@ -54,7 +54,7 @@ Number::setMantissaScale(MantissaRange::MantissaScale scale) if (scale != MantissaRange::MantissaScale::Small && scale != MantissaRange::MantissaScale::Large) logicError("Unknown mantissa scale"); - kRANGE = scale == MantissaRange::MantissaScale::Small ? kSMALL_RANGE : kLARGE_RANGE; + kRange = scale == MantissaRange::MantissaScale::Small ? kSmallRange : kLargeRange; } // Guard @@ -224,13 +224,13 @@ Number::Guard::bringIntoRange( mantissa *= 10; --exponent; } - if (exponent < kMIN_EXPONENT) + if (exponent < kMinExponent) { - constexpr Number kZERO = Number{}; + static constexpr Number kZero = Number{}; - negative = kZERO.negative_; - mantissa = kZERO.mantissa_; - exponent = kZERO.exponent_; + negative = kZero.negative_; + mantissa = kZero.mantissa_; + exponent = kZero.exponent_; } } @@ -250,14 +250,14 @@ Number::Guard::doRoundUp( ++mantissa; // Ensure mantissa after incrementing fits within both the // min/maxMantissa range and is a valid "rep". - if (mantissa > maxMantissa || mantissa > kMAX_REP) + if (mantissa > maxMantissa || mantissa > kMaxRep) { mantissa /= 10; ++exponent; } } bringIntoRange(negative, mantissa, exponent, minMantissa); - if (exponent > kMAX_EXPONENT) + if (exponent > kMaxExponent) Throw(std::string(location)); } @@ -289,7 +289,7 @@ Number::Guard::doRound(rep& drops, std::string location) const auto r = round(); if (r == 1 || (r == 0 && (drops & 1) == 1)) { - if (drops >= kMAX_REP) + if (drops >= kMaxRep) { static_assert(sizeof(internalrep) == sizeof(rep)); // This should be impossible, because it's impossible to represent @@ -334,26 +334,26 @@ Number::externalToInternal(rep mantissa) constexpr Number Number::oneSmall() { - return Number{false, Number::kSMALL_RANGE.min, -Number::kSMALL_RANGE.log, Number::Unchecked{}}; + return Number{false, Number::kSmallRange.min, -Number::kSmallRange.log, Number::Unchecked{}}; }; -constexpr Number kONE_SML = Number::oneSmall(); +constexpr Number kOneSml = Number::oneSmall(); constexpr Number Number::oneLarge() { - return Number{false, Number::kLARGE_RANGE.min, -Number::kLARGE_RANGE.log, Number::Unchecked{}}; + return Number{false, Number::kLargeRange.min, -Number::kLargeRange.log, Number::Unchecked{}}; }; -constexpr Number kONE_LRG = Number::oneLarge(); +constexpr Number kOneLrg = Number::oneLarge(); Number Number::one() { - if (&kRANGE.get() == &kSMALL_RANGE) - return kONE_SML; - XRPL_ASSERT(&kRANGE.get() == &kLARGE_RANGE, "Number::one() : valid range"); - return kONE_LRG; + if (&kRange.get() == &kSmallRange) + return kOneSml; + XRPL_ASSERT(&kRange.get() == &kLargeRange, "Number::one() : valid range"); + return kOneLrg; } // Use the member names in this static function for now so the diff is cleaner @@ -367,22 +367,22 @@ doNormalize( MantissaRange::rep const& minMantissa, MantissaRange::rep const& maxMantissa) { - auto constexpr kMIN_EXPONENT = Number::kMIN_EXPONENT; - auto constexpr kMAX_EXPONENT = Number::kMAX_EXPONENT; - auto constexpr kMAX_REP = Number::kMAX_REP; + static constexpr auto kMinExponent = Number::kMinExponent; + static constexpr auto kMaxExponent = Number::kMaxExponent; + static constexpr auto kMaxRep = Number::kMaxRep; using Guard = Number::Guard; - constexpr Number kZERO = Number{}; + static constexpr Number kZero = Number{}; if (mantissa == 0) { - mantissa = kZERO.mantissa_; - exponent = kZERO.exponent_; - negative = kZERO.negative_; + mantissa = kZero.mantissa_; + exponent = kZero.exponent_; + negative = kZero.negative_; return; } auto m = mantissa; - while ((m < minMantissa) && (exponent > kMIN_EXPONENT)) + while ((m < minMantissa) && (exponent > kMinExponent)) { m *= 10; --exponent; @@ -392,17 +392,17 @@ doNormalize( g.setNegative(); while (m > maxMantissa) { - if (exponent >= kMAX_EXPONENT) + if (exponent >= kMaxExponent) throw std::overflow_error("Number::normalize 1"); g.push(m % 10); m /= 10; ++exponent; } - if ((exponent < kMIN_EXPONENT) || (m < minMantissa)) + if ((exponent < kMinExponent) || (m < minMantissa)) { - mantissa = kZERO.mantissa_; - exponent = kZERO.exponent_; - negative = kZERO.negative_; + mantissa = kZero.mantissa_; + exponent = kZero.exponent_; + negative = kZero.negative_; return; } @@ -419,9 +419,9 @@ doNormalize( // 9,900,000,000,000,123,450 or 9,900,000,000,000,123,460. // mantissa() will return mantissa_ / 10, and exponent() will return // exponent_ + 1. - if (m > kMAX_REP) + if (m > kMaxRep) { - if (exponent >= kMAX_EXPONENT) + if (exponent >= kMaxExponent) throw std::overflow_error("Number::normalize 1.5"); g.push(m % 10); m /= 10; @@ -431,7 +431,7 @@ doNormalize( // modification, it must be less than maxRep. In other words, the original // value should have been no more than maxRep * 10. // (maxRep * 10 > maxMantissa) - XRPL_ASSERT_PARTS(m <= kMAX_REP, "xrpl::doNormalize", "intermediate mantissa fits in int64"); + XRPL_ASSERT_PARTS(m <= kMaxRep, "xrpl::doNormalize", "intermediate mantissa fits in int64"); mantissa = m; g.doRoundUp(negative, mantissa, exponent, minMantissa, maxMantissa, "Number::normalize 2"); @@ -480,7 +480,7 @@ Number::normalize( void Number::normalize() { - auto const& range = kRANGE.get(); + auto const& range = kRange.get(); normalize(negative_, mantissa_, exponent_, range.min, range.max); } @@ -492,9 +492,9 @@ Number::shiftExponent(int exponentDelta) const { XRPL_ASSERT_PARTS(isnormal(), "xrpl::Number::shiftExponent", "normalized"); auto const newExponent = exponent_ + exponentDelta; - if (newExponent >= kMAX_EXPONENT) + if (newExponent >= kMaxExponent) throw std::overflow_error("Number::shiftExponent"); - if (newExponent < kMIN_EXPONENT) + if (newExponent < kMinExponent) { return Number{}; } @@ -506,17 +506,17 @@ Number::shiftExponent(int exponentDelta) const Number& Number::operator+=(Number const& y) { - constexpr Number kZERO = Number{}; - if (y == kZERO) + static constexpr Number kZero = Number{}; + if (y == kZero) return *this; - if (*this == kZERO) + if (*this == kZero) { *this = y; return *this; } if (*this == -y) { - *this = kZERO; + *this = kZero; return *this; } @@ -559,14 +559,14 @@ Number::operator+=(Number const& y) } while (xe > ye); } - auto const& range = kRANGE.get(); + auto const& range = kRange.get(); auto const& minMantissa = range.min; auto const& maxMantissa = range.max; if (xn == yn) { xm += ym; - if (xm > maxMantissa || xm > kMAX_REP) + if (xm > maxMantissa || xm > kMaxRep) { g.push(xm % 10); xm /= 10; @@ -586,7 +586,7 @@ Number::operator+=(Number const& y) xe = ye; xn = yn; } - while (xm < minMantissa && xm * 10 <= kMAX_REP) + while (xm < minMantissa && xm * 10 <= kMaxRep) { xm *= 10; xm -= g.pop(); @@ -633,10 +633,10 @@ divu10(uint128_t& u) Number& Number::operator*=(Number const& y) { - constexpr Number kZERO = Number{}; - if (*this == kZERO) + static constexpr Number kZero = Number{}; + if (*this == kZero) return *this; - if (y == kZERO) + if (y == kZero) { *this = y; return *this; @@ -664,11 +664,11 @@ Number::operator*=(Number const& y) if (zn) g.setNegative(); - auto const& range = kRANGE.get(); + auto const& range = kRange.get(); auto const& minMantissa = range.min; auto const& maxMantissa = range.max; - while (zm > maxMantissa || zm > kMAX_REP) + while (zm > maxMantissa || zm > kMaxRep) { // The following is optimization for: // g.push(static_cast(zm % 10)); @@ -696,10 +696,10 @@ Number::operator*=(Number const& y) Number& Number::operator/=(Number const& y) { - constexpr Number kZERO = Number{}; - if (y == kZERO) + static constexpr Number kZero = Number{}; + if (y == kZero) throw std::overflow_error("Number: divide by 0"); - if (*this == kZERO) + if (*this == kZero) return *this; // n* = numerator // d* = denominator @@ -718,7 +718,7 @@ Number::operator/=(Number const& y) auto dm = y.mantissa_; auto de = y.exponent_; - auto const& range = kRANGE.get(); + auto const& range = kRange.get(); auto const& minMantissa = range.min; auto const& maxMantissa = range.max; @@ -728,8 +728,8 @@ Number::operator/=(Number const& y) // log(2^128,10) ~ 38.5 // largeRange.log = 18, fits in 10^19 // f can be up to 10^(38-19) = 10^19 safely - static_assert(kSMALL_RANGE.log == 15); - static_assert(kLARGE_RANGE.log == 18); + static_assert(kSmallRange.log == 15); + static_assert(kLargeRange.log == 18); bool const small = Number::getMantissaScale() == MantissaRange::MantissaScale::Small; uint128_t const f = small ? 100'000'000'000'000'000 : 10'000'000'000'000'000'000ULL; XRPL_ASSERT_PARTS(f >= minMantissa * 10, "Number::operator/=", "factor expected size"); @@ -808,7 +808,7 @@ operator rep() const } for (; offset > 0; --offset) { - if (drops > kMAX_REP / 10) + if (drops > kMaxRep / 10) throw std::overflow_error("Number::operator rep() overflow"); drops *= 10; } @@ -839,8 +839,8 @@ std::string to_string(Number const& amount) { // keep full internal accuracy, but make more human friendly if possible - constexpr Number kZERO = Number{}; - if (amount == kZERO) + static constexpr Number kZero = Number{}; + if (amount == kZero) return "0"; auto exponent = amount.exponent_; @@ -851,7 +851,7 @@ to_string(Number const& amount) auto const rangeLog = Number::mantissaLog(); if (((exponent != 0) && ((exponent < -(rangeLog + 10)) || (exponent > -(rangeLog - 10))))) { - while (mantissa != 0 && mantissa % 10 == 0 && exponent < Number::kMAX_EXPONENT) + while (mantissa != 0 && mantissa % 10 == 0 && exponent < Number::kMaxExponent) { mantissa /= 10; ++exponent; @@ -959,7 +959,7 @@ power(Number const& f, unsigned n) Number root(Number f, unsigned d) { - constexpr Number kZERO = Number{}; + static constexpr Number kZero = Number{}; auto const one = Number::one(); if (f == one || d == 1) @@ -969,12 +969,12 @@ root(Number f, unsigned d) if (f == -one) return one; if (abs(f) < one) - return kZERO; + return kZero; throw std::overflow_error("Number::root infinity"); } - if (f < kZERO && d % 2 == 0) + if (f < kZero && d % 2 == 0) throw std::overflow_error("Number::root nan"); - if (f == kZERO) + if (f == kZero) return f; // Scale f into the range (0, 1) such that f's exponent is a multiple of d @@ -993,7 +993,7 @@ root(Number f, unsigned d) XRPL_ASSERT_PARTS(f.isnormal(), "xrpl::root(Number, unsigned)", "f is normalized"); bool neg = false; - if (f < kZERO) + if (f < kZero) { neg = true; f = -f; @@ -1031,14 +1031,14 @@ root(Number f, unsigned d) Number root2(Number f) { - constexpr Number kZERO = Number{}; + static constexpr Number kZero = Number{}; auto const one = Number::one(); if (f == one) return f; - if (f < kZERO) + if (f < kZero) throw std::overflow_error("Number::root nan"); - if (f == kZERO) + if (f == kZero) return f; // Scale f into the range (0, 1) such that f's exponent is a multiple of d @@ -1078,7 +1078,7 @@ root2(Number f) Number power(Number const& f, unsigned n, unsigned d) { - constexpr Number kZERO = Number{}; + static constexpr Number kZero = Number{}; auto const one = Number::one(); if (f == one) @@ -1091,7 +1091,7 @@ power(Number const& f, unsigned n, unsigned d) if (f == -one) return one; if (abs(f) < one) - return kZERO; + return kZero; // abs(f) > one throw std::overflow_error("Number::power infinity"); } @@ -1099,7 +1099,7 @@ power(Number const& f, unsigned n, unsigned d) return one; n /= g; d /= g; - if ((n % 2) == 1 && (d % 2) == 0 && f < kZERO) + if ((n % 2) == 1 && (d % 2) == 0 && f < kZero) throw std::overflow_error("Number::power nan"); return root(power(f, n), d); } diff --git a/src/libxrpl/basics/ResolverAsio.cpp b/src/libxrpl/basics/ResolverAsio.cpp index 4e64c280c7..ddf006b681 100644 --- a/src/libxrpl/basics/ResolverAsio.cpp +++ b/src/libxrpl/basics/ResolverAsio.cpp @@ -108,7 +108,7 @@ public: beast::Journal journal; - boost::asio::io_context& io_context; + boost::asio::io_context& ioContext; boost::asio::strand strand; boost::asio::ip::tcp::resolver resolver; @@ -116,7 +116,7 @@ public: std::mutex mut; bool asyncHandlersCompleted{true}; - std::atomic stop_called; + std::atomic stopCalled; std::atomic stopped; // Represents a unit of work for the resolver to do @@ -138,10 +138,10 @@ public: ResolverAsioImpl(boost::asio::io_context& ioContext, beast::Journal journal) : journal(journal) - , io_context(ioContext) + , ioContext(ioContext) , strand(boost::asio::make_strand(ioContext)) , resolver(ioContext) - , stop_called(false) + , stopCalled(false) , stopped(true) { } @@ -172,7 +172,7 @@ public: start() override { XRPL_ASSERT(stopped == true, "xrpl::ResolverAsioImpl::start : stopped"); - XRPL_ASSERT(stop_called == false, "xrpl::ResolverAsioImpl::start : not stopping"); + XRPL_ASSERT(stopCalled == false, "xrpl::ResolverAsioImpl::start : not stopping"); if (stopped.exchange(false)) { @@ -187,10 +187,10 @@ public: void stopAsync() override { - if (!stop_called.exchange(true)) + if (!stopCalled.exchange(true)) { boost::asio::dispatch( - io_context, + ioContext, boost::asio::bind_executor( strand, std::bind(&ResolverAsioImpl::doStop, this, CompletionCounter(this)))); @@ -213,13 +213,13 @@ public: void resolve(std::vector const& names, HandlerType const& handler) override { - XRPL_ASSERT(stop_called == false, "xrpl::ResolverAsioImpl::resolve : not stopping"); + XRPL_ASSERT(stopCalled == false, "xrpl::ResolverAsioImpl::resolve : not stopping"); XRPL_ASSERT(!names.empty(), "xrpl::ResolverAsioImpl::resolve : names non-empty"); // TODO NIKB use rvalue references to construct and move // reducing cost. boost::asio::dispatch( - io_context, + ioContext, boost::asio::bind_executor( strand, std::bind( @@ -231,7 +231,7 @@ public: void doStop(CompletionCounter) { - XRPL_ASSERT(stop_called == true, "xrpl::ResolverAsioImpl::do_stop : stopping"); + XRPL_ASSERT(stopCalled == true, "xrpl::ResolverAsioImpl::doStop : stopping"); if (!stopped.exchange(true)) { @@ -270,7 +270,7 @@ public: handler(name, addresses); boost::asio::post( - io_context, + ioContext, boost::asio::bind_executor( strand, std::bind(&ResolverAsioImpl::doWork, this, CompletionCounter(this)))); } @@ -324,7 +324,7 @@ public: void doWork(CompletionCounter) { - if (stop_called) + if (stopCalled) return; // We don't have any work to do at this time @@ -346,7 +346,7 @@ public: JLOG(journal.error()) << "Unable to parse '" << name << "'"; boost::asio::post( - io_context, + ioContext, boost::asio::bind_executor( strand, std::bind(&ResolverAsioImpl::doWork, this, CompletionCounter(this)))); @@ -369,9 +369,9 @@ 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) + if (!stopCalled) { work.emplace_back(names, handler); @@ -381,7 +381,7 @@ public: if (!work.empty()) { boost::asio::post( - io_context, + ioContext, boost::asio::bind_executor( strand, std::bind(&ResolverAsioImpl::doWork, this, CompletionCounter(this)))); diff --git a/src/libxrpl/basics/StringUtilities.cpp b/src/libxrpl/basics/StringUtilities.cpp index f1f8515ae1..f4edaf5aca 100644 --- a/src/libxrpl/basics/StringUtilities.cpp +++ b/src/libxrpl/basics/StringUtilities.cpp @@ -37,7 +37,7 @@ bool parseUrl(ParsedUrl& pUrl, std::string const& strUrl) { // scheme://username:password@hostname:port/rest - static boost::regex const kRE_URL( + static boost::regex const kReUrl( "(?i)\\`\\s*" // required scheme "([[:alpha:]][-+.[:alpha:][:digit:]]*?):" @@ -58,7 +58,7 @@ parseUrl(ParsedUrl& pUrl, std::string const& strUrl) // Bail if there is no match. try { - if (!boost::regex_match(strUrl, smMatch, kRE_URL)) + if (!boost::regex_match(strUrl, smMatch, kReUrl)) return false; } catch (...) @@ -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/basics/UptimeClock.cpp b/src/libxrpl/basics/UptimeClock.cpp index 5b92617098..0ae5f6bfe9 100644 --- a/src/libxrpl/basics/UptimeClock.cpp +++ b/src/libxrpl/basics/UptimeClock.cpp @@ -7,15 +7,15 @@ namespace xrpl { -std::atomic UptimeClock::kNOW{0}; // seconds since start -std::atomic UptimeClock::kSTOP{false}; // stop update thread +std::atomic UptimeClock::kNow{0}; // seconds since start +std::atomic UptimeClock::kStop{false}; // stop update thread // On xrpld shutdown, cancel and wait for the update thread UptimeClock::UpdateThread::~UpdateThread() { if (joinable()) { - kSTOP = true; + kStop = true; // This join() may take up to a 1s, but happens only // once at xrpld shutdown. join(); @@ -30,13 +30,13 @@ UptimeClock::startClock() using namespace std; using namespace std::chrono; - // Wake up every second and update kNOW + // Wake up every second and update kNow auto next = system_clock::now() + 1s; - while (!kSTOP) + while (!kStop) { this_thread::sleep_until(next); next += 1s; - ++kNOW; + ++kNow; } }}; } @@ -49,10 +49,10 @@ UptimeClock::time_point UptimeClock::now() { // start the update thread on first use - static auto const kINIT = startClock(); + static auto const kInit = startClock(); // Return the number of seconds since xrpld start - return time_point{duration{kNOW}}; + return time_point{duration{kNow}}; } } // namespace xrpl diff --git a/src/libxrpl/basics/base64.cpp b/src/libxrpl/basics/base64.cpp index 7a649a8c3a..541ddd0839 100644 --- a/src/libxrpl/basics/base64.cpp +++ b/src/libxrpl/basics/base64.cpp @@ -47,15 +47,15 @@ namespace base64 { inline char const* getAlphabet() { - static char constexpr kTAB[] = { + static constexpr char kTab[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"}; - return &kTAB[0]; + return &kTab[0]; } inline signed char const* getInverse() { - static signed char constexpr kTAB[] = { + static constexpr signed char kTab[] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0-15 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 16-31 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, // 32-47 @@ -73,17 +73,19 @@ getInverse() -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 224-239 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 // 240-255 }; - return &kTAB[0]; + return &kTab[0]; } /// Returns max chars needed to encode a base64 string -std::size_t constexpr encodedSize(std::size_t n) +constexpr std::size_t +encodedSize(std::size_t n) { return 4 * ((n + 2) / 3); } /// Returns max bytes needed to decode a base64 string -std::size_t constexpr decodedSize(std::size_t n) +constexpr std::size_t +decodedSize(std::size_t n) { return ((n / 4) * 3) + 2; } diff --git a/src/libxrpl/basics/make_SSLContext.cpp b/src/libxrpl/basics/make_SSLContext.cpp index 89da14333a..165d36076b 100644 --- a/src/libxrpl/basics/make_SSLContext.cpp +++ b/src/libxrpl/basics/make_SSLContext.cpp @@ -60,7 +60,7 @@ int gDefaultRsaKeyBits = 2048; @note If you increase the number of bits you need to update defaultRSAKeyBits accordingly. */ -static constexpr char const kDEFAULT_DH[] = +static constexpr char kDefaultDh[] = "-----BEGIN DH PARAMETERS-----\n" "MIIBCAKCAQEApKSWfR7LKy0VoZ/SDCObCvJ5HKX2J93RJ+QN8kJwHh+uuA8G+t8Q\n" "MDRjL5HanlV/sKN9HXqBc7eqHmmbqYwIXKUt9MUZTLNheguddxVlc2IjdP5i9Ps8\n" @@ -84,14 +84,14 @@ static constexpr char const kDEFAULT_DH[] = global or per-port basis, using the `ssl_ciphers` directive in the config file. */ -std::string const kDEFAULT_CIPHER_LIST = "TLSv1.2:!CBC:!DSS:!PSK:!eNULL:!aNULL"; +std::string const kDefaultCipherList = "TLSv1.2:!CBC:!DSS:!PSK:!eNULL:!aNULL"; static void initAnonymous(boost::asio::ssl::context& context) { using namespace openssl; - static auto kDEFAULT_RSA = []() { + static auto kDefaultRsa = []() { BIGNUM* bn = BN_new(); BN_set_word(bn, RSA_F4); @@ -108,7 +108,7 @@ initAnonymous(boost::asio::ssl::context& context) return rsa; }(); - static auto kDEFAULT_EPHEMERAL_PRIVATE_KEY = []() { + static auto kDefaultEphemeralPrivateKey = []() { auto pkey = EVP_PKEY_new(); if (!pkey) @@ -116,16 +116,16 @@ initAnonymous(boost::asio::ssl::context& context) // We need to up the reference count of here, since we are retaining a // copy of the key for (potential) reuse. - if (RSA_up_ref(kDEFAULT_RSA) != 1) + if (RSA_up_ref(kDefaultRsa) != 1) logicError("EVP_PKEY_assign_RSA: incrementing reference count failed"); - if (!EVP_PKEY_assign_RSA(pkey, kDEFAULT_RSA)) + if (!EVP_PKEY_assign_RSA(pkey, kDefaultRsa)) logicError("EVP_PKEY_assign_RSA failed"); return pkey; }(); - static auto kDEFAULT_CERT = []() { + static auto kDefaultCert = []() { auto x509 = X509_new(); if (x509 == nullptr) @@ -205,9 +205,9 @@ initAnonymous(boost::asio::ssl::context& context) } // And a private key - X509_set_pubkey(x509, kDEFAULT_EPHEMERAL_PRIVATE_KEY); + X509_set_pubkey(x509, kDefaultEphemeralPrivateKey); - if (!X509_sign(x509, kDEFAULT_EPHEMERAL_PRIVATE_KEY, EVP_sha256())) + if (!X509_sign(x509, kDefaultEphemeralPrivateKey, EVP_sha256())) logicError("X509_sign failed"); return x509; @@ -215,10 +215,10 @@ initAnonymous(boost::asio::ssl::context& context) SSL_CTX* const ctx = context.native_handle(); - if (SSL_CTX_use_certificate(ctx, kDEFAULT_CERT) <= 0) + if (SSL_CTX_use_certificate(ctx, kDefaultCert) <= 0) logicError("SSL_CTX_use_certificate failed"); - if (SSL_CTX_use_PrivateKey(ctx, kDEFAULT_EPHEMERAL_PRIVATE_KEY) <= 0) + if (SSL_CTX_use_PrivateKey(ctx, kDefaultEphemeralPrivateKey) <= 0) logicError("SSL_CTX_use_PrivateKey failed"); } @@ -330,12 +330,12 @@ getContext(std::string cipherList) boost::asio::ssl::context::no_compression); if (cipherList.empty()) - cipherList = kDEFAULT_CIPHER_LIST; + cipherList = kDefaultCipherList; if (auto result = SSL_CTX_set_cipher_list(c->native_handle(), cipherList.c_str()); result != 1) logicError("SSL_CTX_set_cipher_list failed"); - c->use_tmp_dh({std::addressof(detail::kDEFAULT_DH), sizeof(kDEFAULT_DH)}); + c->use_tmp_dh({std::addressof(detail::kDefaultDh), sizeof(kDefaultDh)}); // Disable all renegotiation support in TLS v1.2. This can help prevent // exploitation of the bug described in CVE-2021-3499 (for details see diff --git a/src/libxrpl/basics/mulDiv.cpp b/src/libxrpl/basics/mulDiv.cpp index 64d37a35c3..b5e6304738 100644 --- a/src/libxrpl/basics/mulDiv.cpp +++ b/src/libxrpl/basics/mulDiv.cpp @@ -15,7 +15,7 @@ mulDiv(std::uint64_t value, std::uint64_t mul, std::uint64_t div) result /= div; - if (result > xrpl::kMULDIV_MAX) + if (result > xrpl::kMuldivMax) return std::nullopt; return static_cast(result); diff --git a/src/libxrpl/beast/clock/basic_seconds_clock.cpp b/src/libxrpl/beast/clock/basic_seconds_clock.cpp index 2c8ac34b6a..ec003ffb1f 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; @@ -81,8 +81,8 @@ SecondsClockThread::run() BasicSecondsClock::time_point BasicSecondsClock::now() { - static SecondsClockThread kCLK; - return kCLK.now(); + static SecondsClockThread kClk; + return kClk.now(); } } // namespace beast diff --git a/src/libxrpl/beast/core/CurrentThreadName.cpp b/src/libxrpl/beast/core/CurrentThreadName.cpp index 39daa286c6..52d9063179 100644 --- a/src/libxrpl/beast/core/CurrentThreadName.cpp +++ b/src/libxrpl/beast/core/CurrentThreadName.cpp @@ -80,20 +80,19 @@ inline void setCurrentThreadNameImpl(std::string_view name) { // truncate and set the thread name. - char boundedName[kMAX_THREAD_NAME_LENGTH + 1]; + char boundedName[kMaxThreadNameLength + 1]; auto const boundedSize = - name.size() < kMAX_THREAD_NAME_LENGTH ? name.size() : kMAX_THREAD_NAME_LENGTH; + name.size() < kMaxThreadNameLength ? name.size() : kMaxThreadNameLength; name.copy(boundedName, boundedSize); boundedName[boundedSize] = '\0'; pthread_setname_np(pthread_self(), boundedName); #ifdef TRUNCATED_THREAD_NAME_LOGS - if (name.size() > kMAX_THREAD_NAME_LENGTH) + if (name.size() > kMaxThreadNameLength) { std::cerr << "WARNING: Thread name \"" << name << "\" (length " << name.size() - << ") exceeds maximum of " << kMAX_THREAD_NAME_LENGTH - << " characters on Linux.\n"; + << ") exceeds maximum of " << kMaxThreadNameLength << " characters on Linux.\n"; } #endif } diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp index 90d06ddf28..88f52c26de 100644 --- a/src/libxrpl/beast/insight/StatsDCollector.cpp +++ b/src/libxrpl/beast/insight/StatsDCollector.cpp @@ -164,7 +164,7 @@ public: private: std::shared_ptr impl_; std::string name_; - GaugeImpl::value_type last_value_{0}; + GaugeImpl::value_type lastValue_{0}; GaugeImpl::value_type value_{0}; bool dirty_{false}; }; @@ -204,17 +204,12 @@ 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 kMaxPacketSize = 1472; Journal journal_; IP::Endpoint address_; std::string prefix_; - boost::asio::io_context io_context_; + boost::asio::io_context ioContext_; std::optional> work_; boost::asio::strand strand_; boost::asio::basic_waitable_timer timer_; @@ -237,10 +232,10 @@ public: : journal_(journal) , address_(std::move(address)) , prefix_(std::move(prefix)) - , work_(boost::asio::make_work_guard(io_context_)) - , strand_(boost::asio::make_strand(io_context_)) - , timer_(io_context_) - , socket_(io_context_) + , work_(boost::asio::make_work_guard(ioContext_)) + , strand_(boost::asio::make_strand(ioContext_)) + , timer_(ioContext_) + , socket_(ioContext_) , thread_(&StatsDCollectorImp::run, this) { } @@ -311,7 +306,7 @@ public: boost::asio::io_context& getIoContext() { - return io_context_; + return ioContext_; } std::string const& @@ -330,7 +325,7 @@ public: postBuffer(std::string&& buffer) { boost::asio::dispatch( - io_context_, + ioContext_, boost::asio::bind_executor( strand_, std::bind(&StatsDCollectorImp::doPostBuffer, this, std::move(buffer)))); } @@ -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) > kMaxPacketSize) { log(buffers); socket_.async_send( @@ -470,14 +465,14 @@ public: setTimer(); - io_context_.run(); + ioContext_.run(); // NOLINTNEXTLINE(bugprone-unused-return-value) socket_.shutdown(boost::asio::ip::udp::socket::shutdown_send, ec); socket_.close(); - io_context_.poll(); + ioContext_.poll(); } }; @@ -633,9 +628,9 @@ StatsDGaugeImpl::doSet(GaugeImpl::value_type value) { value_ = value; - if (value_ != last_value_) + if (value_ != lastValue_) { - last_value_ = value_; + lastValue_ = value_; dirty_ = true; } } diff --git a/src/libxrpl/beast/net/IPAddressV4.cpp b/src/libxrpl/beast/net/IPAddressV4.cpp index 48554d0ec3..f9b0c96022 100644 --- a/src/libxrpl/beast/net/IPAddressV4.cpp +++ b/src/libxrpl/beast/net/IPAddressV4.cpp @@ -14,14 +14,52 @@ 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 getClass(AddressV4 const& addr) { - static char const* kTABLE = "AAAABBCD"; // cspell:disable-line - return kTABLE[(addr.to_uint() & 0xE0000000) >> 29]; + static char const* kTable = "AAAABBCD"; // cspell:disable-line + return kTable[(addr.to_uint() & 0xE0000000) >> 29]; } } // namespace beast::IP 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..0837dd2392 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 { } }; @@ -62,8 +62,8 @@ public: Journal::Sink& Journal::getNullSink() { - static NullJournalSink kSINK; - return kSINK; + static NullJournalSink kSink; + return kSink; } //------------------------------------------------------------------------------ @@ -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/conditions/Condition.cpp b/src/libxrpl/conditions/Condition.cpp index 004778bc4e..cb950c9e24 100644 --- a/src/libxrpl/conditions/Condition.cpp +++ b/src/libxrpl/conditions/Condition.cpp @@ -52,7 +52,7 @@ namespace detail { // ed25519Sha256 (4) // } -constexpr std::size_t kFINGERPRINT_SIZE = 32; +constexpr std::size_t kFingerprintSize = 32; std::unique_ptr loadSimpleSha256(Type type, Slice s, std::error_code& ec) @@ -76,7 +76,7 @@ loadSimpleSha256(Type type, Slice s, std::error_code& ec) return {}; } - if (p.length != kFINGERPRINT_SIZE) + if (p.length != kFingerprintSize) { ec = Error::FingerprintSize; return {}; @@ -118,7 +118,7 @@ loadSimpleSha256(Type type, Slice s, std::error_code& ec) switch (type) { case Type::PreimageSha256: - if (cost > PreimageSha256::kMAX_PREIMAGE_LENGTH) + if (cost > PreimageSha256::kMaxPreimageLength) { ec = Error::PreimageTooLong; return {}; @@ -173,7 +173,7 @@ Condition::deserialize(Slice s, std::error_code& ec) return {}; } - if (s.size() > kMAX_SERIALIZED_CONDITION) + if (s.size() > kMaxSerializedCondition) { ec = Error::LargeSize; return {}; diff --git a/src/libxrpl/conditions/Fulfillment.cpp b/src/libxrpl/conditions/Fulfillment.cpp index 52f89a6150..eaad6b8cdb 100644 --- a/src/libxrpl/conditions/Fulfillment.cpp +++ b/src/libxrpl/conditions/Fulfillment.cpp @@ -82,7 +82,7 @@ Fulfillment::deserialize(Slice s, std::error_code& ec) return {}; } - if (p.length > kMAX_SERIALIZED_FULFILLMENT) + if (p.length > kMaxSerializedFulfillment) { ec = Error::LargeSize; return {}; diff --git a/src/libxrpl/conditions/error.cpp b/src/libxrpl/conditions/error.cpp index a26a153975..48e8ece94f 100644 --- a/src/libxrpl/conditions/error.cpp +++ b/src/libxrpl/conditions/error.cpp @@ -101,8 +101,8 @@ public: inline std::error_category const& getCryptoconditionsErrorCategory() { - static CryptoconditionsErrorCategory const kCAT{}; - return kCAT; + static CryptoconditionsErrorCategory const kCat{}; + return kCat; } } // namespace detail diff --git a/src/libxrpl/core/detail/Job.cpp b/src/libxrpl/core/detail/Job.cpp index a1b88864d7..89fe42db05 100644 --- a/src/libxrpl/core/detail/Job.cpp +++ b/src/libxrpl/core/detail/Job.cpp @@ -25,7 +25,7 @@ Job::Job( std::uint64_t index, LoadMonitor& lm, std::function const& job) - : type_(type), jobIndex_(index), job_(job), name_(name), queue_time_(clock_type::now()) + : type_(type), jobIndex_(index), job_(job), name_(name), queueTime_(clock_type::now()) { loadEvent_ = std::make_shared(std::ref(lm), name, false); } @@ -39,7 +39,7 @@ Job::getType() const Job::clock_type::time_point const& Job::queueTime() const { - return queue_time_; + return queueTime_; } void diff --git a/src/libxrpl/core/detail/JobQueue.cpp b/src/libxrpl/core/detail/JobQueue.cpp index 06a2d226e1..5c07bf68cc 100644 --- a/src/libxrpl/core/detail/JobQueue.cpp +++ b/src/libxrpl/core/detail/JobQueue.cpp @@ -36,7 +36,7 @@ JobQueue::JobQueue( JLOG(journal_.info()) << "Using " << threadCount << " threads"; hook_ = collector_->makeHook(std::bind(&JobQueue::collect, this)); - job_count_ = collector_->makeGauge("job_count"); + jobCount_ = collector_->makeGauge("job_count"); { std::scoped_lock const lock(mutex_); @@ -66,7 +66,7 @@ void JobQueue::collect() { std::scoped_lock const lock(mutex_); - job_count_ = jobSet_.size(); + jobCount_ = jobSet_.size(); } bool @@ -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/core/detail/Workers.cpp b/src/libxrpl/core/detail/Workers.cpp index 991c51b77a..0d9c1afd26 100644 --- a/src/libxrpl/core/detail/Workers.cpp +++ b/src/libxrpl/core/detail/Workers.cpp @@ -46,7 +46,7 @@ Workers::getNumberOfThreads() const noexcept void Workers::setNumberOfThreads(int numberOfThreads) { - static int kINSTANCE{0}; + static int kInstance{0}; if (numberOfThreads_ == numberOfThreads) return; @@ -72,7 +72,7 @@ Workers::setNumberOfThreads(int numberOfThreads) } else { - worker = new Worker(*this, threadNames_, kINSTANCE++); + worker = new Worker(*this, threadNames_, kInstance++); everyone_.pushFront(worker); } } diff --git a/src/libxrpl/crypto/csprng.cpp b/src/libxrpl/crypto/csprng.cpp index 897432fcf1..e000786c4a 100644 --- a/src/libxrpl/crypto/csprng.cpp +++ b/src/libxrpl/crypto/csprng.cpp @@ -80,8 +80,8 @@ CsprngEngine::operator()() CsprngEngine& cryptoPrng() { - static CsprngEngine kENGINE; - return kENGINE; + static CsprngEngine kEngine; + return kEngine; } } // namespace xrpl diff --git a/src/libxrpl/git/Git.cpp b/src/libxrpl/git/Git.cpp index e13b2ef693..d5f3a24b3a 100644 --- a/src/libxrpl/git/Git.cpp +++ b/src/libxrpl/git/Git.cpp @@ -11,21 +11,21 @@ namespace xrpl::git { -static constexpr char kGIT_COMMIT_HASH[] = GIT_COMMIT_HASH; -static constexpr char kGIT_BUILD_BRANCH[] = GIT_BUILD_BRANCH; +static constexpr char kGitCommitHash[] = GIT_COMMIT_HASH; +static constexpr char kGitBuildBranch[] = GIT_BUILD_BRANCH; std::string const& getCommitHash() { - static std::string const kVALUE = kGIT_COMMIT_HASH; - return kVALUE; + static std::string const kValue = kGitCommitHash; + return kValue; } std::string const& getBuildBranch() { - static std::string const kVALUE = kGIT_BUILD_BRANCH; - return kVALUE; + static std::string const kValue = kGitBuildBranch; + return kValue; } } // namespace xrpl::git 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/Writer.cpp b/src/libxrpl/json/Writer.cpp index 518573ded4..c5c4b3cd31 100644 --- a/src/libxrpl/json/Writer.cpp +++ b/src/libxrpl/json/Writer.cpp @@ -26,18 +26,18 @@ std::map gJsonSpecialCharacterEscape = { {'\r', "\\r"}, {'\t', "\\t"}}; -size_t const kJSON_ESCAPE_LENGTH = 2; +size_t const kJsonEscapeLength = 2; // All other JSON punctuation. -char const kCLOSE_BRACE = '}'; -char const kCLOSE_BRACKET = ']'; -char const kCOLON = ':'; -char const kCOMMA = ','; -char const kOPEN_BRACE = '{'; -char const kOPEN_BRACKET = '['; -char const kQUOTE = '"'; +char const kCloseBrace = '}'; +char const kCloseBracket = ']'; +char const kColon = ':'; +char const kComma = ','; +char const kOpenBrace = '{'; +char const kOpenBracket = '['; +char const kQuote = '"'; -auto const kINTEGRAL_FLOATS_BECOME_INTS = false; +auto const kIntegralFloatsBecomeInts = false; size_t lengthWithoutTrailingZeros(std::string const& s) @@ -52,7 +52,7 @@ lengthWithoutTrailingZeros(std::string const& s) if (hasDecimals) return lastNonZero + 1; - if (kINTEGRAL_FLOATS_BECOME_INTS || lastNonZero + 2 > s.size()) + if (kIntegralFloatsBecomeInts || lastNonZero + 2 > s.size()) return lastNonZero; return lastNonZero + 2; @@ -81,7 +81,7 @@ public: void start(CollectionType ct) { - char const ch = (ct == CollectionType::Array) ? kOPEN_BRACKET : kOPEN_BRACE; + char const ch = (ct == CollectionType::Array) ? kOpenBracket : kOpenBrace; output({&ch, 1}); stack_.emplace(Collection{.type = ct}); } @@ -99,7 +99,7 @@ public: markStarted(); std::size_t position = 0, writtenUntil = 0; - output_({&kQUOTE, 1}); + output_({&kQuote, 1}); auto data = bytes.data(); for (; position < bytes.size(); ++position) { @@ -110,13 +110,13 @@ public: { output_({data + writtenUntil, position - writtenUntil}); } - output_({i->second, kJSON_ESCAPE_LENGTH}); + output_({i->second, kJsonEscapeLength}); writtenUntil = position + 1; }; } if (writtenUntil < position) output_({data + writtenUntil, position - writtenUntil}); - output_({&kQUOTE, 1}); + output_({&kQuote, 1}); } void @@ -144,7 +144,7 @@ public: } else { - output_({&kCOMMA, 1}); + output_({&kComma, 1}); } } @@ -159,7 +159,7 @@ public: #endif stringOutput(tag); - output_({&kCOLON, 1}); + output_({&kColon, 1}); } [[nodiscard]] bool @@ -174,7 +174,7 @@ public: check(!empty(), "Empty stack in finish()"); auto isArray = stack_.top().type == CollectionType::Array; - auto ch = isArray ? kCLOSE_BRACKET : kCLOSE_BRACE; + auto ch = isArray ? kCloseBracket : kCloseBrace; output_({&ch, 1}); stack_.pop(); } diff --git a/src/libxrpl/json/json_reader.cpp b/src/libxrpl/json/json_reader.cpp index 6574789e7b..3786f51fdd 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); @@ -117,41 +117,41 @@ Reader::readValue(unsigned depth) { Token token{}; skipCommentTokens(token); - if (depth > kNEST_LIMIT) + if (depth > kNestLimit) return addError("Syntax error: maximum nesting depth exceeded", token); bool successful = true; 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; @@ -352,9 +352,9 @@ Reader::readCppStyleComment() Reader::TokenType Reader::readNumber() { - static char const kEXTENDED_TOKENS[] = {'.', 'e', 'E', '+', '-'}; + static char const kExtendedTokens[] = {'.', 'e', 'E', '+', '-'}; - TokenType type = TokenInteger; + TokenType type = TokenType::Integer; if (current_ != end_) { @@ -365,12 +365,12 @@ Reader::readNumber() { if (std::isdigit(static_cast(*current_)) == 0) { - auto ret = std::ranges::find(kEXTENDED_TOKENS, *current_); + auto ret = std::ranges::find(kExtendedTokens, *current_); - if (ret == std::end(kEXTENDED_TOKENS)) + if (ret == std::end(kExtendedTokens)) 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::kMaxUInt), "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::kMaxUInt)) { Char const c = *current++; @@ -569,7 +569,7 @@ Reader::decodeNumber(Token& token) { value = -value; - if (value < Value::kMIN_INT || value > Value::kMAX_INT) + if (value < Value::kMinInt || value > Value::kMaxInt) { return addError( "'" + std::string(token.start, token.end) + "' exceeds the allowable range.", @@ -580,7 +580,7 @@ Reader::decodeNumber(Token& token) } else { - if (value > Value::kMAX_U_INT) + if (value > Value::kMaxUInt) { return addError( "'" + std::string(token.start, token.end) + "' exceeds the allowable range.", @@ -588,7 +588,7 @@ Reader::decodeNumber(Token& token) } // If it's representable as a signed integer, construct it as one. - if (value <= Value::kMAX_INT) + if (value <= Value::kMaxInt) { currentValue() = static_cast(value); } @@ -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..93875f497a 100644 --- a/src/libxrpl/json/json_value.cpp +++ b/src/libxrpl/json/json_value.cpp @@ -17,7 +17,7 @@ namespace json { -Value const Value::kNULL; +Value const Value::kNull; class DefaultValueAllocator : public ValueAllocator { @@ -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)); @@ -64,8 +64,8 @@ public: static ValueAllocator*& valueAllocator() { - static ValueAllocator* kVALUE_ALLOCATOR = new DefaultValueAllocator; // NOLINT TODO - return kVALUE_ALLOCATOR; + static ValueAllocator* kValueAllocator = new DefaultValueAllocator; // NOLINT TODO + return kValueAllocator; } static struct DummyValueAllocatorInitializer @@ -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"); + value_.uintVal < (unsigned)kMaxInt, "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), + (value_.realVal >= kMinInt && value_.realVal <= kMaxInt), "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 <= kMaxUInt, "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 <= kMaxUInt, "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 <= kMaxUInt, "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 <= kMaxUInt, "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 <= kMaxUInt), "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)kMaxInt) || + 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 >= kMinInt && + value_.realVal <= kMaxInt) || + (other == ValueType::UInt && value_.realVal >= 0 && value_.realVal <= kMaxUInt && 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); @@ -859,7 +869,7 @@ Value::operator[](UInt index) if (it != value_.mapVal->end() && (*it).first == key) return (*it).second; - ObjectValues::value_type const defaultValue(key, kNULL); + ObjectValues::value_type const defaultValue(key, kNull); it = value_.mapVal->insert(it, defaultValue); return (*it).second; } @@ -868,17 +878,17 @@ 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) - return kNULL; + if (type_ == ValueType::Null) + return kNull; CZString const key(index); ObjectValues::const_iterator const it = value_.mapVal->find(key); if (it == value_.mapVal->end()) - return kNULL; + return kNull; return (*it).second; } @@ -893,18 +903,22 @@ 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) return (*it).second; - ObjectValues::value_type const defaultValue(actualKey, kNULL); + ObjectValues::value_type const defaultValue(actualKey, kNull); it = value_.mapVal->insert(it, defaultValue); Value& value = (*it).second; return value; @@ -914,7 +928,7 @@ Value Value::get(UInt index, Value const& defaultValue) const { Value const* value = &((*this)[index]); - return value == &kNULL ? defaultValue : *value; + return value == &kNull ? defaultValue : *value; } bool @@ -927,17 +941,17 @@ 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) - return kNULL; + 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()) - return kNULL; + return kNull; return (*it).second; } @@ -982,7 +996,7 @@ Value Value::get(char const* key, Value const& defaultValue) const { Value const* value = &((*this)[key]); - return value == &kNULL ? defaultValue : *value; + return value == &kNull ? defaultValue : *value; } Value @@ -995,16 +1009,17 @@ 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) - return kNULL; + 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()) - return kNULL; + return kNull; Value old(it->second); value_.mapVal->erase(it); @@ -1020,11 +1035,11 @@ 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]); - return value != &kNULL; + return value != &kNull; } bool @@ -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..70fa0aef5d 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::kSmdChangeOrig) && !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::kSmdAlways | SField::kSmdDeleteFinal)) 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::kSmdChangeOrig) && !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::kSmdAlways | SField::kSmdChangeNew)) 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::kSmdCreate | SField::kSmdAlways)) 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/ApplyView.cpp b/src/libxrpl/ledger/ApplyView.cpp index 3343748a75..2200afecac 100644 --- a/src/libxrpl/ledger/ApplyView.cpp +++ b/src/libxrpl/ledger/ApplyView.cpp @@ -125,7 +125,7 @@ insertPage( // Check whether we're out of pages. if (page == 0) return std::nullopt; - if (!view.rules().enabled(fixDirectoryLimit) && page >= kDIR_NODE_MAX_PAGES) // Old pages limit + if (!view.rules().enabled(fixDirectoryLimit) && page >= kDirNodeMaxPages) // Old pages limit return std::nullopt; // We are about to create a new node; we'll link it to @@ -179,7 +179,7 @@ ApplyView::dirAdd( auto [page, node, indexes] = directory::findPreviousPage(*this, directory, root); // If there's space, we use it: - if (indexes.size() < kDIR_NODE_MAX_ENTRIES) + if (indexes.size() < kDirNodeMaxEntries) { return directory::insertKey(*this, node, page, preserveOrder, indexes, key); } @@ -208,19 +208,19 @@ ApplyView::emptyDirDelete(Keylet const& directory) if (!node->getFieldV256(sfIndexes).empty()) return false; - std::uint64_t constexpr kROOT_PAGE = 0; + static constexpr std::uint64_t kRootPage = 0; auto prevPage = node->getFieldU64(sfIndexPrevious); auto nextPage = node->getFieldU64(sfIndexNext); - if (nextPage == kROOT_PAGE && prevPage != kROOT_PAGE) + if (nextPage == kRootPage && prevPage != kRootPage) Throw("Directory chain: fwd link broken"); // LCOV_EXCL_LINE - if (prevPage == kROOT_PAGE && nextPage != kROOT_PAGE) + if (prevPage == kRootPage && nextPage != kRootPage) Throw("Directory chain: rev link broken"); // LCOV_EXCL_LINE // Older versions of the code would, in some cases, allow the last // page to be empty. Remove such pages: - if (nextPage == prevPage && nextPage != kROOT_PAGE) + if (nextPage == prevPage && nextPage != kRootPage) { auto last = peek(keylet::page(directory, nextPage)); @@ -232,8 +232,8 @@ ApplyView::emptyDirDelete(Keylet const& directory) // Update the first page's linked list and // mark it as updated. - node->setFieldU64(sfIndexNext, kROOT_PAGE); - node->setFieldU64(sfIndexPrevious, kROOT_PAGE); + node->setFieldU64(sfIndexNext, kRootPage); + node->setFieldU64(sfIndexPrevious, kRootPage); update(node); // And erase the empty last page: @@ -241,12 +241,12 @@ ApplyView::emptyDirDelete(Keylet const& directory) // Make sure our local values reflect the // updated information: - nextPage = kROOT_PAGE; - prevPage = kROOT_PAGE; + nextPage = kRootPage; + prevPage = kRootPage; } // If there are no other pages, erase the root: - if (nextPage == kROOT_PAGE && prevPage == kROOT_PAGE) + if (nextPage == kRootPage && prevPage == kRootPage) erase(node); return true; @@ -260,7 +260,7 @@ ApplyView::dirRemove(Keylet const& directory, std::uint64_t page, uint256 const& if (!node) return false; - std::uint64_t constexpr kROOT_PAGE = 0; + static constexpr std::uint64_t kRootPage = 0; { auto entries = node->getFieldV256(sfIndexes); @@ -289,7 +289,7 @@ ApplyView::dirRemove(Keylet const& directory, std::uint64_t page, uint256 const& // treated specially: it can never be deleted even if // it is empty, unless we plan on removing the entire // directory. - if (page == kROOT_PAGE) + if (page == kRootPage) { if (nextPage == page && prevPage != page) Throw("Directory chain: fwd link broken"); // LCOV_EXCL_LINE @@ -360,30 +360,30 @@ ApplyView::dirRemove(Keylet const& directory, std::uint64_t page, uint256 const& // Check whether the next page is the last page and, if // so, whether it's empty. If it is, delete it. - if (nextPage != kROOT_PAGE && next->getFieldU64(sfIndexNext) == kROOT_PAGE && + if (nextPage != kRootPage && next->getFieldU64(sfIndexNext) == kRootPage && next->getFieldV256(sfIndexes).empty()) { // Since next doesn't point to the root, it can't be pointing to prev. erase(next); // The previous page is now the last page: - prev->setFieldU64(sfIndexNext, kROOT_PAGE); + prev->setFieldU64(sfIndexNext, kRootPage); update(prev); // And the root points to the last page: - auto root = peek(keylet::page(directory, kROOT_PAGE)); + auto root = peek(keylet::page(directory, kRootPage)); if (!root) Throw("Directory chain: root link broken."); // LCOV_EXCL_LINE root->setFieldU64(sfIndexPrevious, prevPage); update(root); - nextPage = kROOT_PAGE; + nextPage = kRootPage; } // If we're not keeping the root, then check to see if // it's left empty. If so, delete it as well. - if (!keepRoot && nextPage == kROOT_PAGE && prevPage == kROOT_PAGE) + if (!keepRoot && nextPage == kRootPage && prevPage == kRootPage) { if (prev->getFieldV256(sfIndexes).empty()) erase(prev); diff --git a/src/libxrpl/ledger/BookDirs.cpp b/src/libxrpl/ledger/BookDirs.cpp index fbe876669e..099fec99e1 100644 --- a/src/libxrpl/ledger/BookDirs.cpp +++ b/src/libxrpl/ledger/BookDirs.cpp @@ -14,11 +14,11 @@ namespace xrpl { BookDirs::BookDirs(ReadView const& view, Book const& book) : view_(&view) , root_(keylet::page(getBookBase(book)).key) - , next_quality_(getQualityNext(root_)) - , key_(view_->succ(root_, next_quality_).value_or(beast::kZERO)) + , nextQuality_(getQualityNext(root_)) + , key_(view_->succ(root_, nextQuality_).value_or(beast::kZero)) { - XRPL_ASSERT(root_ != beast::kZERO, "xrpl::BookDirs::BookDirs : nonzero root"); - if (key_ != beast::kZERO) + XRPL_ASSERT(root_ != beast::kZero, "xrpl::BookDirs::BookDirs : nonzero root"); + if (key_ != beast::kZero) { if (!cdirFirst(*view_, key_, sle_, entry_, index_)) { @@ -33,9 +33,9 @@ auto BookDirs::begin() const -> BookDirs::const_iterator { auto it = BookDirs::const_iterator(*view_, root_, key_); - if (key_ != beast::kZERO) + if (key_ != beast::kZero) { - it.next_quality_ = next_quality_; + it.nextQuality_ = nextQuality_; it.sle_ = sle_; it.entry_ = entry_; it.index_ = index_; @@ -59,14 +59,14 @@ BookDirs::const_iterator::operator==(BookDirs::const_iterator const& other) cons view_ == other.view_ && root_ == other.root_, "xrpl::BookDirs::const_iterator::operator== : views and roots are " "matching"); - return entry_ == other.entry_ && cur_key_ == other.cur_key_ && index_ == other.index_; + return entry_ == other.entry_ && curKey_ == other.curKey_ && index_ == other.index_; } BookDirs::const_iterator::reference BookDirs::const_iterator::operator*() const { XRPL_ASSERT( - index_ != beast::kZERO, "xrpl::BookDirs::const_iterator::operator* : nonzero index"); + index_ != beast::kZero, "xrpl::BookDirs::const_iterator::operator* : nonzero index"); if (!cache_) cache_ = view_->read(keylet::offer(index_)); return *cache_; @@ -75,21 +75,21 @@ BookDirs::const_iterator::operator*() const BookDirs::const_iterator& BookDirs::const_iterator::operator++() { - using beast::kZERO; + using beast::kZero; - XRPL_ASSERT(index_ != kZERO, "xrpl::BookDirs::const_iterator::operator++ : nonzero index"); - if (!cdirNext(*view_, cur_key_, sle_, entry_, index_)) + XRPL_ASSERT(index_ != kZero, "xrpl::BookDirs::const_iterator::operator++ : nonzero index"); + if (!cdirNext(*view_, curKey_, sle_, entry_, index_)) { if (index_ == 0) - cur_key_ = view_->succ(++cur_key_, next_quality_).value_or(kZERO); + curKey_ = view_->succ(++curKey_, nextQuality_).value_or(kZero); - if (index_ != 0 || cur_key_ == kZERO) + if (index_ != 0 || curKey_ == kZero) { - cur_key_ = key_; + curKey_ = key_; entry_ = 0; - index_ = kZERO; + index_ = kZero; } - else if (!cdirFirst(*view_, cur_key_, sle_, entry_, index_)) + else if (!cdirFirst(*view_, curKey_, sle_, entry_, index_)) { // LCOV_EXCL_START UNREACHABLE("xrpl::BookDirs::const_iterator::operator++ : directory is empty"); @@ -105,7 +105,7 @@ BookDirs::const_iterator BookDirs::const_iterator::operator++(int) { XRPL_ASSERT( - index_ != beast::kZERO, "xrpl::BookDirs::const_iterator::operator++(int) : nonzero index"); + index_ != beast::kZero, "xrpl::BookDirs::const_iterator::operator++(int) : nonzero index"); const_iterator tmp(*this); ++(*this); return tmp; diff --git a/src/libxrpl/ledger/CachedView.cpp b/src/libxrpl/ledger/CachedView.cpp index 2dc28d67e0..8a6c266b8f 100644 --- a/src/libxrpl/ledger/CachedView.cpp +++ b/src/libxrpl/ledger/CachedView.cpp @@ -22,9 +22,9 @@ CachedViewImpl::exists(Keylet const& k) const std::shared_ptr CachedViewImpl::read(Keylet const& k) const { - static CountedObjects::Counter kHITS{"CachedView::hit"}; - static CountedObjects::Counter kHITSEXPIRED{"CachedView::hitExpired"}; - static CountedObjects::Counter kMISSES{"CachedView::miss"}; + static CountedObjects::Counter kHits{"CachedView::hit"}; + static CountedObjects::Counter kHitsExpired{"CachedView::hitExpired"}; + static CountedObjects::Counter kMisses{"CachedView::miss"}; bool cacheHit = false; bool baseRead = false; @@ -50,15 +50,15 @@ CachedViewImpl::read(Keylet const& k) const XRPL_ASSERT(sle || baseRead, "xrpl::CachedView::read : null SLE result from base"); if (cacheHit && baseRead) { - kHITSEXPIRED.increment(); + kHitsExpired.increment(); } else if (cacheHit) { - kHITS.increment(); + kHits.increment(); } else { - kMISSES.increment(); + kMisses.increment(); } if (!cacheHit) diff --git a/src/libxrpl/ledger/CanonicalTXSet.cpp b/src/libxrpl/ledger/CanonicalTXSet.cpp index bfa3d811e6..a06576342a 100644 --- a/src/libxrpl/ledger/CanonicalTXSet.cpp +++ b/src/libxrpl/ledger/CanonicalTXSet.cpp @@ -33,7 +33,7 @@ operator<(CanonicalTXSet::Key const& lhs, CanonicalTXSet::Key const& rhs) uint256 CanonicalTXSet::accountKey(AccountID const& account) { - uint256 ret = beast::kZERO; + uint256 ret = beast::kZero; memcpy(ret.begin(), account.begin(), account.size()); ret ^= salt_; return ret; @@ -68,7 +68,7 @@ CanonicalTXSet::popAcctTransaction(std::shared_ptr const& tx) uint256 const effectiveAccount{accountKey(tx->getAccountID(sfAccount))}; auto const seqProxy = tx->getSeqProxy(); - Key const after(effectiveAccount, seqProxy, beast::kZERO); + Key const after(effectiveAccount, seqProxy, beast::kZero); auto const itrNext{map_.lower_bound(after)}; if (itrNext != map_.end() && itrNext->first.getAccount() == effectiveAccount && (!itrNext->second->getSeqProxy().isSeq() || diff --git a/src/libxrpl/ledger/Dir.cpp b/src/libxrpl/ledger/Dir.cpp index a633257b27..63f41762a4 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; @@ -97,17 +98,17 @@ const_iterator::nextPage() if (next == 0) { page_.key = root_.key; - index_ = beast::kZERO; + index_ = beast::kZero; } else { 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()) { - index_ = beast::kZERO; + index_ = beast::kZero; } else { diff --git a/src/libxrpl/ledger/Ledger.cpp b/src/libxrpl/ledger/Ledger.cpp index 9857b49b65..fe7db9a158 100644 --- a/src/libxrpl/ledger/Ledger.cpp +++ b/src/libxrpl/ledger/Ledger.cpp @@ -46,7 +46,7 @@ namespace xrpl { -CreateGenesisT const kCREATE_GENESIS{}; +CreateGenesisT const kCreateGenesis{}; //------------------------------------------------------------------------------ @@ -159,8 +159,8 @@ Ledger::Ledger( , j_(beast::Journal(beast::Journal::getNullSink())) { header_.seq = 1; - header_.drops = kINITIAL_XRP; - header_.closeTimeResolution = kLEDGER_GENESIS_TIME_RESOLUTION; + header_.drops = kInitialXrp; + header_.closeTimeResolution = kLedgerGenesisTimeResolution; static auto const kID = calcAccountID(generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase")).first); @@ -196,7 +196,7 @@ Ledger::Ledger( sle->at(sfReserveBase) = *f; if (auto const f = fees.increment.dropsAs()) sle->at(sfReserveIncrement) = *f; - sle->at(sfReferenceFeeUnits) = kFEE_UNITS_DEPRECATED; + sle->at(sfReferenceFeeUnits) = kFeeUnitsDeprecated; } rawInsert(sle); } @@ -304,7 +304,7 @@ Ledger::Ledger( { header_.seq = ledgerSeq; header_.closeTime = closeTime; - header_.closeTimeResolution = kLEDGER_DEFAULT_TIME_RESOLUTION; + header_.closeTimeResolution = kLedgerDefaultTimeResolution; setup(); } @@ -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) @@ -339,7 +339,7 @@ Ledger::setAccepted( header_.closeTime = closeTime; header_.closeTimeResolution = closeResolution; - header_.closeFlags = correctCloseTime ? 0 : kS_LCF_NO_CONSENSUS_TIME; + header_.closeFlags = correctCloseTime ? 0 : kSLcfNoConsensusTime; setImmutable(); } @@ -404,7 +404,7 @@ Ledger::succ(uint256 const& key, std::optional const& last) const std::shared_ptr Ledger::read(Keylet const& k) const { - if (k.key == beast::kZERO) + if (k.key == beast::kZero) { // LCOV_EXCL_START UNREACHABLE("xrpl::Ledger::read : zero key"); @@ -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/OpenView.cpp b/src/libxrpl/ledger/OpenView.cpp index afe826d78d..40b411fcc0 100644 --- a/src/libxrpl/ledger/OpenView.cpp +++ b/src/libxrpl/ledger/OpenView.cpp @@ -78,9 +78,9 @@ public: OpenView::OpenView(OpenView const& rhs) : ReadView(rhs) , TxsRawView(rhs) - , monotonic_resource_{std::make_unique( - kINITIAL_BUFFER_SIZE)} - , txs_{rhs.txs_, monotonic_resource_.get()} + , monotonicResource_{std::make_unique( + kInitialBufferSize)} + , txs_{rhs.txs_, monotonicResource_.get()} , rules_{rhs.rules_} , header_{rhs.header_} , base_{rhs.base_} @@ -89,9 +89,9 @@ OpenView::OpenView(OpenView const& rhs) , open_{rhs.open_} {}; OpenView::OpenView(OpenLedgerT, ReadView const* base, Rules rules, std::shared_ptr hold) - : monotonic_resource_{ - std::make_unique(kINITIAL_BUFFER_SIZE)} - , txs_{monotonic_resource_.get()} + : monotonicResource_{ + std::make_unique(kInitialBufferSize)} + , txs_{monotonicResource_.get()} , rules_(std::move(rules)) , header_(base->header()) , base_(base) @@ -105,9 +105,9 @@ OpenView::OpenView(OpenLedgerT, ReadView const* base, Rules rules, std::shared_p } OpenView::OpenView(ReadView const* base, std::shared_ptr hold) - : monotonic_resource_{ - std::make_unique(kINITIAL_BUFFER_SIZE)} - , txs_{monotonic_resource_.get()} + : monotonicResource_{ + std::make_unique(kInitialBufferSize)} + , txs_{monotonicResource_.get()} , rules_(base->rules()) , header_(base->header()) , base_(base) diff --git a/src/libxrpl/ledger/PaymentSandbox.cpp b/src/libxrpl/ledger/PaymentSandbox.cpp index a730b247ba..97e3e53cbf 100644 --- a/src/libxrpl/ledger/PaymentSandbox.cpp +++ b/src/libxrpl/ledger/PaymentSandbox.cpp @@ -321,7 +321,7 @@ PaymentSandbox::balanceHookIOU( auto adjustedAmt = std::min({amount, lastBal - delta, minBal}); adjustedAmt.get().account = amount.getIssuer(); - if (isXRP(issuer) && adjustedAmt < beast::kZERO) + if (isXRP(issuer) && adjustedAmt < beast::kZero) { // A calculated negative XRP balance is not an error case. Consider a // payment snippet that credits a large XRP amount and then debits the diff --git a/src/libxrpl/ledger/View.cpp b/src/libxrpl/ledger/View.cpp index 9fb03a230c..c62d79dcac 100644 --- a/src/libxrpl/ledger/View.cpp +++ b/src/libxrpl/ledger/View.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -57,19 +58,45 @@ isVaultPseudoAccountFrozen( ReadView const& view, AccountID const& account, MPTIssue const& mptShare, - int depth) + std::uint8_t depth) { if (!view.rules().enabled(featureSingleAssetVault)) return false; - if (depth >= kMAX_ASSET_CHECK_DEPTH) - return true; // LCOV_EXCL_LINE + if (depth >= kMaxAssetCheckDepth) + { + // LCOV_EXCL_START + UNREACHABLE("xrpl::View::isVaultPseudoAccountFrozen : reached asset check depth"); + return true; + // LCOV_EXCL_STOP + } auto const mptIssuance = view.read(keylet::mptIssuance(mptShare.getMptID())); if (mptIssuance == nullptr) return false; // zero MPToken won't block deletion of MPTokenIssuance auto const issuer = mptIssuance->getAccountID(sfIssuer); + + // Post-fixCleanup3_2_0: vault shares carry sfReferenceHolding pointing + // to the vault pseudo's MPToken or RippleState for the underlying. + // Read it to derive the underlying asset and recurse, skipping the + // issuer-account-then-vault chain. Pre-amendment shares (no field) + // fall back to the chain lookup below. + if (mptIssuance->isFieldPresent(sfReferenceHolding)) + { + auto const sleHolding = + view.read(keylet::unchecked(mptIssuance->getFieldH256(sfReferenceHolding))); + if (!sleHolding) + { + // LCOV_EXCL_START + UNREACHABLE("xrpl::isVaultPseudoAccountFrozen : dangling sfReferenceHolding"); + return false; + // LCOV_EXCL_STOP + } + return isAnyFrozen( + view, {issuer, account}, assetOfHolding(*mptIssuance, *sleHolding), depth + 1); + } + auto const mptIssuer = view.read(keylet::account(issuer)); if (mptIssuer == nullptr) { @@ -350,7 +377,7 @@ withdrawToDestExceedsLimit( [&](Issue const& issue) -> TER { auto const& currency = issue.currency; auto const owed = creditBalance(view, to, issuer, currency); - if (owed <= beast::kZERO) + if (owed <= beast::kZero) { auto const limit = creditLimit(view, to, issuer, currency); if (-owed >= limit || amount > (limit + owed)) @@ -463,7 +490,7 @@ cleanupOnAccountDelete( // Delete all the entries in the account directory. std::shared_ptr sleDirNode{}; unsigned int uDirEntry{0}; - uint256 dirEntry{beast::kZERO}; + uint256 dirEntry{beast::kZero}; std::uint32_t deleted = 0; if (view.exists(ownerDirKeylet) && diff --git a/src/libxrpl/ledger/helpers/AMMHelpers.cpp b/src/libxrpl/ledger/helpers/AMMHelpers.cpp index 4cef02e056..f7aabc8ea5 100644 --- a/src/libxrpl/ledger/helpers/AMMHelpers.cpp +++ b/src/libxrpl/ledger/helpers/AMMHelpers.cpp @@ -205,7 +205,7 @@ adjustAmountsByLPTokens( auto const lpTokensActual = adjustLPTokens(lptAMMBalance, lpTokens, isDeposit); - if (lpTokensActual == beast::kZERO) + if (lpTokensActual == beast::kZero) { auto const amount2Opt = amount2 ? std::make_optional(STAmount{}) : std::nullopt; return std::make_tuple(STAmount{}, amount2Opt, lpTokensActual); @@ -644,7 +644,7 @@ deleteAMMTrustLines( if (nodeType == ltRIPPLE_STATE) { // Trustlines must have zero balance - if (sleItem->getFieldAmount(sfBalance) != beast::kZERO) + if (sleItem->getFieldAmount(sfBalance) != beast::kZero) { // LCOV_EXCL_START JLOG(j.error()) << "deleteAMMObjects: deleting trustline with " @@ -732,7 +732,7 @@ deleteAMMAccount(Sandbox& sb, Asset const& asset, Asset const& asset2, beast::Jo // LCOV_EXCL_STOP } - if (auto const ter = deleteAMMTrustLines(sb, ammAccountID, kMAX_DELETABLE_AMM_TRUST_LINES, j); + if (auto const ter = deleteAMMTrustLines(sb, ammAccountID, kMaxDeletableAmmTrustLines, j); !isTesSuccess(ter)) return ter; @@ -779,7 +779,7 @@ initializeFeeAuctionVote( STObject voteEntry = STObject::makeInnerObject(sfVoteEntry); if (tfee != 0) voteEntry.setFieldU16(sfTradingFee, tfee); - voteEntry.setFieldU32(sfVoteWeight, kVOTE_WEIGHT_SCALE_FACTOR); + voteEntry.setFieldU32(sfVoteWeight, kVoteWeightScaleFactor); voteEntry.setAccountID(sfAccount, account); voteSlots.pushBack(voteEntry); ammSle->setFieldArray(sfVoteSlots, voteSlots); @@ -797,7 +797,7 @@ initializeFeeAuctionVote( auto const expiration = std::chrono::duration_cast( view.header().parentCloseTime.time_since_epoch()) .count() + - kTOTAL_TIME_SLOT_SECS; + kTotalTimeSlotSecs; auctionSlot.setFieldU32(sfExpiration, expiration); auctionSlot.setFieldAmount(sfPrice, STAmount{lptAsset, 0}); // Set the fee @@ -809,7 +809,7 @@ initializeFeeAuctionVote( { ammSle->makeFieldAbsent(sfTradingFee); // LCOV_EXCL_LINE } - if (auto const dfee = tfee / kAUCTION_SLOT_DISCOUNTED_FEE_FRACTION) + if (auto const dfee = tfee / kAuctionSlotDiscountedFeeFraction) { auctionSlot.setFieldU16(sfDiscountedFee, dfee); } @@ -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..029cb5cd92 100644 --- a/src/libxrpl/ledger/helpers/AccountRootHelpers.cpp +++ b/src/libxrpl/ledger/helpers/AccountRootHelpers.cpp @@ -88,7 +88,7 @@ xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj, { auto const sle = view.read(keylet::account(id)); if (sle == nullptr) - return beast::kZERO; + return beast::kZero; // Return balance minus reserve std::uint32_t const ownerCount = @@ -121,7 +121,7 @@ transferRate(ReadView const& view, AccountID const& issuer) if (sle && sle->isFieldPresent(sfTransferRate)) return Rate{sle->getFieldU32(sfTransferRate)}; - return kPARITY_RATE; + return kParityRate; } void @@ -146,17 +146,17 @@ AccountID pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey) { // This number must not be changed without an amendment - constexpr std::uint16_t kMAX_ACCOUNT_ATTEMPTS = 256; - for (std::uint16_t i = 0; i < kMAX_ACCOUNT_ATTEMPTS; ++i) + static constexpr std::uint16_t kMaxAccountAttempts = 256; + for (std::uint16_t i = 0; i < kMaxAccountAttempts; ++i) { 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; } - return beast::kZERO; + return beast::kZero; } // Pseudo-account designator fields MUST be maintained by including the @@ -168,7 +168,7 @@ pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey) [[nodiscard]] std::vector const& getPseudoAccountFields() { - static std::vector const kPSEUDO_FIELDS = []() { + static std::vector const kPseudoFields = []() { auto const ar = LedgerFormats::getInstance().findByType(ltACCOUNT_ROOT); if (!ar) { @@ -183,12 +183,12 @@ getPseudoAccountFields() std::vector pseudoFields; for (auto const& field : soTemplate) { - if (field.sField().shouldMeta(SField::SMdPseudoAccount)) + if (field.sField().shouldMeta(SField::kSmdPseudoAccount)) pseudoFields.emplace_back(&field.sField()); } return pseudoFields; }(); - return kPSEUDO_FIELDS; + return kPseudoFields; } [[nodiscard]] bool @@ -221,7 +221,7 @@ createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const "xrpl::createPseudoAccount : valid owner field"); auto const accountId = pseudoAccountAddress(view, pseudoOwnerKey); - if (accountId == beast::kZERO) + if (accountId == beast::kZero) return Unexpected(tecDUPLICATE); // Create pseudo-account. diff --git a/src/libxrpl/ledger/helpers/CredentialHelpers.cpp b/src/libxrpl/ledger/helpers/CredentialHelpers.cpp index 22122216bc..838e72d364 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)) @@ -126,7 +131,7 @@ checkFields(STTx const& tx, beast::Journal j) return tesSUCCESS; auto const& credentials = tx.getFieldV256(sfCredentialIDs); - if (credentials.empty() || (credentials.size() > kMAX_CREDENTIALS_ARRAY_SIZE)) + if (credentials.empty() || (credentials.size() > kMaxCredentialsArraySize)) { JLOG(j.trace()) << "Malformed transaction: Credentials array size is invalid: " << credentials.size(); @@ -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; } @@ -283,7 +288,7 @@ checkArray(STArray const& credentials, unsigned maxSize, beast::Journal j) } auto const ct = credential[sfCredentialType]; - if (ct.empty() || (ct.size() > kMAX_CREDENTIAL_TYPE_LENGTH)) + if (ct.empty() || (ct.size() > kMaxCredentialTypeLength)) { JLOG(j.trace()) << "Malformed transaction: " "Invalid credentialType size: " @@ -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..9cda5905c9 100644 --- a/src/libxrpl/ledger/helpers/LendingHelpers.cpp +++ b/src/libxrpl/ledger/helpers/LendingHelpers.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -24,10 +25,42 @@ #include #include #include +#include #include namespace xrpl { +[[nodiscard]] TER +canApplyToBrokerCover( + ReadView const& view, + SLE::const_ref sleBroker, + Asset const& vaultAsset, + STAmount const& amount, + beast::Journal j, + std::string_view logPrefix) +{ + XRPL_ASSERT( + sleBroker && sleBroker->getType() == ltLOAN_BROKER, + "xrpl::canApplyToBrokerCover : valid LoanBroker sle"); + XRPL_ASSERT(vaultAsset == amount.asset(), "xrpl::canApplyToBrokerCover : valid asset"); + + if (!view.rules().enabled(fixCleanup3_2_0)) + return tesSUCCESS; + + if (amount == beast::kZero) + return tecPRECISION_LOSS; + + int const coverScale = scale(sleBroker->at(sfCoverAvailable), vaultAsset); + if (amount.isZeroAtScale(coverScale)) + { + JLOG(j.warn()) << logPrefix << ": amount " << amount.getFullText() + << " rounds to zero at cover scale " << coverScale; + return tecPRECISION_LOSS; + } + + return tesSUCCESS; +} + bool checkLendingProtocolDependencies(Rules const& rules, STTx const& tx) { @@ -48,15 +81,15 @@ LoanPaymentParts::operator+=(LoanPaymentParts const& other) { XRPL_ASSERT( - other.principalPaid >= beast::kZERO, + other.principalPaid >= beast::kZero, "xrpl::LoanPaymentParts::operator+= : other principal " "non-negative"); XRPL_ASSERT( - other.interestPaid >= beast::kZERO, + other.interestPaid >= beast::kZero, "xrpl::LoanPaymentParts::operator+= : other interest paid " "non-negative"); XRPL_ASSERT( - other.feePaid >= beast::kZERO, + other.feePaid >= beast::kZero, "xrpl::LoanPaymentParts::operator+= : other fee paid " "non-negative"); @@ -83,7 +116,7 @@ Number loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval) { // Need floating point math, since we're dividing by a large number - return tenthBipsOfValue(Number(paymentInterval), interestRate) / kSECONDS_IN_YEAR; + return tenthBipsOfValue(Number(paymentInterval), interestRate) / kSecondsInYear; } /* Checks if a value is already rounded to the specified scale. @@ -102,22 +135,86 @@ namespace detail { void LoanStateDeltas::nonNegative() { - if (principal < beast::kZERO) - principal = kNUM_ZERO; - if (interest < beast::kZERO) - interest = kNUM_ZERO; - if (managementFee < beast::kZERO) - managementFee = kNUM_ZERO; + if (principal < beast::kZero) + principal = kNumZero; + if (interest < beast::kZero) + interest = kNumZero; + if (managementFee < beast::kZero) + managementFee = kNumZero; } -/* 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 kNumZero; + + // 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 kNumZero; + + // 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,16 +223,31 @@ 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; + return kNumZero; // For zero interest, payment factor is simply 1/paymentsRemaining - if (periodicRate == beast::kZERO) + 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 +259,7 @@ computePaymentFactor(Number const& periodicRate, std::uint32_t paymentsRemaining */ Number loanPeriodicPayment( + Rules const& rules, Number const& principalOutstanding, Number const& periodicRate, std::uint32_t paymentsRemaining) @@ -155,10 +268,10 @@ loanPeriodicPayment( return 0; // Interest-free loans: equal principal payments - if (periodicRate == beast::kZERO) + 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,17 +281,18 @@ loanPeriodicPayment( */ Number loanPrincipalFromPeriodicPayment( + Rules const& rules, Number const& periodicPayment, Number const& periodicRate, std::uint32_t paymentsRemaining) { if (paymentsRemaining == 0) - return kNUM_ZERO; + return kNumZero; if (periodicRate == 0) return periodicPayment * paymentsRemaining; - return periodicPayment / computePaymentFactor(periodicRate, paymentsRemaining); + return periodicPayment / computePaymentFactor(rules, periodicRate, paymentsRemaining); } /* @@ -210,11 +324,11 @@ loanLatePaymentInterest( NetClock::time_point parentCloseTime, std::uint32_t nextPaymentDueDate) { - if (principalOutstanding == beast::kZERO) - return kNUM_ZERO; + if (principalOutstanding == beast::kZero) + return kNumZero; if (lateInterestRate == TenthBips32{0}) - return kNUM_ZERO; + return kNumZero; auto const now = parentCloseTime.time_since_epoch().count(); @@ -245,11 +359,11 @@ loanAccruedInterest( std::uint32_t prevPaymentDate, std::uint32_t paymentInterval) { - if (periodicRate == beast::kZERO) - return kNUM_ZERO; + if (periodicRate == beast::kZero) + return kNumZero; if (paymentInterval == 0) - return kNUM_ZERO; + return kNumZero; auto const lastPaymentDate = std::max(prevPaymentDate, startDate); auto const now = parentCloseTime.time_since_epoch().count(); @@ -257,7 +371,7 @@ loanAccruedInterest( // If the loan has been paid ahead, then "lastPaymentDate" is in the future, // and no interest has accrued. if (now <= lastPaymentDate) - return kNUM_ZERO; + return kNumZero; // Equation (4) from XLS-66 spec, Section A-2 Equation Glossary auto const secondsSinceLastPayment = now - lastPaymentDate; @@ -366,7 +480,7 @@ doPayment( XRPL_ASSERT_PARTS( // Use an explicit cast because the template parameter can be // ValueProxy or Number - static_cast(managementFeeOutstandingProxy) >= beast::kZERO, + static_cast(managementFeeOutstandingProxy) >= beast::kZero, "xrpl::detail::doPayment", "fee outstanding stays valid"); @@ -402,6 +516,7 @@ doPayment( */ Expected, TER> tryOverpayment( + Rules const& rules, Asset const& asset, std::int32_t loanScale, ExtendedPaymentComponents const& overpaymentComponents, @@ -414,7 +529,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 +547,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 +561,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 @@ -463,7 +582,7 @@ tryOverpayment( newTheoreticalState.principalOutstanding, loanScale, Number::RoundingMode::Upward), - kNUM_ZERO, + kNumZero, roundedOldState.principalOutstanding); auto const totalValueOutstanding = std::clamp( roundToAsset( @@ -471,11 +590,11 @@ tryOverpayment( principalOutstanding + newTheoreticalState.interestOutstanding(), loanScale, Number::RoundingMode::Upward), - kNUM_ZERO, + kNumZero, roundedOldState.valueOutstanding); auto const managementFeeOutstanding = std::clamp( roundToAsset(asset, newTheoreticalState.managementFeeDue, loanScale), - kNUM_ZERO, + kNumZero, roundedOldState.managementFeeDue); auto const roundedNewState = @@ -497,7 +616,7 @@ tryOverpayment( // small interest amounts, that may have already been paid // off. Check what's still outstanding. This should // guarantee that the interest checks pass. - roundedNewState.interestOutstanding() != beast::kZERO, + roundedNewState.interestOutstanding() != beast::kZero, paymentRemaining, newLoanProperties, j)) @@ -582,6 +701,7 @@ tryOverpayment( template Expected doOverpayment( + Rules const& rules, Asset const& asset, std::int32_t loanScale, ExtendedPaymentComponents const& overpaymentComponents, @@ -610,6 +730,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, @@ -648,9 +769,6 @@ doOverpayment( "xrpl::detail::doOverpayment", "principal change agrees"); - // I'm not 100% sure the following asserts are correct. If in doubt, and - // everything else works, remove any that cause trouble. - JLOG(j.debug()) << "valueChange: " << loanPaymentParts.valueChange << ", totalValue before: " << *totalValueOutstandingProxy << ", totalValue after: " << newRoundedLoanState.valueOutstanding @@ -662,11 +780,28 @@ doOverpayment( << overpaymentComponents.trackedPrincipalDelta - (totalValueOutstandingProxy - newRoundedLoanState.valueOutstanding); + // The valueChange returned by tryOverpayment satisfies + // valueChange = (newInterestDue - oldInterestDue) + untrackedInterest. + // Using the loan-state identity v = p + i + m and the adjacent + // `principal change agrees` assertion (dp = oldP - newP), this + // rearranges into three independently-computable terms: + // + // 1. TVO change beyond what principal repayment alone explains: + // newTVO - (oldTVO - dp) + // 2. Management fee released by re-amortization (positive when + // mfee decreased; zero when managementFeeRate == 0): + // oldMfee - newMfee + // 3. The overpayment's penalty interest part (= untrackedInterest + // for the overpayment path; see computeOverpaymentComponents): + // trackedInterestPart() + [[maybe_unused]] Number const tvoChange = newRoundedLoanState.valueOutstanding - + (totalValueOutstandingProxy - overpaymentComponents.trackedPrincipalDelta); + [[maybe_unused]] Number const managementFeeReleased = + managementFeeOutstandingProxy - newRoundedLoanState.managementFeeDue; + [[maybe_unused]] Number const interestPart = overpaymentComponents.trackedInterestPart(); + XRPL_ASSERT_PARTS( - loanPaymentParts.valueChange == - newRoundedLoanState.valueOutstanding - - (totalValueOutstandingProxy - overpaymentComponents.trackedPrincipalDelta) + - overpaymentComponents.trackedInterestPart(), + loanPaymentParts.valueChange == tvoChange + managementFeeReleased + interestPart, "xrpl::detail::doOverpayment", "interest paid agrees"); @@ -823,8 +958,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 +1064,7 @@ PaymentComponents::trackedInterestPart() const */ PaymentComponents computePaymentComponents( + Rules const& rules, Asset const& asset, std::int32_t scale, Number const& totalValueOutstanding, @@ -966,14 +1102,25 @@ 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. + // are stored. With fixCleanup3_2_0 enabled, principal is rounded upward + // and interest downward so that at coarse scale principal sticks at the + // floor (until the final payment clears it) while interest absorbs each + // periodic payment. Without the amendment the pre-existing round-to- + // nearest behavior is preserved (which can hit the "Partial principal + // payment" assertion on degenerate integer-scale loans). + bool const fixCleanup320Enabled = rules.enabled(fixCleanup3_2_0); + Number::RoundingMode const principalRounding = + fixCleanup320Enabled ? Number::RoundingMode::Upward : Number::getround(); + Number::RoundingMode const interestRounding = + fixCleanup320Enabled ? Number::RoundingMode::Downward : Number::getround(); LoanState const roundedTarget = LoanState{ .valueOutstanding = roundToAsset(asset, trueTarget.valueOutstanding, scale), - .principalOutstanding = roundToAsset(asset, trueTarget.principalOutstanding, scale), - .interestDue = roundToAsset(asset, trueTarget.interestDue, scale), + .principalOutstanding = + roundToAsset(asset, trueTarget.principalOutstanding, scale, principalRounding), + .interestDue = roundToAsset(asset, trueTarget.interestDue, scale, interestRounding), .managementFeeDue = roundToAsset(asset, trueTarget.managementFeeDue, scale)}; // Get the current actual loan state from the ledger values @@ -1006,7 +1153,7 @@ computePaymentComponents( // periodic payment after principal is paid deltas.interest = std::min( {deltas.interest, - std::max(kNUM_ZERO, roundedPeriodicPayment - deltas.principal), + std::max(kNumZero, roundedPeriodicPayment - deltas.principal), currentLedgerState.interestDue}); XRPL_ASSERT_PARTS( @@ -1026,14 +1173,14 @@ computePaymentComponents( // which indicates that we're not going to take the whole payment amount, // but if so, it must be small. auto takeFrom = [](Number& component, Number& excess) { - if (excess > beast::kZERO) + if (excess > beast::kZero) { auto part = std::min(component, excess); component -= part; excess -= part; } XRPL_ASSERT_PARTS( - excess >= beast::kZERO, + excess >= beast::kZero, "xrpl::detail::computePaymentComponents", "excess non-negative"); }; @@ -1051,7 +1198,7 @@ computePaymentComponents( // happen due to earlier caps, but handle it defensively. Number totalOverpayment = deltas.total() - currentLedgerState.valueOutstanding; - if (totalOverpayment > beast::kZERO) + if (totalOverpayment > beast::kZero) { // LCOV_EXCL_START UNREACHABLE( @@ -1069,7 +1216,7 @@ computePaymentComponents( "xrpl::detail::computePaymentComponents", "shortage is rounded"); - if (shortage < beast::kZERO) + if (shortage < beast::kZero) { // Deltas exceed payment amount - reduce them proportionally Number excess = -shortage; @@ -1081,7 +1228,7 @@ computePaymentComponents( // periodic payment (due to rounding or component caps). // shortage < 0 would mean we're trying to pay more than allowed (bug). XRPL_ASSERT_PARTS( - shortage >= beast::kZERO, + shortage >= beast::kZero, "xrpl::detail::computePaymentComponents", "no shortage or excess"); @@ -1092,33 +1239,33 @@ computePaymentComponents( "total value adds up"); XRPL_ASSERT_PARTS( - deltas.principal >= beast::kZERO && + deltas.principal >= beast::kZero && deltas.principal <= currentLedgerState.principalOutstanding, "xrpl::detail::computePaymentComponents", "valid principal result"); XRPL_ASSERT_PARTS( - deltas.interest >= beast::kZERO && deltas.interest <= currentLedgerState.interestDue, + deltas.interest >= beast::kZero && deltas.interest <= currentLedgerState.interestDue, "xrpl::detail::computePaymentComponents", "valid interest result"); XRPL_ASSERT_PARTS( - deltas.managementFee >= beast::kZERO && + deltas.managementFee >= beast::kZero && deltas.managementFee <= currentLedgerState.managementFeeDue, "xrpl::detail::computePaymentComponents", "valid fee result"); XRPL_ASSERT_PARTS( - deltas.principal + deltas.interest + deltas.managementFee > beast::kZERO, + deltas.principal + deltas.interest + deltas.managementFee > beast::kZero, "xrpl::detail::computePaymentComponents", "payment parts add to payment"); // Final safety clamp to ensure no value exceeds its outstanding balance return PaymentComponents{ .trackedValueDelta = - std::clamp(deltas.total(), kNUM_ZERO, currentLedgerState.valueOutstanding), + std::clamp(deltas.total(), kNumZero, currentLedgerState.valueOutstanding), .trackedPrincipalDelta = - std::clamp(deltas.principal, kNUM_ZERO, currentLedgerState.principalOutstanding), + std::clamp(deltas.principal, kNumZero, currentLedgerState.principalOutstanding), .trackedManagementFeeDelta = - std::clamp(deltas.managementFee, kNUM_ZERO, currentLedgerState.managementFeeDue), + std::clamp(deltas.managementFee, kNumZero, currentLedgerState.managementFeeDue), }; } @@ -1284,7 +1431,7 @@ checkLoanGuards( // avoids dividing by 0. auto const roundedPayment = roundPeriodicPayment(vaultAsset, properties.periodicPayment, properties.loanScale); - if (roundedPayment == beast::kZERO) + if (roundedPayment == beast::kZero) { JLOG(j.warn()) << "Loan Periodic payment (" << properties.periodicPayment << ") rounds to 0. "; @@ -1342,7 +1489,7 @@ computeFullPaymentInterest( "interest"); // Equation (28) from XLS-66 spec, Section A-2 Equation Glossary - auto const prepaymentPenalty = closeInterestRate == beast::kZERO + auto const prepaymentPenalty = closeInterestRate == beast::kZero ? Number{} : tenthBipsOfValue(theoreticalPrincipalOutstanding, closeInterestRate); @@ -1379,6 +1526,7 @@ computeFullPaymentInterest( */ LoanState computeTheoreticalLoanState( + Rules const& rules, Number const& periodicPayment, Number const& periodicRate, std::uint32_t const paymentRemaining, @@ -1396,8 +1544,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 +1636,7 @@ computeManagementFee( */ LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, TenthBips32 interestRate, @@ -1499,6 +1648,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 +1667,7 @@ computeLoanProperties( */ LoanProperties computeLoanProperties( + Rules const& rules, Asset const& asset, Number const& principalOutstanding, Number const& periodicRate, @@ -1525,7 +1676,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 +1724,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 +1884,7 @@ loanMakePayment( // payment is late or regular detail::ExtendedPaymentComponents periodic{ detail::computePaymentComponents( + view.rules(), asset, loanScale, totalValueOutstandingProxy, @@ -1809,7 +1961,7 @@ loanMakePayment( std::size_t numPayments = 0; while ((amount >= (totalPaid + periodic.totalDue)) && paymentRemainingProxy > 0 && - numPayments < kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION) + numPayments < kLoanMaximumPaymentsPerTransaction) { // Try to make more payments XRPL_ASSERT_PARTS( @@ -1841,6 +1993,7 @@ loanMakePayment( periodic = detail::ExtendedPaymentComponents{ detail::computePaymentComponents( + view.rules(), asset, loanScale, totalValueOutstandingProxy, @@ -1868,9 +2021,19 @@ 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 && - numPayments < kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION) + paymentRemainingProxy > 0 && totalPaid < roundedAmount && + numPayments < kLoanMaximumPaymentsPerTransaction) { TenthBips32 const overpaymentInterestRate{loan->at(sfOverpaymentInterestRate)}; TenthBips32 const overpaymentFeeRate{loan->at(sfOverpaymentFee)}; @@ -1878,50 +2041,62 @@ 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 overpaymentRaw = + std::min(roundedAmount - totalPaid, *totalValueOutstandingProxy); - detail::ExtendedPaymentComponents const overpaymentComponents = - detail::computeOverpaymentComponents( - asset, - loanScale, - overpayment, - overpaymentInterestRate, - overpaymentFeeRate, - managementFeeRate); + bool const fixEnabled = view.rules().enabled(fixCleanup3_2_0); + Number const overpayment = fixEnabled + ? roundToAsset(asset, overpaymentRaw, loanScale, Number::RoundingMode::Downward) + : overpaymentRaw; - // Don't process an overpayment if the whole amount (or more!) - // gets eaten by fees and interest. - if (overpaymentComponents.trackedPrincipalDelta > 0) + // Post-amendment, the rounded overpayment can be zero; pre-amendment + // it's always positive given the surrounding guards. + if (!fixEnabled || overpayment > 0) { - XRPL_ASSERT_PARTS( - overpaymentComponents.untrackedInterest >= beast::kZERO, - "xrpl::loanMakePayment", - "overpayment penalty did not reduce value of loan"); - // Can't just use `periodicPayment` here, because it might - // change - auto periodicPaymentProxy = loan->at(sfPeriodicPayment); - if (auto const overResult = detail::doOverpayment( + detail::ExtendedPaymentComponents const overpaymentComponents = + detail::computeOverpaymentComponents( asset, loanScale, - overpaymentComponents, - totalValueOutstandingProxy, - principalOutstandingProxy, - managementFeeOutstandingProxy, - periodicPaymentProxy, - periodicRate, - paymentRemainingProxy, - managementFeeRate, - j)) + overpayment, + overpaymentInterestRate, + overpaymentFeeRate, + managementFeeRate); + + // Don't process an overpayment if the whole amount (or more!) + // gets eaten by fees and interest. + if (overpaymentComponents.trackedPrincipalDelta > 0) { - totalParts += *overResult; - } - else if (overResult.error()) - { - // error() will be the TER returned if a payment is not - // made. It will only evaluate to true if it's unsuccessful. - // Otherwise, tesSUCCESS means nothing was done, so - // continue. - return Unexpected(overResult.error()); + XRPL_ASSERT_PARTS( + overpaymentComponents.untrackedInterest >= beast::kZero, + "xrpl::loanMakePayment", + "overpayment penalty did not reduce value of loan"); + // Can't just use `periodicPayment` here, because it might + // change + auto periodicPaymentProxy = loan->at(sfPeriodicPayment); + if (auto const overResult = detail::doOverpayment( + view.rules(), + asset, + loanScale, + overpaymentComponents, + totalValueOutstandingProxy, + principalOutstandingProxy, + managementFeeOutstandingProxy, + periodicPaymentProxy, + periodicRate, + paymentRemainingProxy, + managementFeeRate, + j)) + { + totalParts += *overResult; + } + else if (overResult.error()) + { + // error() will be the TER returned if a payment is not + // made. It will only evaluate to true if it's unsuccessful. + // Otherwise, tesSUCCESS means nothing was done, so + // continue. + return Unexpected(overResult.error()); + } } } } @@ -1930,17 +2105,17 @@ loanMakePayment( // intermediate steps were rounded. XRPL_ASSERT( isRounded(asset, totalParts.principalPaid, loanScale) && - totalParts.principalPaid >= beast::kZERO, + totalParts.principalPaid >= beast::kZero, "xrpl::loanMakePayment : total principal paid is valid"); XRPL_ASSERT( isRounded(asset, totalParts.interestPaid, loanScale) && - totalParts.interestPaid >= beast::kZERO, + totalParts.interestPaid >= beast::kZero, "xrpl::loanMakePayment : total interest paid is valid"); XRPL_ASSERT( isRounded(asset, totalParts.valueChange, loanScale), "xrpl::loanMakePayment : loan value change is valid"); XRPL_ASSERT( - isRounded(asset, totalParts.feePaid, loanScale) && totalParts.feePaid >= beast::kZERO, + isRounded(asset, totalParts.feePaid, loanScale) && totalParts.feePaid >= beast::kZero, "xrpl::loanMakePayment : fee paid is valid"); return totalParts; } diff --git a/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp b/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp index 75fe61b34b..387116d820 100644 --- a/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp +++ b/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp @@ -25,7 +25,6 @@ #include #include #include -#include #include #include @@ -55,7 +54,11 @@ isIndividualFrozen(ReadView const& view, AccountID const& account, MPTIssue cons } bool -isFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth) +isFrozen( + ReadView const& view, + AccountID const& account, + MPTIssue const& mptIssue, + std::uint8_t depth) { return isGlobalFrozen(view, mptIssue) || isIndividualFrozen(view, account, mptIssue) || isVaultPseudoAccountFrozen(view, account, mptIssue, depth); @@ -66,7 +69,7 @@ isAnyFrozen( ReadView const& view, std::initializer_list const& accounts, MPTIssue const& mptIssue, - int depth) + std::uint8_t depth) { if (isGlobalFrozen(view, mptIssue)) return true; @@ -96,11 +99,11 @@ transferRate(ReadView const& view, MPTID const& issuanceID) sle && sle->isFieldPresent(sfTransferFee)) { auto const fee = sle->getFieldU16(sfTransferFee); - XRPL_ASSERT(fee <= kMAX_TRANSFER_FEE, "xrpl::transferRate : fee is too large"); + XRPL_ASSERT(fee <= kMaxTransferFee, "xrpl::transferRate : fee is too large"); return Rate{1'000'000'000u + (10'000 * fee)}; } - return kPARITY_RATE; + return kParityRate; } [[nodiscard]] TER @@ -169,7 +172,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 @@ -194,7 +197,7 @@ authorizeMPToken( // items. This is similar to the reserve requirements of trust lines. std::uint32_t const uOwnerCount = sleAcct->getFieldU32(sfOwnerCount); XRPAmount const reserveCreate( - (uOwnerCount < 2) ? XRPAmount(beast::kZERO) + (uOwnerCount < 2) ? XRPAmount(beast::kZero) : view.fees().accountReserve(uOwnerCount + 1)); if (priorBalance < reserveCreate) @@ -284,7 +287,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( @@ -303,7 +306,7 @@ requireAuth( MPTIssue const& mptIssue, AccountID const& account, AuthType authType, - int depth) + std::uint8_t depth) { auto const mptID = keylet::mptIssuance(mptIssue.getMptID()); auto const sleIssuance = view.read(mptID); @@ -320,8 +323,13 @@ requireAuth( if (featureSAVEnabled) { - if (depth >= kMAX_ASSET_CHECK_DEPTH) - return tecINTERNAL; // LCOV_EXCL_LINE + if (depth >= kMaxAssetCheckDepth) + { + // LCOV_EXCL_START + UNREACHABLE("xrpl::MPTokenHelpers::requireAuth : reached asset check depth"); + return tecINTERNAL; + // LCOV_EXCL_STOP + } // requireAuth is recursive if the issuer is a vault pseudo-account auto const sleIssuer = view.read(keylet::account(mptIssuer)); @@ -358,7 +366,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); @@ -374,10 +382,11 @@ requireAuth( // belong to someone who is explicitly authorized e.g. a vault owner. } - if (featureSAVEnabled) + bool const featureMPTV2Enabled = view.rules().enabled(featureMPTokensV2); + if (featureSAVEnabled || featureMPTV2Enabled) { - // Implicitly authorize Vault and LoanBroker pseudo-accounts - if (isPseudoAccount(view, account, {&sfVaultID, &sfLoanBrokerID})) + // Implicitly authorize Vault, LoanBroker, and AMM pseudo-accounts + if (isPseudoAccount(view, account, {&sfVaultID, &sfLoanBrokerID, &sfAMMID})) return tesSUCCESS; } @@ -489,28 +498,88 @@ enforceMPTokenAuthorization( // LCOV_EXCL_STOP } +[[nodiscard]] Asset +assetOfHolding(SLE const& sleShareIssuance, SLE const& sleHolding) +{ + XRPL_ASSERT_PARTS( + sleHolding.getType() == ltRIPPLE_STATE || sleHolding.getType() == ltMPTOKEN, + "xrpl::assetOfHolding", + "unexpected holding type"); + XRPL_ASSERT_PARTS( + sleShareIssuance.getType() == ltMPTOKEN_ISSUANCE, + "xrpl::assetOfHolding", + "not SLE MPTokenIssuance"); + + if (sleHolding.getType() == ltMPTOKEN) + return MPTIssue{sleHolding.getFieldH192(sfMPTokenIssuanceID)}; + + auto const vaultPseudo = sleShareIssuance.at(sfIssuer); + auto const lowLimit = sleHolding.getFieldAmount(sfLowLimit); + auto const highLimit = sleHolding.getFieldAmount(sfHighLimit); + auto const& iouIssuer = + (lowLimit.getIssuer() != vaultPseudo) ? lowLimit.getIssuer() : highLimit.getIssuer(); + return Issue{lowLimit.get().currency, iouIssuer}; +} + TER canTransfer( ReadView const& view, MPTIssue const& mptIssue, AccountID const& from, - AccountID const& to) + AccountID const& to, + WaiveMPTCanTransfer waive, + std::uint8_t depth) { auto const mptID = keylet::mptIssuance(mptIssue.getMptID()); auto const sleIssuance = view.read(mptID); if (!sleIssuance) return tecOBJECT_NOT_FOUND; + auto const issuer = (*sleIssuance)[sfIssuer]; + if (waive == WaiveMPTCanTransfer::Yes || from == issuer || to == issuer) + return tesSUCCESS; + if (!sleIssuance->isFlag(lsfMPTCanTransfer)) + return TER{tecNO_AUTH}; + + // Post-fixCleanup3_2_0: vault shares carry sfReferenceHolding pointing + // to the vault pseudo's MPToken or RippleState for the underlying asset. + // Third-party transfers inherit the underlying's transferability. + // Issuer-involving transfers and waived callers returned tesSUCCESS above. + // + // The recursive call always passes WaiveMPTCanTransfer::No so that + // a waived outer caller does not transitively unlock the underlying. + if (view.rules().enabled(fixCleanup3_2_0) && sleIssuance->isFieldPresent(sfReferenceHolding)) { - if (from != (*sleIssuance)[sfIssuer] && to != (*sleIssuance)[sfIssuer]) - return TER{tecNO_AUTH}; + // Defensive depth bound on the inheritance recursion. Unreachable + // in practice (vault-of-vault-shares is forbidden at VaultCreate). + if (depth >= kMaxAssetCheckDepth) + { + // LCOV_EXCL_START + UNREACHABLE("xrpl::MPTokenHelpers::canTransfer : reached asset check depth"); + return tecINTERNAL; + // LCOV_EXCL_STOP + } + + auto const sleHolding = + view.read(keylet::unchecked(sleIssuance->getFieldH256(sfReferenceHolding))); + if (!sleHolding) + return tefINTERNAL; // LCOV_EXCL_LINE + + return canTransfer( + view, + assetOfHolding(*sleIssuance, *sleHolding), + from, + to, + WaiveMPTCanTransfer::No, + depth + 1); } + return tesSUCCESS; } TER -canTrade(ReadView const& view, Asset const& asset) +canTrade(ReadView const& view, Asset const& asset, std::uint8_t depth) { return asset.visit( [&](Issue const&) -> TER { return tesSUCCESS; }, @@ -520,10 +589,51 @@ canTrade(ReadView const& view, Asset const& asset) return tecOBJECT_NOT_FOUND; if (!sleIssuance->isFlag(lsfMPTCanTrade)) return tecNO_PERMISSION; + + // Post-fixCleanup3_2_0: vault shares inherit the underlying + // asset's tradability. A share whose underlying has been + // removed from trading cannot itself be placed on the DEX. + if (view.rules().enabled(fixCleanup3_2_0) && + sleIssuance->isFieldPresent(sfReferenceHolding)) + { + // Defensive depth bound on the inheritance recursion. + // Unreachable in practice (vault-of-vault-shares + // forbidden at VaultCreate). + if (depth >= kMaxAssetCheckDepth) + { + // LCOV_EXCL_START + UNREACHABLE("xrpl::MPTokenHelpers::canTrade : reached asset check depth"); + return tecINTERNAL; + // LCOV_EXCL_STOP + } + auto const sleHolding = + view.read(keylet::unchecked(sleIssuance->getFieldH256(sfReferenceHolding))); + if (!sleHolding) + return tefINTERNAL; // LCOV_EXCL_LINE + + return canTrade(view, assetOfHolding(*sleIssuance, *sleHolding), depth + 1); + } + return tesSUCCESS; }); } +TER +canMPTTradeAndTransfer( + ReadView const& view, + Asset const& asset, + AccountID const& from, + AccountID const& to) +{ + if (!asset.holds()) + return tesSUCCESS; + + if (auto const ter = canTrade(view, asset); !isTesSuccess(ter)) + return ter; + + return canTransfer(view, asset, from, to); +} + TER lockEscrowMPT(ApplyView& view, AccountID const& sender, STAmount const& amount, beast::Journal j) { @@ -839,7 +949,7 @@ checkCreateMPT( std::int64_t maxMPTAmount(SLE const& sleIssuance) { - return sleIssuance[~sfMaximumAmount].value_or(kMAX_MP_TOKEN_AMOUNT); + return sleIssuance[~sfMaximumAmount].value_or(kMaxMpTokenAmount); } std::int64_t @@ -891,65 +1001,4 @@ issuerSelfDebitHookMPT(ApplyView& view, MPTIssue const& issue, std::uint64_t amo view.issuerSelfDebitHookMPT(issue, amount, available); } -static TER -checkMPTAllowed(ReadView const& view, TxType txType, Asset const& asset, AccountID const& accountID) -{ - if (!asset.holds()) - return tesSUCCESS; - - auto const& issuanceID = asset.get().getMptID(); - auto const validTx = txType == ttAMM_CREATE || txType == ttAMM_DEPOSIT || - txType == ttAMM_WITHDRAW || txType == ttOFFER_CREATE || txType == ttCHECK_CREATE || - txType == ttCHECK_CASH || txType == ttPAYMENT; - XRPL_ASSERT(validTx, "xrpl::checkMPTAllowed : all MPT tx or DEX"); - if (!validTx) - return tefINTERNAL; // LCOV_EXCL_LINE - - auto const& issuer = asset.getIssuer(); - if (!view.exists(keylet::account(issuer))) - return tecNO_ISSUER; // LCOV_EXCL_LINE - - auto const issuanceKey = keylet::mptIssuance(issuanceID); - auto const issuanceSle = view.read(issuanceKey); - if (!issuanceSle) - return tecOBJECT_NOT_FOUND; // LCOV_EXCL_LINE - - auto const flags = issuanceSle->getFlags(); - - if ((flags & lsfMPTLocked) != 0u) - return tecLOCKED; // LCOV_EXCL_LINE - // Offer crossing and Payment - if ((flags & lsfMPTCanTrade) == 0) - return tecNO_PERMISSION; - - if (accountID != issuer) - { - if ((flags & lsfMPTCanTransfer) == 0) - return tecNO_PERMISSION; - - auto const mptSle = view.read(keylet::mptoken(issuanceKey.key, accountID)); - // Allow to succeed since some tx create MPToken if it doesn't exist. - // Tx's have their own check for missing MPToken. - if (!mptSle) - return tesSUCCESS; - - if (mptSle->isFlag(lsfMPTLocked)) - return tecLOCKED; - } - - return tesSUCCESS; -} - -TER -checkMPTTxAllowed( - ReadView const& view, - TxType txType, - Asset const& asset, - AccountID const& accountID) -{ - // use isDEXAllowed for payment/offer crossing - XRPL_ASSERT(txType != ttPAYMENT, "xrpl::checkMPTTxAllowed : not payment"); - return checkMPTAllowed(view, txType, asset, accountID); -} - } // namespace xrpl diff --git a/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp b/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp index eb69ec93d0..bb784278ba 100644 --- a/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp +++ b/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp @@ -98,7 +98,7 @@ getPageForToken( STArray narr = cp->getFieldArray(sfNFTokens); // The right page still has space: we're good. - if (narr.size() != kDIR_MAX_TOKENS_PER_PAGE) + if (narr.size() != kDirMaxTokensPerPage) return cp; // We need to split the page in two: the first half of the items in this @@ -115,13 +115,13 @@ getPageForToken( // any additional equivalent NFTs maximum room for expansion. // Round up the boundary until there's a non-equivalent entry. uint256 const cmp = - narr[(kDIR_MAX_TOKENS_PER_PAGE / 2) - 1].getFieldH256(sfNFTokenID) & nft::kPAGE_MASK; + narr[(kDirMaxTokensPerPage / 2) - 1].getFieldH256(sfNFTokenID) & nft::kPageMask; // Note that the calls to find_if_not() and (later) find_if() // rely on the fact that narr is kept in sorted order. auto splitIter = std::find_if_not( - narr.begin() + (kDIR_MAX_TOKENS_PER_PAGE / 2), narr.end(), [&cmp](STObject const& obj) { - return (obj.getFieldH256(sfNFTokenID) & nft::kPAGE_MASK) == cmp; + narr.begin() + (kDirMaxTokensPerPage / 2), narr.end(), [&cmp](STObject const& obj) { + return (obj.getFieldH256(sfNFTokenID) & nft::kPageMask) == cmp; }); // If we get all the way from the middle to the end with only @@ -130,7 +130,7 @@ getPageForToken( if (splitIter == narr.end()) { splitIter = std::ranges::find_if(narr, [&cmp](STObject const& obj) { - return (obj.getFieldH256(sfNFTokenID) & nft::kPAGE_MASK) == cmp; + return (obj.getFieldH256(sfNFTokenID) & nft::kPageMask) == cmp; }); } @@ -143,7 +143,7 @@ getPageForToken( // equivalent tokens. This requires special handling. if (splitIter == narr.begin()) { - auto const relation{(id & nft::kPAGE_MASK) <=> cmp}; + auto const relation{(id & nft::kPageMask) <=> cmp}; if (relation == 0) { // If the passed in id belongs exactly on this (full) page @@ -178,8 +178,8 @@ getPageForToken( // less than the low 96-bits of the enclosing page's index. In order to // accommodate that requirement we use an index one higher than the // largest NFT in the page. - uint256 const tokenIDForNewPage = narr.size() == kDIR_MAX_TOKENS_PER_PAGE - ? narr[kDIR_MAX_TOKENS_PER_PAGE - 1].getFieldH256(sfNFTokenID).next() + uint256 const tokenIDForNewPage = narr.size() == kDirMaxTokensPerPage + ? narr[kDirMaxTokensPerPage - 1].getFieldH256(sfNFTokenID).next() : carr[0].getFieldH256(sfNFTokenID); auto np = std::make_shared(keylet::nftpage(base, tokenIDForNewPage)); @@ -217,7 +217,7 @@ compareTokens(uint256 const& a, uint256 const& b) // 96-bits are identical we still need a fully deterministic sort. // So we sort on the low 96-bits first. If those are equal we sort on // the whole thing. - if (auto const lowBitsCmp{(a & nft::kPAGE_MASK) <=> (b & nft::kPAGE_MASK)}; lowBitsCmp != 0) + if (auto const lowBitsCmp{(a & nft::kPageMask) <=> (b & nft::kPageMask)}; lowBitsCmp != 0) return lowBitsCmp < 0; return a < b; @@ -314,7 +314,7 @@ mergePages(ApplyView& view, std::shared_ptr const& p1, std::shared_ptr // this it would mean that one of them can be deleted as a result of // the merge. - if (p1arr.size() + p2arr.size() > kDIR_MAX_TOKENS_PER_PAGE) + if (p1arr.size() + p2arr.size() > kDirMaxTokensPerPage) return false; STArray x(p1arr.size() + p2arr.size()); @@ -445,7 +445,7 @@ removeToken( // 3. Fix up the owner count. // 4. Erase the previous page. if (view.rules().enabled(fixNFTokenPageLinks) && - ((curr->key() & nft::kPAGE_MASK) == kPAGE_MASK)) + ((curr->key() & nft::kPageMask) == kPageMask)) { // Copy all relevant information from prev to curr. curr->peekFieldArray(sfNFTokens) = prev->peekFieldArray(sfNFTokens); @@ -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)) @@ -788,7 +788,7 @@ tokenOfferCreatePreflight( if (!isXRP(amount)) { - if ((nftFlags & nft::kFLAG_ONLY_XRP) != 0) + if ((nftFlags & nft::kFlagOnlyXrp) != 0) return temBAD_AMOUNT; if (!amount) @@ -833,7 +833,7 @@ tokenOfferCreatePreclaim( std::optional const& owner, std::uint32_t txFlags) { - if (((nftFlags & nft::kFLAG_CREATE_TRUST_LINES) == 0) && !amount.native() && (xferFee != 0u)) + if (((nftFlags & nft::kFlagCreateTrustLines) == 0) && !amount.native() && (xferFee != 0u)) { if (!view.exists(keylet::account(nftIssuer))) return tecNO_ISSUER; @@ -855,7 +855,7 @@ tokenOfferCreatePreclaim( return tecFROZEN; } - if (nftIssuer != acctID && ((nftFlags & nft::kFLAG_TRANSFERABLE) == 0)) + if (nftIssuer != acctID && ((nftFlags & nft::kFlagTransferable) == 0)) { auto const root = view.read(keylet::account(nftIssuer)); XRPL_ASSERT(root, "xrpl::nft::tokenOfferCreatePreclaim : non-null account"); @@ -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..5aaa417ad9 100644 --- a/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp +++ b/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp @@ -183,15 +183,15 @@ trustCreate( bool const bSrcHigh, AccountID const& uSrcAccountID, AccountID const& uDstAccountID, - uint256 const& uIndex, // --> ripple state entry - SLE::ref sleAccount, // --> the account being set. - bool const bAuth, // --> authorize account. - bool const bNoRipple, // --> others cannot ripple through - bool const bFreeze, // --> funds cannot leave - bool bDeepFreeze, // --> can neither receive nor send funds - STAmount const& saBalance, // --> balance of account being set. + uint256 const& uIndex, // ripple state entry + SLE::ref sleAccount, // the account being set. + bool const bAuth, // authorize account. + bool const bNoRipple, // others cannot ripple through + bool const bFreeze, // funds cannot leave + bool bDeepFreeze, // can neither receive nor send funds + STAmount const& saBalance, // balance of account being set. // Issuer should be noAccount() - STAmount const& saLimit, // --> limit for account being set. + STAmount const& saLimit, // limit for account being set. // Issuer should be the account being set. std::uint32_t uQualityIn, std::uint32_t uQualityOut, @@ -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 + if (before > beast::kZero // Sender balance was positive. - && after <= beast::kZERO + && 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}; } @@ -698,7 +699,7 @@ removeEmptyHolding( auto const line = view.peek(keylet::line(accountID, issue)); if (!line) return accountIsIssuer ? (TER)tesSUCCESS : (TER)tecOBJECT_NOT_FOUND; - if (!accountIsIssuer && line->at(sfBalance)->iou() != beast::kZERO) + if (!accountIsIssuer && line->at(sfBalance)->iou() != beast::kZero) return tecHAS_OBLIGATIONS; // Adjust the owner count(s) @@ -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 000f459ef6..7191456868 100644 --- a/src/libxrpl/ledger/helpers/TokenHelpers.cpp +++ b/src/libxrpl/ledger/helpers/TokenHelpers.cpp @@ -28,6 +28,7 @@ #include #include +#include #include #include @@ -55,6 +56,14 @@ isGlobalFrozen(ReadView const& view, Asset const& asset) [&](MPTIssue const& issue) { return isGlobalFrozen(view, issue); }); } +TER +checkGlobalFrozen(ReadView const& view, Asset const& asset) +{ + if (isGlobalFrozen(view, asset)) + return asset.holds() ? tecLOCKED : tecFROZEN; + return tesSUCCESS; +} + bool isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset) { @@ -62,8 +71,16 @@ isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& [&](auto const& issue) { return isIndividualFrozen(view, account, issue); }, asset.value()); } +TER +checkIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset) +{ + if (isIndividualFrozen(view, account, asset)) + return asset.holds() ? tecLOCKED : tecFROZEN; + return tesSUCCESS; +} + bool -isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth) +isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, std::uint8_t depth) { return std::visit( [&](auto const& issue) { return isFrozen(view, account, issue, depth); }, asset.value()); @@ -107,7 +124,7 @@ isAnyFrozen( ReadView const& view, std::initializer_list const& accounts, Asset const& asset, - int depth) + std::uint8_t depth) { return asset.visit( [&](Issue const& issue) { return isAnyFrozen(view, accounts, issue); }, @@ -115,7 +132,11 @@ isAnyFrozen( } bool -isDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth) +isDeepFrozen( + ReadView const& view, + AccountID const& account, + MPTIssue const& mptIssue, + std::uint8_t depth) { // Unlike IOUs, frozen / locked MPTs are not allowed to send or receive // funds, so checking "deep frozen" is the same as checking "frozen". @@ -123,7 +144,7 @@ isDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mpt } bool -isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth) +isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, std::uint8_t depth) { return std::visit( [&](auto const& issue) { return isDeepFrozen(view, account, issue, depth); }, @@ -257,7 +278,7 @@ accountHolds( { // If the account is the issuer, then their limit is effectively // infinite - return STAmount{Issue{currency, issuer}, STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET}; + return STAmount{Issue{currency, issuer}, STAmount::kMaxValue, STAmount::kMaxOffset}; } // IOU: Return balance on trust line modulo freeze @@ -500,13 +521,19 @@ requireAuth(ReadView const& view, Asset const& asset, AccountID const& account, } TER -canTransfer(ReadView const& view, Asset const& asset, AccountID const& from, AccountID const& to) +canTransfer( + ReadView const& view, + Asset const& asset, + AccountID const& from, + AccountID const& to, + WaiveMPTCanTransfer waive, + std::uint8_t depth) { - return std::visit( - [&](TIss const& issue) -> TER { - return canTransfer(view, issue, from, to); + return asset.visit( + [&](MPTIssue const& issue) -> TER { + return canTransfer(view, issue, from, to, waive, depth); }, - asset.value()); + [&](Issue const& issue) -> TER { return canTransfer(view, issue, from, to); }); } //------------------------------------------------------------------------------ @@ -569,39 +596,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 + if (saBefore > beast::kZero // Sender balance was positive. - && saBalance <= beast::kZERO + && 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. } @@ -618,7 +647,7 @@ directSendNoFeeIOU( view, sleRippleState, bSenderHigh ? uReceiverID : uSenderID, - !bSenderHigh ? uReceiverID : uSenderID, + bSenderHigh ? uSenderID : uReceiverID, j); } @@ -640,7 +669,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, @@ -795,7 +824,7 @@ accountSendIOU( { if (view.rules().enabled(fixAMMv1_1)) { - if (saAmount < beast::kZERO || saAmount.holds()) + if (saAmount < beast::kZero || saAmount.holds()) { return tecINTERNAL; // LCOV_EXCL_LINE } @@ -804,7 +833,7 @@ accountSendIOU( { // LCOV_EXCL_START XRPL_ASSERT( - saAmount >= beast::kZERO && !saAmount.holds(), + saAmount >= beast::kZero && !saAmount.holds(), "xrpl::accountSendIOU : minimum amount and not MPT"); // LCOV_EXCL_STOP } @@ -833,9 +862,9 @@ accountSendIOU( TER terResult(tesSUCCESS); SLE::pointer const sender = - uSenderID != beast::kZERO ? view.peek(keylet::account(uSenderID)) : SLE::pointer(); + uSenderID != beast::kZero ? view.peek(keylet::account(uSenderID)) : SLE::pointer(); SLE::pointer const receiver = - uReceiverID != beast::kZERO ? view.peek(keylet::account(uReceiverID)) : SLE::pointer(); + uReceiverID != beast::kZero ? view.peek(keylet::account(uReceiverID)) : SLE::pointer(); if (auto stream = j.trace()) { @@ -929,7 +958,7 @@ accountSendMultiIOU( */ SLE::pointer const sender = - senderID != beast::kZERO ? view.peek(keylet::account(senderID)) : SLE::pointer(); + senderID != beast::kZero ? view.peek(keylet::account(senderID)) : SLE::pointer(); if (auto stream = j.trace()) { @@ -949,7 +978,7 @@ accountSendMultiIOU( auto const& receiverID = r.first; STAmount const amount{issue, r.second}; - if (amount < beast::kZERO) + if (amount < beast::kZero) { return tecINTERNAL; // LCOV_EXCL_LINE } @@ -961,7 +990,7 @@ accountSendMultiIOU( continue; SLE::pointer const receiver = - receiverID != beast::kZERO ? view.peek(keylet::account(receiverID)) : SLE::pointer(); + receiverID != beast::kZero ? view.peek(keylet::account(receiverID)) : SLE::pointer(); if (auto stream = j.trace()) { @@ -1093,6 +1122,13 @@ directSendNoFeeMPT( auto const mptokenID = keylet::mptoken(mptID.key, uReceiverID); if (auto sle = view.peek(mptokenID)) { + if (view.rules().enabled(featureMPTokensV2)) + { + if ((*sle)[sfMPTAmount] > (std::numeric_limits::max() - amt)) + { + return tecINTERNAL; // LCOV_EXCL_LINE + } + } view.creditHookMPT(uSenderID, uReceiverID, saAmount, (*sle)[sfMPTAmount], available); (*sle)[sfMPTAmount] += amt; view.update(sle); @@ -1189,9 +1225,9 @@ directSendNoLimitMultiMPT( // Use uint64_t, not STAmount, to keep MaximumAmount comparisons in exact // integer arithmetic. STAmount implicitly converts to Number, whose // small-scale mantissa (~16 digits) can lose precision for values near - // maxMPTokenAmount (19 digits). + // kMaxMpTokenAmount (19 digits). std::uint64_t totalSendAmount{0}; - std::uint64_t const maximumAmount = sle->at(~sfMaximumAmount).value_or(kMAX_MP_TOKEN_AMOUNT); + std::uint64_t const maximumAmount = sle->at(~sfMaximumAmount).value_or(kMaxMpTokenAmount); std::uint64_t const outstandingAmount = sle->getFieldU64(sfOutstandingAmount); // actual accumulates the total cost to the sender (includes transfer @@ -1205,7 +1241,7 @@ directSendNoLimitMultiMPT( { STAmount const amount{mptIssue, amt}; - if (amount < beast::kZERO) + if (amount < beast::kZero) return tecINTERNAL; // LCOV_EXCL_LINE if (!amount || senderID == receiverID) @@ -1216,15 +1252,15 @@ directSendNoLimitMultiMPT( if (senderID == issuer) { XRPL_ASSERT_PARTS( - takeFromSender == beast::kZERO, + takeFromSender == beast::kZero, "xrpl::directSendNoLimitMultiMPT", "sender == issuer, takeFromSender == zero"); 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. @@ -1242,7 +1278,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. @@ -1298,7 +1334,7 @@ accountSendMPT( AllowMPTOverflow allowOverflow) { XRPL_ASSERT( - saAmount >= beast::kZERO && saAmount.holds(), + saAmount >= beast::kZero && saAmount.holds(), "xrpl::accountSendMPT : minimum amount and MPT"); /* If we aren't sending anything or if the sender is the same as the @@ -1400,8 +1436,8 @@ transferXRP( STAmount const& amount, beast::Journal j) { - XRPL_ASSERT(from != beast::kZERO, "xrpl::transferXRP : nonzero from account"); - XRPL_ASSERT(to != beast::kZERO, "xrpl::transferXRP : nonzero to account"); + XRPL_ASSERT(from != beast::kZero, "xrpl::transferXRP : nonzero from account"); + XRPL_ASSERT(to != beast::kZero, "xrpl::transferXRP : nonzero to account"); XRPL_ASSERT(from != to, "xrpl::transferXRP : sender is not receiver"); XRPL_ASSERT(amount.native(), "xrpl::transferXRP : amount is XRP"); diff --git a/src/libxrpl/net/HTTPClient.cpp b/src/libxrpl/net/HTTPClient.cpp index afdb264916..78ee5eb577 100644 --- a/src/libxrpl/net/HTTPClient.cpp +++ b/src/libxrpl/net/HTTPClient.cpp @@ -69,7 +69,7 @@ public: ioContext, gHttpClientSslContext->context()) // NOLINT(bugprone-unchecked-optional-access) , resolver_(ioContext) - , header_(kMAX_CLIENT_HEADER_BYTES) + , header_(kMaxClientHeaderBytes) , port_(port) , maxResponseSize_(maxResponseSize) , deadline_(ioContext) @@ -372,14 +372,14 @@ public: {std::istreambuf_iterator(&header_)}, std::istreambuf_iterator()}; JLOG(j_.trace()) << "Header: \"" << strHeader << "\""; - static boost::regex const kRE_STATUS{"\\`HTTP/1\\S+ (\\d{3}) .*\\'"}; // HTTP/1.1 200 OK - static boost::regex const kRE_SIZE{ + static boost::regex const kReStatus{"\\`HTTP/1\\S+ (\\d{3}) .*\\'"}; // HTTP/1.1 200 OK + static boost::regex const kReSize{ "\\`.*\\r\\nContent-Length:\\s+([0-9]+).*\\'", boost::regex::icase}; - static boost::regex const kRE_BODY{"\\`.*\\r\\n\\r\\n(.*)\\'"}; + static boost::regex const kReBody{"\\`.*\\r\\n\\r\\n(.*)\\'"}; boost::smatch smMatch; // Match status code. - if (!boost::regex_match(strHeader, smMatch, kRE_STATUS)) + if (!boost::regex_match(strHeader, smMatch, kReStatus)) { // XXX Use our own error code. JLOG(j_.trace()) << "No status code"; @@ -391,11 +391,11 @@ public: status_ = beast::lexicalCastThrow(std::string(smMatch[1])); - if (boost::regex_match(strHeader, smMatch, kRE_BODY)) // we got some body + if (boost::regex_match(strHeader, smMatch, kReBody)) // we got some body body_ = smMatch[1]; std::size_t const responseSize = [&] { - if (boost::regex_match(strHeader, smMatch, kRE_SIZE)) + if (boost::regex_match(strHeader, smMatch, kReSize)) return beast::lexicalCast(std::string(smMatch[1]), maxResponseSize_); return maxResponseSize_; }(); diff --git a/src/libxrpl/nodestore/BatchWriter.cpp b/src/libxrpl/nodestore/BatchWriter.cpp index 28184bf174..e0a1fbf20c 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(kBatchWritePreallocationSize); } 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() >= kBatchWritePreallocationSize) writeCondition_.wait(sl); writeSet_.push_back(object); @@ -65,7 +65,7 @@ BatchWriter::writeBatch() { std::vector> set; - set.reserve(BatchWritePreallocationSize); + set.reserve(kBatchWritePreallocationSize); { std::scoped_lock const sl(writeMutex_); diff --git a/src/libxrpl/nodestore/Database.cpp b/src/libxrpl/nodestore/Database.cpp index 84941d98aa..b584aca268 100644 --- a/src/libxrpl/nodestore/Database.cpp +++ b/src/libxrpl/nodestore/Database.cpp @@ -38,7 +38,7 @@ Database::Database( beast::Journal journal) : j_(journal) , scheduler_(scheduler) - , earliestLedgerSeq_(get(config, "earliest_seq", kXRP_LEDGER_EARLIEST_SEQ)) + , earliestLedgerSeq_(get(config, "earliest_seq", kXrpLedgerEarliestSeq)) , requestBundle_(get(config, "rq_bundle", 4)) , readThreads_(std::max(1, readThreads)) { @@ -192,7 +192,7 @@ void Database::importInternal(Backend& dstBackend, Database& srcDB) { Batch batch; - batch.reserve(BatchWritePreallocationSize); + batch.reserve(kBatchWritePreallocationSize); 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() >= kBatchWritePreallocationSize) storeBatch(); }); diff --git a/src/libxrpl/nodestore/DatabaseNodeImp.cpp b/src/libxrpl/nodestore/DatabaseNodeImp.cpp index ef84862de6..a51c34079b 100644 --- a/src/libxrpl/nodestore/DatabaseNodeImp.cpp +++ b/src/libxrpl/nodestore/DatabaseNodeImp.cpp @@ -4,21 +4,16 @@ #include #include #include -#include -#include #include #include #include #include -#include -#include #include #include #include #include #include -#include namespace xrpl::NodeStore { @@ -81,33 +76,4 @@ DatabaseNodeImp::fetchNodeObject( return nodeObject; } -std::vector> -DatabaseNodeImp::fetchBatch(std::vector const& hashes) -{ - using namespace std::chrono; - auto const before = steady_clock::now(); - - // Get the node objects that match the hashes from the backend. To protect - // against the backends returning fewer or more results than expected, the - // container is resized to the number of hashes. - auto results = backend_->fetchBatch(hashes).first; - XRPL_ASSERT( - results.size() == hashes.size() || results.empty(), - "number of output objects either matches number of input hashes or is empty"); - results.resize(hashes.size()); - for (size_t i = 0; i < results.size(); ++i) - { - if (!results[i]) - { - JLOG(j_.error()) << "fetchBatch - " - << "record not found in db. hash = " << strHex(hashes[i]); - } - } - - auto fetchDurationUs = - std::chrono::duration_cast(steady_clock::now() - before).count(); - updateFetchMetrics(hashes.size(), 0, fetchDurationUs); - return results; -} - } // namespace xrpl::NodeStore diff --git a/src/libxrpl/nodestore/ManagerImp.cpp b/src/libxrpl/nodestore/ManagerImp.cpp index 0cfda7d86a..5cefbfd357 100644 --- a/src/libxrpl/nodestore/ManagerImp.cpp +++ b/src/libxrpl/nodestore/ManagerImp.cpp @@ -26,8 +26,8 @@ namespace xrpl::NodeStore { ManagerImp& ManagerImp::instance() { - static ManagerImp k_; - return k_; + static ManagerImp kInst; + return kInst; } void @@ -77,7 +77,7 @@ ManagerImp::makeBackend( } return factory->createInstance( - NodeObject::kKEY_BYTES, parameters, burstSize, scheduler, journal); + NodeObject::kKeyBytes, parameters, burstSize, scheduler, journal); } std::unique_ptr diff --git a/src/libxrpl/nodestore/backend/MemoryFactory.cpp b/src/libxrpl/nodestore/backend/MemoryFactory.cpp index 13c82696cb..5bdf8e65b5 100644 --- a/src/libxrpl/nodestore/backend/MemoryFactory.cpp +++ b/src/libxrpl/nodestore/backend/MemoryFactory.cpp @@ -22,7 +22,6 @@ #include #include #include -#include namespace xrpl::NodeStore { @@ -74,8 +73,8 @@ MemoryFactory* gMemoryFactory = nullptr; void registerMemoryFactory(Manager& manager) { - static MemoryFactory kINSTANCE{manager}; - gMemoryFactory = &kINSTANCE; + static MemoryFactory kInstance{manager}; + gMemoryFactory = &kInstance; } //------------------------------------------------------------------------------ @@ -146,28 +145,6 @@ public: return Status::Ok; } - std::pair>, Status> - fetchBatch(std::vector const& hashes) override - { - std::vector> results; - results.reserve(hashes.size()); - for (auto const& h : hashes) - { - std::shared_ptr nObj; - Status const status = fetch(h, &nObj); - if (status != Status::Ok) - { - results.push_back({}); - } - else - { - results.push_back(nObj); - } - } - - return {results, Status::Ok}; - } - void store(std::shared_ptr const& object) override { diff --git a/src/libxrpl/nodestore/backend/NuDBFactory.cpp b/src/libxrpl/nodestore/backend/NuDBFactory.cpp index db9dbcbec1..abf09e871d 100644 --- a/src/libxrpl/nodestore/backend/NuDBFactory.cpp +++ b/src/libxrpl/nodestore/backend/NuDBFactory.cpp @@ -42,7 +42,6 @@ #include #include #include -#include namespace xrpl::NodeStore { @@ -53,7 +52,7 @@ public: // NuDB database. We used it to identify shard databases before that code // was removed. For now, its only use is a sanity check that the database // was created by xrpld. - static constexpr std::uint64_t kAPPNUM = 1; + static constexpr std::uint64_t kAppNum = 1; beast::Journal const j; size_t const keyBytes; @@ -161,7 +160,7 @@ public: if (ec) Throw(ec); - if (db.appnum() != kAPPNUM) + if (db.appnum() != kAppNum) Throw("nodestore: unknown appnum"); db.set_burst(burstSize); } @@ -175,7 +174,7 @@ public: void open(bool createIfMissing) override { - open(createIfMissing, kAPPNUM, nudb::make_uid(), nudb::make_salt()); + open(createIfMissing, kAppNum, nudb::make_uid(), nudb::make_salt()); } void @@ -232,28 +231,6 @@ public: return status; } - std::pair>, Status> - fetchBatch(std::vector const& hashes) override - { - std::vector> results; - results.reserve(hashes.size()); - for (auto const& h : hashes) - { - std::shared_ptr nObj; - Status const status = fetch(h, &nObj); - if (status != Status::Ok) - { - results.push_back({}); - } - else - { - results.push_back(nObj); - } - } - - return {results, Status::Ok}; - } - void doInsert(std::shared_ptr const& no) { @@ -460,7 +437,7 @@ public: void registerNuDBFactory(Manager& manager) { - static NuDBFactory const kINSTANCE{manager}; + static NuDBFactory const kInstance{manager}; } } // namespace xrpl::NodeStore diff --git a/src/libxrpl/nodestore/backend/NullFactory.cpp b/src/libxrpl/nodestore/backend/NullFactory.cpp index 38f35e91ff..36b8139984 100644 --- a/src/libxrpl/nodestore/backend/NullFactory.cpp +++ b/src/libxrpl/nodestore/backend/NullFactory.cpp @@ -12,8 +12,6 @@ #include #include #include -#include -#include namespace xrpl::NodeStore { @@ -52,12 +50,6 @@ public: return Status::NotFound; } - std::pair>, Status> - fetchBatch(std::vector const& hashes) override - { - return {}; - } - void store(std::shared_ptr const& object) override { @@ -128,7 +120,7 @@ public: void registerNullFactory(Manager& manager) { - static NullFactory const kINSTANCE{manager}; + static NullFactory const kInstance{manager}; } } // namespace xrpl::NodeStore diff --git a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp index 7f5ac6b14e..d2c193888c 100644 --- a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp +++ b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp @@ -29,8 +29,6 @@ #include #include #include -#include -#include #if XRPL_ROCKSDB_AVAILABLE #include @@ -330,28 +328,6 @@ public: return status; } - std::pair>, Status> - fetchBatch(std::vector const& hashes) override - { - std::vector> results; - results.reserve(hashes.size()); - for (auto const& h : hashes) - { - std::shared_ptr nObj; - Status const status = fetch(h, &nObj); - if (status != Status::Ok) - { - results.push_back({}); - } - else - { - results.push_back(nObj); - } - } - - return {results, Status::Ok}; - } - void store(std::shared_ptr const& object) override { @@ -486,7 +462,7 @@ public: void registerRocksDBFactory(Manager& manager) { - static RocksDBFactory const kINSTANCE{manager}; + static RocksDBFactory const kInstance{manager}; } } // namespace xrpl::NodeStore diff --git a/src/libxrpl/protocol/AMMCore.cpp b/src/libxrpl/protocol/AMMCore.cpp index 71d4b83857..e58ab29257 100644 --- a/src/libxrpl/protocol/AMMCore.cpp +++ b/src/libxrpl/protocol/AMMCore.cpp @@ -29,7 +29,7 @@ Currency ammLPTCurrency(Asset const& asset1, Asset const& asset2) { // AMM LPToken is 0x03 plus 19 bytes of the hash - std::int32_t constexpr kAMM_CURRENCY_CODE = 0x03; + static constexpr std::int32_t kAmmCurrencyCode = 0x03; auto const& [minA, maxA] = std::minmax(asset1, asset2); uint256 const hash = std::visit( [](auto&& issue1, auto&& issue2) { @@ -44,7 +44,7 @@ ammLPTCurrency(Asset const& asset1, Asset const& asset2) minA.value(), maxA.value()); Currency currency; - *currency.begin() = kAMM_CURRENCY_CODE; + *currency.begin() = kAmmCurrencyCode; std::copy(hash.begin(), hash.begin() + currency.size() - 1, currency.begin() + 1); return currency; } @@ -60,7 +60,7 @@ invalidAMMAsset(Asset const& asset, std::optional> const { auto const err = asset.visit( [](MPTIssue const& issue) -> std::optional { - if (issue.getIssuer() == beast::kZERO) + if (issue.getIssuer() == beast::kZero) return temBAD_MPT; return std::nullopt; }, @@ -101,7 +101,7 @@ invalidAMMAmount( { if (auto const res = invalidAMMAsset(amount.asset(), pair)) return res; - if (amount < beast::kZERO || (!validZero && amount == beast::kZERO)) + if (amount < beast::kZero || (!validZero && amount == beast::kZero)) return temBAD_AMOUNT; return tesSUCCESS; } @@ -112,14 +112,13 @@ ammAuctionTimeSlot(std::uint64_t current, STObject const& auctionSlot) // It should be impossible for expiration to be < TOTAL_TIME_SLOT_SECS, // but check just to be safe auto const expiration = auctionSlot[sfExpiration]; - XRPL_ASSERT( - expiration >= kTOTAL_TIME_SLOT_SECS, "xrpl::ammAuctionTimeSlot : minimum expiration"); - if (expiration >= kTOTAL_TIME_SLOT_SECS) + XRPL_ASSERT(expiration >= kTotalTimeSlotSecs, "xrpl::ammAuctionTimeSlot : minimum expiration"); + if (expiration >= kTotalTimeSlotSecs) { - if (auto const start = expiration - kTOTAL_TIME_SLOT_SECS; current >= start) + if (auto const start = expiration - kTotalTimeSlotSecs; current >= start) { - if (auto const diff = current - start; diff < kTOTAL_TIME_SLOT_SECS) - return diff / kAUCTION_SLOT_INTERVAL_DURATION; + if (auto const diff = current - start; diff < kTotalTimeSlotSecs) + return diff / kAuctionSlotIntervalDuration; } } return std::nullopt; diff --git a/src/libxrpl/protocol/AccountID.cpp b/src/libxrpl/protocol/AccountID.cpp index 6639835b41..6050144a8e 100644 --- a/src/libxrpl/protocol/AccountID.cpp +++ b/src/libxrpl/protocol/AccountID.cpp @@ -103,9 +103,9 @@ std::optional parseBase58(std::string const& s) { auto const result = decodeBase58Token(s, TokenType::AccountID); - if (result.size() != AccountID::kBYTES) + if (result.size() != AccountID::kBytes) return std::nullopt; - return AccountID{result}; + return AccountID::fromRaw(result); } //------------------------------------------------------------------------------ @@ -146,25 +146,25 @@ parseBase58(std::string const& s) AccountID calcAccountID(PublicKey const& pk) { - static_assert(AccountID::kBYTES == sizeof(RipeshaHasher::result_type)); + static_assert(AccountID::kBytes == sizeof(RipeshaHasher::result_type)); RipeshaHasher rsh; rsh(pk.data(), pk.size()); - return AccountID{static_cast(rsh)}; + return AccountID::fromRaw(static_cast(rsh)); } AccountID const& xrpAccount() { - static AccountID const kACCOUNT(beast::kZERO); - return kACCOUNT; + static AccountID const kAccount(beast::kZero); + return kAccount; } AccountID const& noAccount() { - static AccountID const kACCOUNT(1); - return kACCOUNT; + static AccountID const kAccount(1); + return kAccount; } bool diff --git a/src/libxrpl/protocol/BuildInfo.cpp b/src/libxrpl/protocol/BuildInfo.cpp index 7ea934fe3a..5613a9366e 100644 --- a/src/libxrpl/protocol/BuildInfo.cpp +++ b/src/libxrpl/protocol/BuildInfo.cpp @@ -23,7 +23,7 @@ namespace { //------------------------------------------------------------------------------ // clang-format off // NOLINTNEXTLINE(readability-identifier-naming) -char const* const versionString = "3.2.0-b0" +char const* const versionString = "3.2.0-b7" // clang-format on ; @@ -67,7 +67,7 @@ buildVersionString() std::string const& getVersionString() { - static std::string const kVALUE = [] { + static std::string const kValue = [] { std::string const s = buildVersionString(); beast::SemanticVersion v; @@ -75,23 +75,23 @@ getVersionString() logicError(s + ": Bad server version string"); return s; }(); - return kVALUE; + return kValue; } std::string const& getFullVersionString() { - static std::string const kVALUE = systemName() + "-" + getVersionString(); - return kVALUE; + static std::string const kValue = systemName() + "-" + getVersionString(); + return kValue; } -static constexpr std::uint64_t kIMPLEMENTATION_VERSION_IDENTIFIER = 0x183B'0000'0000'0000LLU; -static constexpr std::uint64_t kIMPLEMENTATION_VERSION_IDENTIFIER_MASK = 0xFFFF'0000'0000'0000LLU; +static constexpr std::uint64_t kImplementationVersionIdentifier = 0x183B'0000'0000'0000LLU; +static constexpr std::uint64_t kImplementationVersionIdentifierMask = 0xFFFF'0000'0000'0000LLU; std::uint64_t encodeSoftwareVersion(std::string_view versionStr) { - std::uint64_t c = kIMPLEMENTATION_VERSION_IDENTIFIER; + std::uint64_t c = kImplementationVersionIdentifier; beast::SemanticVersion v; @@ -155,15 +155,14 @@ encodeSoftwareVersion(std::string_view versionStr) std::uint64_t getEncodedVersion() { - static std::uint64_t const kCOOKIE = {encodeSoftwareVersion(getVersionString())}; - return kCOOKIE; + static std::uint64_t const kCookie = {encodeSoftwareVersion(getVersionString())}; + return kCookie; } bool isXrpldVersion(std::uint64_t version) { - return (version & kIMPLEMENTATION_VERSION_IDENTIFIER_MASK) == - kIMPLEMENTATION_VERSION_IDENTIFIER; + return (version & kImplementationVersionIdentifierMask) == kImplementationVersionIdentifier; } bool diff --git a/src/libxrpl/protocol/ErrorCodes.cpp b/src/libxrpl/protocol/ErrorCodes.cpp index a51bb9b56d..87761ce13e 100644 --- a/src/libxrpl/protocol/ErrorCodes.cpp +++ b/src/libxrpl/protocol/ErrorCodes.cpp @@ -30,7 +30,7 @@ namespace detail { // status code. // clang-format off -constexpr static ErrorInfo kUNORDERED_ERROR_INFOS[]{ +static constexpr ErrorInfo kUnorderedErrorInfos[]{ {RpcActMalformed, "actMalformed", "Account malformed."}, {RpcActNotFound, "actNotFound", "Account not found."}, {RpcAlreadyMultisig, "alreadyMultisig", "Already multisigned."}, @@ -153,9 +153,9 @@ sortErrorInfos(ErrorInfo const (&unordered)[N]) -> std::array return ret; } -constexpr auto kSORTED_ERROR_INFOS{sortErrorInfos(kUNORDERED_ERROR_INFOS)}; +constexpr auto kSortedErrorInfos{sortErrorInfos(kUnorderedErrorInfos)}; -constexpr ErrorInfo kUNKNOWN_ERROR; +constexpr ErrorInfo kUnknownError; } // namespace detail @@ -183,8 +183,8 @@ ErrorInfo const& getErrorInfo(ErrorCodeI code) { if (code <= RpcSuccess || code > RpcLast) - return detail::kUNKNOWN_ERROR; - return detail::kSORTED_ERROR_INFOS[code - 1]; + return detail::kUnknownError; + return detail::kSortedErrorInfos[code - 1]; } json::Value @@ -212,7 +212,7 @@ containsError(json::Value const& json) int errorCodeHttpStatus(ErrorCodeI code) { - return getErrorInfo(code).http_status; + return getErrorInfo(code).httpStatus; } } // namespace RPC diff --git a/src/libxrpl/protocol/Feature.cpp b/src/libxrpl/protocol/Feature.cpp index 3862b52e27..059abe2996 100644 --- a/src/libxrpl/protocol/Feature.cpp +++ b/src/libxrpl/protocol/Feature.cpp @@ -202,7 +202,7 @@ public: FeatureCollections::FeatureCollections() { - features_.reserve(xrpl::detail::kNUM_FEATURES); + features_.reserve(xrpl::detail::kNumFeatures); } std::optional @@ -233,7 +233,7 @@ FeatureCollections::registerFeature(std::string const& name, Supported support, Feature const* i = getByName(name); if (i == nullptr) { - check(features_.size() < detail::kNUM_FEATURES, "More features defined than allocated."); + check(features_.size() < detail::kNumFeatures, "More features defined than allocated."); auto const f = sha512Half(Slice(name.data(), name.size())); @@ -446,6 +446,6 @@ enforceValidFeatureName(auto fn) -> char const* // are initialized from top to bottom. // // Use initialization of one final static variable to set featureCollections::readOnly_. -[[maybe_unused]] static bool const kREAD_ONLY_SET = gFeatureCollections.registrationIsDone(); +[[maybe_unused]] static bool const kReadOnlySet = gFeatureCollections.registrationIsDone(); } // namespace xrpl diff --git a/src/libxrpl/protocol/IOUAmount.cpp b/src/libxrpl/protocol/IOUAmount.cpp index 2969b91ebc..e733c9541e 100644 --- a/src/libxrpl/protocol/IOUAmount.cpp +++ b/src/libxrpl/protocol/IOUAmount.cpp @@ -19,11 +19,11 @@ namespace xrpl { /* The range for the mantissa when normalized */ // log(2^63,10) ~ 18.96 // -static std::int64_t constexpr kMIN_MANTISSA = STAmount::kMIN_VALUE; -static std::int64_t constexpr kMAX_MANTISSA = STAmount::kMAX_VALUE; +static constexpr std::int64_t kMinMantissa = STAmount::kMinValue; +static constexpr std::int64_t kMaxMantissa = STAmount::kMaxValue; /* The range for the exponent when normalized */ -static int constexpr kMIN_EXPONENT = STAmount::kMIN_OFFSET; -static int constexpr kMAX_EXPONENT = STAmount::kMAX_OFFSET; +static constexpr int kMinExponent = STAmount::kMinOffset; +static constexpr int kMaxExponent = STAmount::kMaxOffset; IOUAmount IOUAmount::fromNumber(Number const& number) @@ -32,14 +32,14 @@ IOUAmount::fromNumber(Number const& number) // to normalize, which calls fromNumber IOUAmount result{}; std::tie(result.mantissa_, result.exponent_) = - number.normalizeToRange(kMIN_MANTISSA, kMAX_MANTISSA); + number.normalizeToRange(kMinMantissa, kMaxMantissa); return result; } IOUAmount IOUAmount::minPositiveAmount() { - return IOUAmount(kMIN_MANTISSA, kMIN_EXPONENT); + return IOUAmount(kMinMantissa, kMinExponent); } void @@ -47,47 +47,77 @@ IOUAmount::normalize() { if (mantissa_ == 0) { - *this = beast::kZERO; + *this = beast::kZero; return; } Number const v{mantissa_, exponent_}; *this = fromNumber(v); - if (exponent_ > kMAX_EXPONENT) + if (exponent_ > kMaxExponent) { Throw("value overflow"); } - if (exponent_ < kMIN_EXPONENT) + if (exponent_ < kMinExponent) { - *this = beast::kZERO; + *this = beast::kZero; } } IOUAmount::IOUAmount(Number const& other) : IOUAmount(fromNumber(other)) { - if (exponent_ > kMAX_EXPONENT) + if (exponent_ > kMaxExponent) { Throw("value overflow"); } - if (exponent_ < kMIN_EXPONENT) + if (exponent_ < kMinExponent) { - *this = beast::kZERO; + *this = beast::kZero; } } IOUAmount& IOUAmount::operator+=(IOUAmount const& other) { - if (other == beast::kZERO) + if (other == beast::kZero) return *this; - if (*this == beast::kZERO) + if (*this == beast::kZero) { *this = other; return *this; } - *this = IOUAmount{Number{*this} + Number{other}}; + if (getSTNumberSwitchover()) + { + *this = IOUAmount{Number{*this} + Number{other}}; + return *this; + } + auto m = other.mantissa_; + auto e = other.exponent_; + + while (exponent_ < e) + { + mantissa_ /= 10; + ++exponent_; + } + + while (e < exponent_) + { + m /= 10; + ++e; + } + + // This addition cannot overflow an std::int64_t but we may throw from + // normalize if the result isn't representable. + mantissa_ += m; + + if (mantissa_ >= -10 && mantissa_ <= 10) + { + *this = beast::kZero; + return *this; + } + + normalize(); return *this; } @@ -108,7 +138,7 @@ mulRatio(IOUAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundU // A vector with the value 10^index for indexes from 0 to 29 // The largest intermediate value we expect is 2^96, which // is less than 10^29 - static auto const kPOWER_TABLE = [] { + static auto const kPowerTable = [] { std::vector result; result.reserve(30); // 2^96 is largest intermediate result size uint128_t cur(1); @@ -122,11 +152,11 @@ mulRatio(IOUAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundU // Return floor(log10(v)) // Note: Returns -1 for v == 0 - static auto kLOG10_FLOOR = [](uint128_t const& v) { + static auto kLoG10Floor = [](uint128_t const& v) { // Find the index of the first element >= the requested element, the // index is the log of the element in the log table. - auto const l = std::ranges::lower_bound(kPOWER_TABLE, v); - int index = std::distance(kPOWER_TABLE.begin(), l); + auto const l = std::ranges::lower_bound(kPowerTable, v); + int index = std::distance(kPowerTable.begin(), l); // If we're not equal, subtract to get the floor if (*l != v) --index; @@ -134,14 +164,14 @@ mulRatio(IOUAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundU }; // Return ceil(log10(v)) - static auto kLOG10_CEIL = [](uint128_t const& v) { + static auto kLoG10Ceil = [](uint128_t const& v) { // Find the index of the first element >= the requested element, the // index is the log of the element in the log table. - auto const l = std::ranges::lower_bound(kPOWER_TABLE, v); - return int(std::distance(kPOWER_TABLE.begin(), l)); + auto const l = std::ranges::lower_bound(kPowerTable, v); + return int(std::distance(kPowerTable.begin(), l)); }; - static auto const kFL64 = kLOG10_FLOOR(std::numeric_limits::max()); + static auto const kFl64 = kLoG10Floor(std::numeric_limits::max()); bool const neg = amt.mantissa() < 0; uint128_t const den128(den); @@ -162,12 +192,12 @@ mulRatio(IOUAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundU // and (rem/den128) is as large as possible. Scale by multiplying low // and rem by 10 and subtracting one from the exponent. We could do this // with a loop, but it's more efficient to use logarithms. - auto const roomToGrow = kFL64 - kLOG10_CEIL(low); + auto const roomToGrow = kFl64 - kLoG10Ceil(low); if (roomToGrow > 0) { exponent -= roomToGrow; - low *= kPOWER_TABLE[roomToGrow]; - rem *= kPOWER_TABLE[roomToGrow]; + low *= kPowerTable[roomToGrow]; + rem *= kPowerTable[roomToGrow]; } auto const addRem = rem / den128; low += addRem; @@ -179,14 +209,14 @@ mulRatio(IOUAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundU // and adding one to the exponent until the low will fit in the 64-bit // mantissa. Use logarithms to avoid looping. bool hasRem = bool(rem); - auto const mustShrink = kLOG10_CEIL(low) - kFL64; + auto const mustShrink = kLoG10Ceil(low) - kFl64; if (mustShrink > 0) { uint128_t const sav(low); exponent += mustShrink; - low /= kPOWER_TABLE[mustShrink]; + low /= kPowerTable[mustShrink]; if (!hasRem) - hasRem = bool(sav - low * kPOWER_TABLE[mustShrink]); + hasRem = bool(sav - low * kPowerTable[mustShrink]); } std::int64_t mantissa = low.convert_to(); @@ -215,7 +245,7 @@ mulRatio(IOUAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundU { if (!result) { - return IOUAmount(-kMIN_MANTISSA, kMIN_EXPONENT); + return IOUAmount(-kMinMantissa, kMinExponent); } // This subtraction cannot underflow because `result` is not zero return IOUAmount(result.mantissa() - 1, result.exponent()); diff --git a/src/libxrpl/protocol/Indexes.cpp b/src/libxrpl/protocol/Indexes.cpp index b37428a6bf..ae29bd3297 100644 --- a/src/libxrpl/protocol/Indexes.cpp +++ b/src/libxrpl/protocol/Indexes.cpp @@ -143,9 +143,9 @@ getBookBase(Book const& book) uint256 getQualityNext(uint256 const& uBase) { - static constexpr uint256 kNEXT_QUALITY( + static constexpr uint256 kNextQuality( "0000000000000000000000000000000000000000000000010000000000000000"); - return uBase + kNEXT_QUALITY; + return uBase + kNextQuality; } std::uint64_t @@ -197,8 +197,8 @@ child(uint256 const& key) noexcept Keylet const& skip() noexcept { - static Keylet const kRET{ltLEDGER_HASHES, indexHash(LedgerNameSpace::SkipList)}; - return kRET; + static Keylet const kRet{ltLEDGER_HASHES, indexHash(LedgerNameSpace::SkipList)}; + return kRet; } Keylet @@ -213,22 +213,22 @@ skip(LedgerIndex ledger) noexcept Keylet const& amendments() noexcept { - static Keylet const kRET{ltAMENDMENTS, indexHash(LedgerNameSpace::Amendments)}; - return kRET; + static Keylet const kRet{ltAMENDMENTS, indexHash(LedgerNameSpace::Amendments)}; + return kRet; } Keylet const& fees() noexcept { - static Keylet const kRET{ltFEE_SETTINGS, indexHash(LedgerNameSpace::FeeSettings)}; - return kRET; + static Keylet const kRet{ltFEE_SETTINGS, indexHash(LedgerNameSpace::FeeSettings)}; + return kRet; } Keylet const& negativeUNL() noexcept { - static Keylet const kRET{ltNEGATIVE_UNL, indexHash(LedgerNameSpace::NegativeUnl)}; - return kRET; + static Keylet const kRet{ltNEGATIVE_UNL, indexHash(LedgerNameSpace::NegativeUnl)}; + return kRet; } Keylet @@ -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,13 +385,13 @@ 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 nftpageMax(AccountID const& owner) { - uint256 id = nft::kPAGE_MASK; + uint256 id = nft::kPageMask; std::memcpy(id.data(), owner.data(), owner.size()); return {ltNFTOKEN_PAGE, id}; } @@ -400,7 +400,7 @@ Keylet nftpage(Keylet const& k, uint256 const& token) { XRPL_ASSERT(k.type == ltNFTOKEN_PAGE, "xrpl::keylet::nftpage : valid input type"); - return {ltNFTOKEN_PAGE, (k.key & ~nft::kPAGE_MASK) + (token & nft::kPAGE_MASK)}; + return {ltNFTOKEN_PAGE, (k.key & ~nft::kPageMask) + (token & nft::kPageMask)}; } Keylet diff --git a/src/libxrpl/protocol/InnerObjectFormats.cpp b/src/libxrpl/protocol/InnerObjectFormats.cpp index 5c691159d7..66b2822a42 100644 --- a/src/libxrpl/protocol/InnerObjectFormats.cpp +++ b/src/libxrpl/protocol/InnerObjectFormats.cpp @@ -165,8 +165,8 @@ InnerObjectFormats::InnerObjectFormats() InnerObjectFormats const& InnerObjectFormats::getInstance() { - static InnerObjectFormats const kINSTANCE; - return kINSTANCE; + static InnerObjectFormats const kInstance; + return kInstance; } SOTemplate const* 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/LedgerFormats.cpp b/src/libxrpl/protocol/LedgerFormats.cpp index 99c636fbdc..8b91bb7930 100644 --- a/src/libxrpl/protocol/LedgerFormats.cpp +++ b/src/libxrpl/protocol/LedgerFormats.cpp @@ -11,12 +11,12 @@ namespace xrpl { std::vector const& LedgerFormats::getCommonFields() { - static auto const kCOMMON_FIELDS = std::vector{ + static auto const kCommonFields = std::vector{ {sfLedgerIndex, SoeOptional}, {sfLedgerEntryType, SoeRequired}, {sfFlags, SoeRequired}, }; - return kCOMMON_FIELDS; + return kCommonFields; } LedgerFormats::LedgerFormats() @@ -41,8 +41,8 @@ LedgerFormats::LedgerFormats() LedgerFormats const& LedgerFormats::getInstance() { - static LedgerFormats const kINSTANCE; - return kINSTANCE; + static LedgerFormats const kInstance; + return kInstance; } } // namespace xrpl 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/Permissions.cpp b/src/libxrpl/protocol/Permissions.cpp index 4222c63fea..ce3baeb35e 100644 --- a/src/libxrpl/protocol/Permissions.cpp +++ b/src/libxrpl/protocol/Permissions.cpp @@ -92,8 +92,8 @@ Permission::Permission() Permission const& Permission::getInstance() { - static Permission const kINSTANCE; - return kINSTANCE; + static Permission const kInstance; + return kInstance; } std::optional diff --git a/src/libxrpl/protocol/Protocol.cpp b/src/libxrpl/protocol/Protocol.cpp index 14230e78bd..fc45a2d4b3 100644 --- a/src/libxrpl/protocol/Protocol.cpp +++ b/src/libxrpl/protocol/Protocol.cpp @@ -4,12 +4,12 @@ namespace xrpl { bool isVotingLedger(LedgerIndex seq) { - return seq % kFLAG_LEDGER_INTERVAL == 0; + return seq % kFlagLedgerInterval == 0; } bool isFlagLedger(LedgerIndex seq) { - return seq % kFLAG_LEDGER_INTERVAL == 0; + return seq % kFlagLedgerInterval == 0; } } // namespace xrpl diff --git a/src/libxrpl/protocol/PublicKey.cpp b/src/libxrpl/protocol/PublicKey.cpp index ad88e60fe7..7472f059e9 100644 --- a/src/libxrpl/protocol/PublicKey.cpp +++ b/src/libxrpl/protocol/PublicKey.cpp @@ -88,9 +88,9 @@ sliceToHex(Slice const& slice) } for (int i = 0; i < slice.size(); ++i) { - constexpr char kHEX[] = "0123456789ABCDEF"; - s += kHEX[((slice[i] & 0xf0) >> 4)]; - s += kHEX[((slice[i] & 0x0f) >> 0)]; + static constexpr char kHex[] = "0123456789ABCDEF"; + s += kHex[((slice[i] & 0xf0) >> 4)]; + s += kHex[((slice[i] & 0x0f) >> 0)]; } return s; } @@ -173,7 +173,7 @@ ed25519Canonical(Slice const& sig) PublicKey::PublicKey(Slice const& slice) { - if (slice.size() < kSIZE) + if (slice.size() < kSize) { logicError( "PublicKey::PublicKey - Input slice cannot be an undersized " @@ -182,12 +182,12 @@ PublicKey::PublicKey(Slice const& slice) if (!publicKeyType(slice)) logicError("PublicKey::PublicKey invalid type"); - std::memcpy(buf_, slice.data(), kSIZE); + std::memcpy(buf_, slice.data(), kSize); } PublicKey::PublicKey(PublicKey const& other) { - std::memcpy(buf_, other.buf_, kSIZE); + std::memcpy(buf_, other.buf_, kSize); } PublicKey& @@ -195,7 +195,7 @@ PublicKey::operator=(PublicKey const& other) { if (this != &other) { - std::memcpy(buf_, other.buf_, kSIZE); + std::memcpy(buf_, other.buf_, kSize); } return *this; @@ -293,11 +293,11 @@ verify(PublicKey const& publicKey, Slice const& m, Slice const& sig) noexcept NodeID calcNodeID(PublicKey const& pk) { - static_assert(NodeID::kBYTES == sizeof(RipeshaHasher::result_type)); + static_assert(NodeID::kBytes == sizeof(RipeshaHasher::result_type)); 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..7ad426bef7 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); } @@ -134,7 +134,7 @@ Quality Quality::round(int digits) const { // Modulus for mantissa - static std::uint64_t const kMOD[17] = { + static std::uint64_t const kMod[17] = { /* 0 */ 10000000000000000, /* 1 */ 1000000000000000, /* 2 */ 100000000000000, @@ -156,8 +156,8 @@ Quality::round(int digits) const auto exponent = value_ >> (64 - 8); auto mantissa = value_ & 0x00ffffffffffffffULL; - mantissa += kMOD[digits] - 1; - mantissa -= (mantissa % kMOD[digits]); + mantissa += kMod[digits] - 1; + mantissa -= (mantissa % kMod[digits]); return Quality{(exponent << (64 - 8)) | mantissa}; } diff --git a/src/libxrpl/protocol/QualityFunction.cpp b/src/libxrpl/protocol/QualityFunction.cpp index 2e9eb5745a..e862770406 100644 --- a/src/libxrpl/protocol/QualityFunction.cpp +++ b/src/libxrpl/protocol/QualityFunction.cpp @@ -13,7 +13,7 @@ namespace xrpl { QualityFunction::QualityFunction(Quality const& quality, QualityFunction::CLOBLikeTag) : m_(0), b_(0), quality_(quality) { - if (quality.rate() <= beast::kZERO) + if (quality.rate() <= beast::kZero) Throw("QualityFunction quality rate is 0."); b_ = 1 / quality.rate(); } @@ -30,7 +30,7 @@ QualityFunction::combine(QualityFunction const& qf) std::optional QualityFunction::outFromAvgQ(Quality const& quality) { - if (m_ != 0 && quality.rate() != beast::kZERO) + if (m_ != 0 && quality.rate() != beast::kZero) { SaveNumberRoundMode const rm(Number::setround(Number::RoundingMode::Upward)); auto const out = (1 / quality.rate() - b_) / m_; 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/Rate2.cpp b/src/libxrpl/protocol/Rate2.cpp index 27b17068e3..fd56f83bf5 100644 --- a/src/libxrpl/protocol/Rate2.cpp +++ b/src/libxrpl/protocol/Rate2.cpp @@ -9,7 +9,7 @@ namespace xrpl { -Rate const kPARITY_RATE(QUALITY_ONE); +Rate const kParityRate(QUALITY_ONE); namespace detail { @@ -35,7 +35,7 @@ multiply(STAmount const& amount, Rate const& rate) { XRPL_ASSERT(rate.value, "xrpl::nft::multiply : nonzero rate input"); - if (rate == kPARITY_RATE) + if (rate == kParityRate) return amount; return multiply(amount, detail::asAmount(rate), amount.asset()); @@ -46,7 +46,7 @@ multiplyRound(STAmount const& amount, Rate const& rate, bool roundUp) { XRPL_ASSERT(rate.value, "xrpl::nft::multiplyRound : nonzero rate input"); - if (rate == kPARITY_RATE) + if (rate == kParityRate) return amount; return mulRound(amount, detail::asAmount(rate), amount.asset(), roundUp); @@ -57,7 +57,7 @@ multiplyRound(STAmount const& amount, Rate const& rate, Asset const& asset, bool { XRPL_ASSERT(rate.value, "xrpl::nft::multiplyRound(Issue) : nonzero rate input"); - if (rate == kPARITY_RATE) + if (rate == kParityRate) { return amount; } @@ -70,7 +70,7 @@ divide(STAmount const& amount, Rate const& rate) { XRPL_ASSERT(rate.value, "xrpl::nft::divide : nonzero rate input"); - if (rate == kPARITY_RATE) + if (rate == kParityRate) return amount; return divide(amount, detail::asAmount(rate), amount.asset()); @@ -81,7 +81,7 @@ divideRound(STAmount const& amount, Rate const& rate, bool roundUp) { XRPL_ASSERT(rate.value, "xrpl::nft::divideRound : nonzero rate input"); - if (rate == kPARITY_RATE) + if (rate == kParityRate) return amount; return divRound(amount, detail::asAmount(rate), amount.asset(), roundUp); @@ -92,7 +92,7 @@ divideRound(STAmount const& amount, Rate const& rate, Asset const& asset, bool r { XRPL_ASSERT(rate.value, "xrpl::nft::divideRound(Issue) : nonzero rate input"); - if (rate == kPARITY_RATE) + if (rate == kParityRate) return amount; return divRound(amount, detail::asAmount(rate), asset, roundUp); diff --git a/src/libxrpl/protocol/SField.cpp b/src/libxrpl/protocol/SField.cpp index 4193bb3e27..a2d4903c6a 100644 --- a/src/libxrpl/protocol/SField.cpp +++ b/src/libxrpl/protocol/SField.cpp @@ -8,7 +8,7 @@ namespace xrpl { // Storage for static const members. -SField::IsSigning const SField::kNOT_SIGNING; +SField::IsSigning const SField::kNotSigning; int SField::num = 0; std::unordered_map SField::knownCodeToField; std::unordered_map SField::knownNameToField; @@ -53,12 +53,12 @@ TypedField::TypedField(PrivateAccessTagT pat, Args&&... args) ##__VA_ARGS__); // SFields which, for historical reasons, do not follow naming conventions. -SField const kSF_INVALID(access, -1, ""); -SField const kSF_GENERIC(access, 0, "Generic"); +SField const sfInvalid(access, -1, ""); +SField const sfGeneric(access, 0, "Generic"); // The following two fields aren't used anywhere, but they break tests/have // downstream effects. -SField const kSF_HASH(access, STI_UINT256, 257, "hash"); -SField const kSF_INDEX(access, STI_UINT256, 258, "index"); +SField const kSfHash(access, STI_UINT256, 257, "hash"); +SField const kSfIndex(access, STI_UINT256, 258, "index"); #include @@ -98,7 +98,7 @@ SField::SField(PrivateAccessTagT, int fc, char const* fn) , fieldType(STI_UNKNOWN) , fieldValue(0) , fieldName(fn) - , fieldMeta(SMdNever) + , fieldMeta(kSmdNever) , fieldNum(++num) , signingField(IsSigning::Yes) , jsonName(fieldName.c_str()) @@ -121,7 +121,7 @@ SField::getField(int code) { return *(it->second); } - return kSF_INVALID; + return sfInvalid; } int @@ -149,7 +149,7 @@ SField::getField(std::string const& fieldName) { return *(it->second); } - return kSF_INVALID; + return sfInvalid; } } // namespace xrpl diff --git a/src/libxrpl/protocol/STAccount.cpp b/src/libxrpl/protocol/STAccount.cpp index f561c9f930..da8b233c61 100644 --- a/src/libxrpl/protocol/STAccount.cpp +++ b/src/libxrpl/protocol/STAccount.cpp @@ -17,11 +17,11 @@ namespace xrpl { -STAccount::STAccount() : value_(beast::kZERO), default_(true) +STAccount::STAccount() : value_(beast::kZero), default_(true) { } -STAccount::STAccount(SField const& n) : STBase(n), value_(beast::kZERO), default_(true) +STAccount::STAccount(SField const& n) : STBase(n), value_(beast::kZero), default_(true) { } @@ -35,11 +35,11 @@ STAccount::STAccount(SField const& n, Buffer const& v) : STAccount(n) // STVar::STVar (SerialIter&, SField const&) // which throws. If STVar can throw in its constructor, then so can // STAccount. - if (v.size() != uint160::kBYTES) + if (v.size() != uint160::kBytes) Throw("Invalid STAccount size"); default_ = false; - memcpy(value_.begin(), v.data(), uint160::kBYTES); + memcpy(value_.begin(), v.data(), uint160::kBytes); } STAccount::STAccount(SerialIter& sit, SField const& name) : STAccount(name, sit.getVLBuffer()) @@ -77,7 +77,7 @@ STAccount::add(Serializer& s) const // Preserve the serialization behavior of an STBlob: // o If we are default (all zeros) serialize as an empty blob. // o Otherwise serialize 160 bits. - int const size = isDefault() ? 0 : uint160::kBYTES; + int const size = isDefault() ? 0 : uint160::kBytes; s.addVL(value_.data(), size); } diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp index c77a1454f8..1a721fedaa 100644 --- a/src/libxrpl/protocol/STAmount.cpp +++ b/src/libxrpl/protocol/STAmount.cpp @@ -19,8 +19,10 @@ #include #include #include +#include #include #include +#include #include #include #include @@ -47,9 +49,9 @@ namespace xrpl { -static std::uint64_t const kTEN_TO14 = 100000000000000ull; -static std::uint64_t const kTEN_TO14M1 = kTEN_TO14 - 1; -static std::uint64_t const kTEN_TO17 = kTEN_TO14 * 1000; +static std::uint64_t const kTenTO14 = 100000000000000ull; +static std::uint64_t const kTenTO14M1 = kTenTO14 - 1; +static std::uint64_t const kTenTO17 = kTenTO14 * 1000; //------------------------------------------------------------------------------ static std::int64_t @@ -88,11 +90,11 @@ areComparable(STAmount const& v1, STAmount const& v2) { return std::visit( [&](TIss1 const& issue1, TIss2 const& issue2) { - if constexpr (kIS_ISSUE_V && kIS_ISSUE_V) + if constexpr (kIsIssueV && kIsIssueV) { return v1.native() == v2.native() && issue1.currency == issue2.currency; } - else if constexpr (kIS_MPTISSUE_V && kIS_MPTISSUE_V) + else if constexpr (kIsMptissueV && kIsMptissueV) { return issue1 == issue2; } @@ -105,20 +107,20 @@ areComparable(STAmount const& v1, STAmount const& v2) v2.asset().value()); } -static_assert(kINITIAL_XRP.drops() == STAmount::kMAX_NATIVE_N); +static_assert(kInitialXrp.drops() == STAmount::kMaxNativeN); STAmount::STAmount(SerialIter& sit, SField const& name) : STBase(name) { std::uint64_t value = sit.get64(); // native or MPT - if ((value & kISSUED_CURRENCY) == 0) + if ((value & kIssuedCurrency) == 0) { - if ((value & kMP_TOKEN) != 0) + if ((value & kMpToken) != 0) { // is MPT offset_ = 0; - isNegative_ = (value & kPOSITIVE) == 0; + isNegative_ = (value & kPositive) == 0; value_ = (value << 8) | sit.get8(); asset_ = sit.get192(); return; @@ -126,9 +128,9 @@ STAmount::STAmount(SerialIter& sit, SField const& name) : STBase(name) // else is XRP asset_ = xrpIssue(); // positive - if ((value & kPOSITIVE) != 0) + if ((value & kPositive) != 0) { - value_ = value & kVALUE_MASK; + value_ = value & kValueMask; offset_ = 0; isNegative_ = false; return; @@ -138,7 +140,7 @@ STAmount::STAmount(SerialIter& sit, SField const& name) : STBase(name) if (value == 0) Throw("negative zero is not canonical"); - value_ = value & kVALUE_MASK; + value_ = value & kValueMask; offset_ = 0; isNegative_ = true; return; @@ -165,8 +167,7 @@ STAmount::STAmount(SerialIter& sit, SField const& name) : STBase(name) bool const isNegative = (offset & 256) == 0; offset = (offset & 255) - 97; // center the range - if (value < kMIN_VALUE || value > kMAX_VALUE || offset < kMIN_OFFSET || - offset > kMAX_OFFSET) + if (value < kMinValue || value > kMaxValue || offset < kMinOffset || offset > kMaxOffset) { Throw("invalid currency value"); } @@ -229,7 +230,7 @@ STAmount::STAmount(std::uint64_t mantissa, bool negative) } STAmount::STAmount(XRPAmount const& amount) - : asset_(xrpIssue()), offset_(0), isNegative_(amount < beast::kZERO) + : asset_(xrpIssue()), offset_(0), isNegative_(amount < beast::kZero) { if (isNegative_) { @@ -316,7 +317,7 @@ STAmount::operator=(IOUAmount const& iou) { XRPL_ASSERT(integral() == false, "xrpl::STAmount::operator=(IOUAmount) : is not integral"); offset_ = iou.exponent(); - isNegative_ = iou < beast::kZERO; + isNegative_ = iou < beast::kZero; if (isNegative_) { value_ = static_cast(-iou.mantissa()); @@ -373,10 +374,10 @@ operator+(STAmount const& v1, STAmount const& v2) if (!areComparable(v1, v2)) Throw("Can't add amounts that are't comparable!"); - if (v2 == beast::kZERO) + if (v2 == beast::kZero) return v1; - if (v1 == beast::kZERO) + if (v1 == beast::kZero) { // Result must be in terms of v1 currency and issuer. return {v1.getFName(), v1.asset(), v2.mantissa(), v2.exponent(), v2.negative()}; @@ -400,7 +401,7 @@ operator-(STAmount const& v1, STAmount const& v2) //------------------------------------------------------------------------------ -std::uint64_t const STAmount::kU_RATE_ONE = getRate(STAmount(1), STAmount(1)); +std::uint64_t const STAmount::kURateOne = getRate(STAmount(1), STAmount(1)); void STAmount::setIssue(Asset const& asset) @@ -420,13 +421,13 @@ STAmount::setIssue(Asset const& asset) std::uint64_t getRate(STAmount const& offerOut, STAmount const& offerIn) { - if (offerOut == beast::kZERO) + if (offerOut == beast::kZero) return 0; try { STAmount const r = divide(offerIn, offerOut, noIssue()); - if (r == beast::kZERO) // offer is too good + if (r == beast::kZero) // offer is too good return 0; XRPL_ASSERT( (r.exponent() >= -100) && (r.exponent() <= 155), @@ -467,7 +468,7 @@ canAdd(STAmount const& a, STAmount const& b) return false; // special case: adding anything to zero is always fine - if (a == beast::kZERO || b == beast::kZERO) + if (a == beast::kZero || b == beast::kZero) return true; // XRP case (overflow & underflow check) @@ -487,17 +488,17 @@ canAdd(STAmount const& a, STAmount const& b) auto const ret = std::visit( [&]( TIss1 const&, TIss2 const&) -> std::optional { - if constexpr (kIS_ISSUE_V && kIS_ISSUE_V) + if constexpr (kIsIssueV && kIsIssueV) { - static STAmount const kONE{IOUAmount{1, 0}, noIssue()}; - static STAmount const kMAX_LOSS{IOUAmount{1, -4}, noIssue()}; - STAmount const lhs = divide((a - b) + b, a, noIssue()) - kONE; - STAmount const rhs = divide((b - a) + a, b, noIssue()) - kONE; - return ((rhs.negative() ? -rhs : rhs) + (lhs.negative() ? -lhs : lhs)) <= kMAX_LOSS; + static STAmount const kOne{IOUAmount{1, 0}, noIssue()}; + static STAmount const kMaxLoss{IOUAmount{1, -4}, noIssue()}; + STAmount const lhs = divide((a - b) + b, a, noIssue()) - kOne; + STAmount const rhs = divide((b - a) + a, b, noIssue()) - kOne; + return ((rhs.negative() ? -rhs : rhs) + (lhs.negative() ? -lhs : lhs)) <= kMaxLoss; } // MPT (overflow & underflow check) - if constexpr (kIS_MPTISSUE_V && kIS_MPTISSUE_V) + if constexpr (kIsMptissueV && kIsMptissueV) { MPTAmount const aVal = a.mpt(); MPTAmount const bVal = b.mpt(); @@ -544,7 +545,7 @@ canSubtract(STAmount const& a, STAmount const& b) return false; // Special case: subtracting zero is always fine - if (b == beast::kZERO) + if (b == beast::kZero) return true; // XRP case (underflow & overflow check) @@ -568,13 +569,13 @@ canSubtract(STAmount const& a, STAmount const& b) auto const ret = std::visit( [&]( TIss1 const&, TIss2 const&) -> std::optional { - if constexpr (kIS_ISSUE_V && kIS_ISSUE_V) + if constexpr (kIsIssueV && kIsIssueV) { return true; } // MPT case (underflow & overflow check) - if constexpr (kIS_MPTISSUE_V && kIS_MPTISSUE_V) + if constexpr (kIsMptissueV && kIsMptissueV) { MPTAmount const aVal = a.mpt(); MPTAmount const bVal = b.mpt(); @@ -604,7 +605,7 @@ canSubtract(STAmount const& a, STAmount const& b) void STAmount::setJson(json::Value& elem) const { - elem = json::ObjectValue; + elem = json::ValueType::Object; if (!native()) { @@ -645,7 +646,7 @@ std::string STAmount::getText() const { // keep full internal accuracy, but make more human friendly if possible - if (*this == beast::kZERO) + if (*this == beast::kZero) return "0"; std::string const rawValue(std::to_string(value_)); @@ -742,9 +743,9 @@ STAmount::add(Serializer& s) const { asset_.visit( [&](MPTIssue const& issue) { - auto u8 = static_cast(kMP_TOKEN >> 56); + auto u8 = static_cast(kMpToken >> 56); if (!isNegative_) - u8 |= static_cast(kPOSITIVE >> 56); + u8 |= static_cast(kPositive >> 56); s.add8(u8); s.add64(value_); s.addBitString(issue.getMptID()); @@ -756,7 +757,7 @@ STAmount::add(Serializer& s) const if (!isNegative_) { - s.add64(value_ | kPOSITIVE); + s.add64(value_ | kPositive); } else { @@ -765,9 +766,9 @@ STAmount::add(Serializer& s) const } else { - if (*this == beast::kZERO) + if (*this == beast::kZero) { - s.add64(kISSUED_CURRENCY); + s.add64(kIssuedCurrency); } else if (isNegative_) // 512 = not native { @@ -860,11 +861,11 @@ STAmount::canonicalize() offset_ = 0; } - if (native() && value_ > kMAX_NATIVE_N) + if (native() && value_ > kMaxNativeN) { Throw("Native currency amount out of range"); } - else if (!native() && value_ > kMAX_MP_TOKEN_AMOUNT) + else if (!native() && value_ > kMaxMpTokenAmount) { Throw("MPT amount out of range"); } @@ -947,8 +948,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()) { @@ -1042,7 +1043,7 @@ amountFromJsonNoThrow(STAmount& result, json::Value const& jvSource) { try { - result = amountFromJson(kSF_GENERIC, jvSource); + result = amountFromJson(sfGeneric, jvSource); return true; } catch (std::exception const& e) @@ -1113,6 +1114,50 @@ operator-(STAmount const& value) STAmount::Unchecked{}); } +static bool +hasInvalidAmount(STBase const& field, int depth, beast::Journal j); + +static bool +hasInvalidAmount(STObject const& object, int depth, beast::Journal j) +{ + return std::ranges::any_of( + object, [&](STBase const& field) { return hasInvalidAmount(field, depth, j); }); +} + +static bool +hasInvalidAmount(STArray const& array, int depth, beast::Journal j) +{ + return std::ranges::any_of( + array, [&](STObject const& object) { return hasInvalidAmount(object, depth, j); }); +} + +static bool +hasInvalidAmount(STBase const& field, int depth, beast::Journal j) +{ + if (depth > 10) + { + JLOG(j.error()) << "hasInvalidAmount: depth exceeds 10"; + return true; + } + + if (auto const amount = dynamic_cast(&field)) + return !isLegalMPT(*amount) || !isLegalNet(*amount); + + if (auto const object = dynamic_cast(&field)) + return hasInvalidAmount(*object, depth + 1, j); + + if (auto const array = dynamic_cast(&field)) + return hasInvalidAmount(*array, depth + 1, j); + + return false; +} + +bool +hasInvalidAmount(STBase const& field, beast::Journal j) +{ + return hasInvalidAmount(field, 0, j); +} + //------------------------------------------------------------------------------ // // Arithmetic @@ -1165,10 +1210,10 @@ muldivRound( STAmount divide(STAmount const& num, STAmount const& den, Asset const& asset) { - if (den == beast::kZERO) + if (den == beast::kZero) Throw("division by zero"); - if (num == beast::kZERO) + if (num == beast::kZero) return {asset}; std::uint64_t numVal = num.mantissa(); @@ -1178,7 +1223,7 @@ divide(STAmount const& num, STAmount const& den, Asset const& asset) if (num.integral()) { - while (numVal < STAmount::kMIN_VALUE) + while (numVal < STAmount::kMinValue) { // Need to bring into range numVal *= 10; @@ -1188,7 +1233,7 @@ divide(STAmount const& num, STAmount const& den, Asset const& asset) if (den.integral()) { - while (denVal < STAmount::kMIN_VALUE) + while (denVal < STAmount::kMinValue) { denVal *= 10; --denOffset; @@ -1202,7 +1247,7 @@ divide(STAmount const& num, STAmount const& den, Asset const& asset) // is in the range of 10^16 to 10^15. return STAmount( asset, - muldiv(numVal, kTEN_TO17, denVal) + 5, + muldiv(numVal, kTenTO17, denVal) + 5, numOffset - denOffset - 17, num.negative() != den.negative()); } @@ -1210,7 +1255,7 @@ divide(STAmount const& num, STAmount const& den, Asset const& asset) STAmount multiply(STAmount const& v1, STAmount const& v2, Asset const& asset) { - if (v1 == beast::kZERO || v2 == beast::kZERO) + if (v1 == beast::kZero || v2 == beast::kZero) return STAmount(asset); if (v1.native() && v2.native() && asset.native()) @@ -1285,9 +1330,9 @@ canonicalizeRound(bool integral, std::uint64_t& value, int& offset, bool) ++offset; } } - else if (value > STAmount::kMAX_VALUE) + else if (value > STAmount::kMaxValue) { - while (value > (10 * STAmount::kMAX_VALUE)) + while (value > (10 * STAmount::kMaxValue)) { value /= 10; ++offset; @@ -1327,9 +1372,9 @@ canonicalizeRoundStrict(bool integral, std::uint64_t& value, int& offset, bool r ++offset; } } - else if (value > STAmount::kMAX_VALUE) + else if (value > STAmount::kMaxValue) { - while (value > (10 * STAmount::kMAX_VALUE)) + while (value > (10 * STAmount::kMaxValue)) { value /= 10; ++offset; @@ -1348,7 +1393,7 @@ roundToScale(STAmount const& value, std::int32_t scale, Number::RoundingMode rou return value; // Nothing to do for zero. - if (value == beast::kZERO) + if (value == beast::kZero) return value; // If the value's exponent is greater than or equal to the scale, then @@ -1357,10 +1402,10 @@ roundToScale(STAmount const& value, std::int32_t scale, Number::RoundingMode rou if (value.exponent() >= scale) return value; - STAmount const referenceValue{value.asset(), STAmount::kMIN_VALUE, scale, value.negative()}; + STAmount const referenceValue{value.asset(), STAmount::kMinValue, scale, value.negative()}; NumberRoundModeGuard const mg(rounding); - // With an IOU, the the result of addition will be truncated to the + // With an IOU, the result of addition will be truncated to the // precision of the larger value, which in this case is referenceValue. Then // remove the reference value via subtraction, and we're left with the // rounded value. @@ -1394,7 +1439,7 @@ template static STAmount divRoundImpl(STAmount const& num, STAmount const& den, Asset const& asset, bool roundUp) { - if (den == beast::kZERO) + if (den == beast::kZero) Throw("division by zero"); - if (num == beast::kZERO) + if (num == beast::kZero) return {asset}; std::uint64_t numVal = num.mantissa(), denVal = den.mantissa(); @@ -1519,7 +1564,7 @@ divRoundImpl(STAmount const& num, STAmount const& den, Asset const& asset, bool if (num.integral()) { - while (numVal < STAmount::kMIN_VALUE) + while (numVal < STAmount::kMinValue) { numVal *= 10; --numOffset; @@ -1528,7 +1573,7 @@ divRoundImpl(STAmount const& num, STAmount const& den, Asset const& asset, bool if (den.integral()) { - while (denVal < STAmount::kMIN_VALUE) + while (denVal < STAmount::kMinValue) { denVal *= 10; --denOffset; @@ -1546,7 +1591,7 @@ divRoundImpl(STAmount const& num, STAmount const& den, Asset const& asset, bool // We round away from zero if we're rounding up or // truncate if we're rounding down. std::uint64_t amount = - muldivRound(numVal, kTEN_TO17, denVal, (resultNegative != roundUp) ? denVal - 1 : 0); + muldivRound(numVal, kTenTO17, denVal, (resultNegative != roundUp) ? denVal - 1 : 0); int offset = numOffset - denOffset - 17; @@ -1573,8 +1618,8 @@ divRoundImpl(STAmount const& num, STAmount const& den, Asset const& asset, bool else { // return the smallest value above zero - amount = STAmount::kMIN_VALUE; - offset = STAmount::kMIN_OFFSET; + amount = STAmount::kMinValue; + offset = STAmount::kMinOffset; } return STAmount(asset, amount, offset, resultNegative); } @@ -1593,4 +1638,9 @@ divRoundStrict(STAmount const& num, STAmount const& den, Asset const& asset, boo return divRoundImpl(num, den, asset, roundUp); } +[[nodiscard]] bool +STAmount::isZeroAtScale(int scale) const +{ + return roundToScale(*this, scale, Number::RoundingMode::ToNearest).signum() == 0; +} } // namespace xrpl 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/STBase.cpp b/src/libxrpl/protocol/STBase.cpp index ec6131482f..f029f10e75 100644 --- a/src/libxrpl/protocol/STBase.cpp +++ b/src/libxrpl/protocol/STBase.cpp @@ -12,7 +12,7 @@ namespace xrpl { -STBase::STBase() : fName_(&kSF_GENERIC) +STBase::STBase() : fName_(&sfGeneric) { } diff --git a/src/libxrpl/protocol/STInteger.cpp b/src/libxrpl/protocol/STInteger.cpp index d17dd49fe5..5f3fb6ffa4 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::kSmdBaseTen)) { 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/STLedgerEntry.cpp b/src/libxrpl/protocol/STLedgerEntry.cpp index 8bec23d319..8c5c5b5eae 100644 --- a/src/libxrpl/protocol/STLedgerEntry.cpp +++ b/src/libxrpl/protocol/STLedgerEntry.cpp @@ -133,13 +133,12 @@ STLedgerEntry::getJson(JsonOptions options) const bool STLedgerEntry::isThreadedType(Rules const& rules) const { - static constexpr std::array kNEW_PREVIOUS_TXN_ID_TYPES = { + static constexpr std::array kNewPreviousTxnIdTypes = { ltDIR_NODE, ltAMENDMENTS, ltFEE_SETTINGS, ltNEGATIVE_UNL, ltAMM}; // Exclude PrevTxnID/PrevTxnLgrSeq if the fixPreviousTxnID amendment is not // enabled and the ledger object type is in the above set bool const excludePrevTxnID = !rules.enabled(fixPreviousTxnID) && - (std::count( - kNEW_PREVIOUS_TXN_ID_TYPES.cbegin(), kNEW_PREVIOUS_TXN_ID_TYPES.cend(), type_) != 0); + (std::count(kNewPreviousTxnIdTypes.cbegin(), kNewPreviousTxnIdTypes.cend(), type_) != 0); return !excludePrevTxnID && getFieldIndex(sfPreviousTxnID) != -1; } diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp index f6481a4d5d..aa3e83515c 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::kSmdNeedsAsset), "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::kSmdNeedsAsset)) { // asset is defined in the STTakesAsset base class if (asset_) @@ -160,7 +160,7 @@ operator<<(std::ostream& out, STNumber const& rhs) NumberParts partsFromString(std::string const& number) { - static boost::regex const kRE_NUMBER( + static boost::regex const kReNumber( "^" // the beginning of the string "([-+]?)" // (optional) + or - character "(0|[1-9][0-9]*)" // a number (no leading zeroes, unless 0) @@ -171,7 +171,7 @@ partsFromString(std::string const& number) boost::smatch match; - if (!boost::regex_match(number, match, kRE_NUMBER)) + if (!boost::regex_match(number, match, kReNumber)) Throw("'" + number + "' is not a number"); // Match fields: diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp index 6bce2f0ab2..e16cbc871f 100644 --- a/src/libxrpl/protocol/STObject.cpp +++ b/src/libxrpl/protocol/STObject.cpp @@ -646,22 +646,22 @@ STObject::getFieldVL(SField const& field) const STAmount const& STObject::getFieldAmount(SField const& field) const { - static STAmount const kEMPTY{}; - return getFieldByConstRef(field, kEMPTY); + static STAmount const kEmpty{}; + return getFieldByConstRef(field, kEmpty); } STPathSet const& STObject::getFieldPathSet(SField const& field) const { - static STPathSet const kEMPTY{}; - return getFieldByConstRef(field, kEMPTY); + static STPathSet const kEmpty{}; + return getFieldByConstRef(field, kEmpty); } STVector256 const& STObject::getFieldV256(SField const& field) const { - static STVector256 const kEMPTY{}; - return getFieldByConstRef(field, kEMPTY); + static STVector256 const kEmpty{}; + return getFieldByConstRef(field, kEmpty); } STObject @@ -677,22 +677,22 @@ STObject::getFieldObject(SField const& field) const STArray const& STObject::getFieldArray(SField const& field) const { - static STArray const kEMPTY{}; - return getFieldByConstRef(field, kEMPTY); + static STArray const kEmpty{}; + return getFieldByConstRef(field, kEmpty); } STCurrency const& STObject::getFieldCurrency(SField const& field) const { - static STCurrency const kEMPTY{}; - return getFieldByConstRef(field, kEMPTY); + static STCurrency const kEmpty{}; + return getFieldByConstRef(field, kEmpty); } STNumber const& STObject::getFieldNumber(SField const& field) const { - static STNumber const kEMPTY{}; - return getFieldByConstRef(field, kEMPTY); + static STNumber const kEmpty{}; + return getFieldByConstRef(field, kEmpty); } void @@ -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..64c4dfd1be 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(kMaxParsedJsonArraySize) + " 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, @@ -249,7 +258,7 @@ parseUint16( safeCast(static_cast( TxFormats::getInstance().findTypeByName(strValue)))); - if (*name == kSF_GENERIC) + if (*name == sfGeneric) name = &sfTransaction; } else if (field == sfLedgerEntryType) @@ -259,7 +268,7 @@ parseUint16( safeCast(static_cast( LedgerFormats::getInstance().findTypeByName(strValue)))); - if (*name == kSF_GENERIC) + if (*name == sfGeneric) name = &sfLedgerEntry; } else @@ -285,7 +294,7 @@ parseUint16( template static std::optional -parseUint32( +parseUInt32( SField const& field, std::string const& jsonName, std::string const& fieldName, @@ -352,7 +361,7 @@ parseLeaf( auto const& field = SField::getField(fieldName); // checked in parseObject - if (field == kSF_INVALID) + if (field == sfInvalid) { // LCOV_EXCL_START error = unknownField(jsonName, fieldName); @@ -365,8 +374,8 @@ parseLeaf( case STI_UINT8: try { - constexpr auto kMIN_VALUE = std::numeric_limits::min(); - constexpr auto kMAX_VALUE = std::numeric_limits::max(); + constexpr auto kMinValue = std::numeric_limits::min(); + constexpr auto kMaxValue = std::numeric_limits::max(); if (value.isString()) { std::string const strValue = value.asString(); @@ -377,7 +386,7 @@ parseLeaf( { auto ter = transCode(strValue); - if (!ter || TERtoInt(*ter) < kMIN_VALUE || TERtoInt(*ter) > kMAX_VALUE) + if (!ter || TERtoInt(*ter) < kMinValue || TERtoInt(*ter) > kMaxValue) { error = outOfRange(jsonName, fieldName); return ret; @@ -400,7 +409,7 @@ parseLeaf( } else if (value.isInt()) { - if (value.asInt() < kMIN_VALUE || value.asInt() > kMAX_VALUE) + if (value.asInt() < kMinValue || value.asInt() > kMaxValue) { error = outOfRange(jsonName, fieldName); return ret; @@ -411,7 +420,7 @@ parseLeaf( } else if (value.isUInt()) { - if (value.asUInt() > kMAX_VALUE) + if (value.asUInt() > kMaxValue) { error = outOfRange(jsonName, fieldName); return ret; @@ -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::kSmdBaseTen); // 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() > kMaxParsedJsonArraySize) + { + 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() > kMaxParsedJsonArraySize) + { + 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() > kMaxParsedJsonArraySize) + { + 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; @@ -810,7 +839,7 @@ parseLeaf( error = invalidData(elementName, assetName.cStr()); return ret; } - if (getMPTIssuer(u) == beast::kZERO) + if (getMPTIssuer(u) == beast::kZero) { error = invalidData(elementName, jss::account.cStr()); return ret; @@ -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 > kMaxParsedJsonDepth) { error = tooDeep(jsonName); return std::nullopt; @@ -984,10 +1011,9 @@ parseObject( for (auto const& fieldName : json.getMemberNames()) { json::Value const& value = json[fieldName]; - auto const& field = SField::getField(fieldName); - if (field == kSF_INVALID) + if (field == sfInvalid) { error = unknownField(jsonName, fieldName); return std::nullopt; @@ -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 > kMaxParsedJsonDepth) { error = tooDeep(jsonName); return std::nullopt; } + if (not json.isNull() and json.size() > kMaxParsedJsonArraySize) + { + error = arrayTooBig(jsonName, ""); + return std::nullopt; + } + try { STArray tail(inName); @@ -1108,13 +1140,11 @@ 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) + if (nameField == sfInvalid) { error = unknownField(jsonName, memberName); return std::nullopt; @@ -1159,7 +1189,7 @@ parseArray( STParsedJSONObject::STParsedJSONObject(std::string const& name, json::Value const& json) { using namespace STParsedJSONDetail; - object = parseObject(name, json, kSF_GENERIC, 0, error); + object = parseObject(name, json, sfGeneric, 0, error); } } // namespace xrpl diff --git a/src/libxrpl/protocol/STPathSet.cpp b/src/libxrpl/protocol/STPathSet.cpp index 8c4b139792..cb70ac36fe 100644 --- a/src/libxrpl/protocol/STPathSet.cpp +++ b/src/libxrpl/protocol/STPathSet.cpp @@ -90,10 +90,14 @@ STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name) if (hasAccount) account = sit.get160(); - XRPL_ASSERT( - !(hasCurrency && hasMPT), "xrpl::STPathSet::STPathSet : not has Currency and MPT"); + if (hasCurrency && hasMPT) + { + JLOG(debugLog().error()) << "Bad path element MPT and Currency in pathset"; + Throw("bad path element: MPT and Currency"); + } + if (hasCurrency) - asset = static_cast(sit.get160()); + asset = Currency::fromRaw(sit.get160()); if (hasMPT) asset = sit.get192(); @@ -101,7 +105,7 @@ STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name) if (hasIssuer) issuer = sit.get160(); - path.emplace_back(account, asset, issuer, hasCurrency); + path.emplace_back(account, asset, issuer, hasCurrency || hasMPT); } } } @@ -167,11 +171,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 +205,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..806861e6b6 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::kSmdNeedsAsset)) { 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..2777981fd7 100644 --- a/src/libxrpl/protocol/STTx.cpp +++ b/src/libxrpl/protocol/STTx.cpp @@ -69,8 +69,8 @@ getTxFormat(TxType type) STTx::STTx(STObject&& object) : STObject(std::move(object)) { - tx_type_ = safeCast(getFieldU16(sfTransactionType)); - applyTemplate(getTxFormat(tx_type_)->getSOTemplate()); // may throw + txType_ = safeCast(getFieldU16(sfTransactionType)); + applyTemplate(getTxFormat(txType_)->getSOTemplate()); // may throw tid_ = getHash(HashPrefix::TransactionId); } @@ -78,15 +78,15 @@ STTx::STTx(SerialIter& sit) : STObject(sfTransaction) { int const length = sit.getBytesLeft(); - if ((length < kTX_MIN_SIZE_BYTES) || (length > kTX_MAX_SIZE_BYTES)) + if ((length < kTxMinSizeBytes) || (length > kTxMaxSizeBytes)) Throw("Transaction length invalid"); if (set(sit)) Throw("Transaction contains an object terminator"); - tx_type_ = safeCast(getFieldU16(sfTransactionType)); + txType_ = safeCast(getFieldU16(sfTransactionType)); - applyTemplate(getTxFormat(tx_type_)->getSOTemplate()); // May throw + applyTemplate(getTxFormat(txType_)->getSOTemplate()); // May throw tid_ = getHash(HashPrefix::TransactionId); } @@ -99,9 +99,9 @@ STTx::STTx(TxType type, std::function assembler) : STObject(sfT assembler(*this); - tx_type_ = safeCast(getFieldU16(sfTransactionType)); + txType_ = safeCast(getFieldU16(sfTransactionType)); - if (tx_type_ != type) + if (txType_ != type) logicError("Transaction type was mutated during assembly"); tid_ = getHash(HashPrefix::TransactionId); @@ -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()); @@ -352,13 +352,13 @@ STTx::getJson(JsonOptions options, bool binary) const std::string const& STTx::getMetaSQLInsertReplaceHeader() { - static std::string const kSQL = + static std::string const kSql = "INSERT OR REPLACE INTO Transactions " "(TransID, TransType, FromAcct, FromSeq, LedgerSeq, Status, RawTxn, " "TxnMeta)" " VALUES "; - return kSQL; + return kSql; } std::string @@ -377,14 +377,14 @@ STTx::getMetaSQL( TxnSql status, std::string const& escapedMetaData) const { - static boost::format const kBF_TRANS("('%s', '%s', '%s', '%d', '%d', '%c', %s, %s)"); + static boost::format const kBfTrans("('%s', '%s', '%s', '%d', '%d', '%c', %s, %s)"); std::string rTxn = sqlBlobLiteral(rawTxn.peekData()); - auto format = TxFormats::getInstance().findByType(tx_type_); + auto format = TxFormats::getInstance().findByType(txType_); XRPL_ASSERT(format, "xrpl::STTx::getMetaSQL : non-null type format"); return str( - boost::format(kBF_TRANS) % to_string(getTransactionID()) % format->getName() % + boost::format(kBfTrans) % to_string(getTransactionID()) % format->getName() % toBase58(getAccountID(sfAccount)) % getFieldU32(sfSequence) % inLedger % safeCast(status) % rTxn % escapedMetaData); } @@ -454,11 +454,11 @@ multiSignHelper( STArray const& signers{sigObject.getFieldArray(sfSigners)}; // There are well known bounds that the number of signers must be within. - if (signers.size() < STTx::kMIN_MULTI_SIGNERS || signers.size() > STTx::kMAX_MULTI_SIGNERS) + if (signers.size() < STTx::kMinMultiSigners || signers.size() > STTx::kMaxMultiSigners) return Unexpected("Invalid Signers array size."); // Signers must be in sorted order by AccountID. - AccountID lastAccountID(beast::kZERO); + AccountID lastAccountID(beast::kZero); for (auto const& signer : signers) { @@ -535,8 +535,10 @@ STTx::checkMultiSign(Rules const& rules, STObject const& sigObject) const { // Used inside the loop in multiSignHelper to enforce that // the account owner may not multisign for themselves. + // For delegated transactions sfDelegate is the account whose signer list is checked, + // the delegate account itself can not be among the signers. auto const txnAccountID = - &sigObject != this ? std::nullopt : std::optional(getAccountID(sfAccount)); + &sigObject != this ? std::nullopt : std::optional(getFeePayer()); // We can ease the computational load inside the loop a bit by // pre-constructing part of the data that we hash. Fill a Serializer @@ -652,7 +654,7 @@ isMemoOkay(STObject const& st, std::string& reason) // The only allowed characters for MemoType and MemoFormat are the // characters allowed in URLs per RFC 3986: alphanumerics and the // following symbols: -._~:/?#[]@!$&'()*+,;=% - static constexpr std::array const kALLOWED_SYMBOLS = []() { + static constexpr std::array const kAllowedSymbols = []() { std::array a{}; std::string_view const symbols( @@ -668,7 +670,7 @@ isMemoOkay(STObject const& st, std::string& reason) for (unsigned char const c : *optData) { - if (kALLOWED_SYMBOLS[c] == 0) + if (kAllowedSymbols[c] == 0) { reason = "The MemoType and MemoFormat fields may only " @@ -731,14 +733,14 @@ isRawTransactionOkay(STObject const& st, std::string& reason) return true; if (st.isFieldPresent(sfBatchSigners) && - st.getFieldArray(sfBatchSigners).size() > kMAX_BATCH_TX_COUNT) + st.getFieldArray(sfBatchSigners).size() > kMaxBatchTxCount) { reason = "Batch Signers array exceeds max entries."; return false; } auto const& rawTxns = st.getFieldArray(sfRawTransactions); - if (rawTxns.size() > kMAX_BATCH_TX_COUNT) + if (rawTxns.size() > kMaxBatchTxCount) { reason = "Raw Transactions array exceeds max entries."; return false; diff --git a/src/libxrpl/protocol/STValidation.cpp b/src/libxrpl/protocol/STValidation.cpp index dd4b8a0fee..5eafb407ec 100644 --- a/src/libxrpl/protocol/STValidation.cpp +++ b/src/libxrpl/protocol/STValidation.cpp @@ -38,7 +38,7 @@ STValidation::validationFormat() // it relies on the SField's below being initialized, and we can't // guarantee the initialization order. // clang-format off - static SOTemplate const kFORMAT{ + static SOTemplate const kFormat{ {sfFlags, SoeRequired}, {sfLedgerHash, SoeRequired}, {sfLedgerSequence, SoeRequired}, @@ -62,7 +62,7 @@ STValidation::validationFormat() }; // clang-format on - return kFORMAT; + return kFormat; }; uint256 @@ -108,7 +108,7 @@ STValidation::isValid() const noexcept getSignerPublic(), getSigningHash(), makeSlice(getFieldVL(sfSignature)), - (getFlags() & kVF_FULLY_CANONICAL_SIG) != 0u); + (getFlags() & kVfFullyCanonicalSig) != 0u); } return valid_.value(); @@ -117,7 +117,7 @@ STValidation::isValid() const noexcept bool STValidation::isFull() const noexcept { - return (getFlags() & kVF_FULL_VALIDATION) != 0; + return (getFlags() & kVfFullValidation) != 0; } Blob diff --git a/src/libxrpl/protocol/STVar.cpp b/src/libxrpl/protocol/STVar.cpp index 8e45d3c75b..3d123e6a0e 100644 --- a/src/libxrpl/protocol/STVar.cpp +++ b/src/libxrpl/protocol/STVar.cpp @@ -38,7 +38,7 @@ STVar::~STVar() STVar::STVar(STVar const& other) { if (other.p_ != nullptr) - p_ = other.p_->copy(kMAX_SIZE, &d_); + p_ = other.p_->copy(kMaxSize, &d_); } STVar::STVar(STVar&& other) @@ -50,7 +50,7 @@ STVar::STVar(STVar&& other) } else { - p_ = other.p_->move(kMAX_SIZE, &d_); + p_ = other.p_->move(kMaxSize, &d_); } } @@ -62,7 +62,7 @@ STVar::operator=(STVar const& rhs) destroy(); if (rhs.p_ != nullptr) { - p_ = rhs.p_->copy(kMAX_SIZE, &d_); + p_ = rhs.p_->copy(kMaxSize, &d_); } else { @@ -86,7 +86,7 @@ STVar::operator=(STVar&& rhs) } else { - p_ = rhs.p_->move(kMAX_SIZE, &d_); + p_ = rhs.p_->move(kMaxSize, &d_); } } @@ -149,9 +149,9 @@ STVar::constructST(SerializedTypeID id, int depth, Args&&... args) } else { - constexpr bool kALWAYS_FALSE = + static constexpr bool kAlwaysFalse = !std::is_same_v, std::tuple>; - static_assert(kALWAYS_FALSE, "Invalid STVar constructor arguments"); + static_assert(kAlwaysFalse, "Invalid STVar constructor arguments"); } }; 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..ce6ad2368a 100644 --- a/src/libxrpl/protocol/STXChainBridge.cpp +++ b/src/libxrpl/protocol/STXChainBridge.cpp @@ -64,11 +64,12 @@ 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 kBridgeJson = + xrpl::STXChainBridge().getJson(xrpl::JsonOptions::Values::None); for (auto it = v.begin(); it != v.end(); ++it) { std::string const name = it.memberName(); - if (!kBRIDGE_JSON.isMember(name)) + if (!kBridgeJson.isMember(name)) { Throw("STXChainBridge extra field detected: " + name); } 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/protocol/TER.cpp b/src/libxrpl/protocol/TER.cpp index 3654547dd2..6b8dfc6811 100644 --- a/src/libxrpl/protocol/TER.cpp +++ b/src/libxrpl/protocol/TER.cpp @@ -22,7 +22,7 @@ transResults() static std::unordered_map< TERUnderlyingType, - std::pair> const kRESULTS + std::pair> const kResults { MAKE_ERROR(tecAMM_BALANCE, "AMM has invalid balance."), MAKE_ERROR(tecAMM_INVALID_TOKENS, "AMM invalid LP tokens."), @@ -223,7 +223,7 @@ transResults() #undef MAKE_ERROR - return kRESULTS; + return kResults; } bool @@ -262,7 +262,7 @@ transHuman(TER code) std::optional transCode(std::string const& token) { - static auto const kRESULTS = [] { + static auto const kResults = [] { auto& byTer = transResults(); auto range = boost::make_iterator_range(byTer.begin(), byTer.end()); auto tRange = boost::adaptors::transform( @@ -272,9 +272,9 @@ transCode(std::string const& token) return byToken; }(); - auto const r = kRESULTS.find(token); + auto const r = kResults.find(token); - if (r == kRESULTS.end()) + if (r == kResults.end()) return std::nullopt; return TER::fromInt(r->second); diff --git a/src/libxrpl/protocol/TxFormats.cpp b/src/libxrpl/protocol/TxFormats.cpp index 083889622c..b926bdf0e5 100644 --- a/src/libxrpl/protocol/TxFormats.cpp +++ b/src/libxrpl/protocol/TxFormats.cpp @@ -12,7 +12,7 @@ namespace xrpl { std::vector const& TxFormats::getCommonFields() { - static auto const kCOMMON_FIELDS = std::vector{ + static auto const kCommonFields = std::vector{ {sfTransactionType, SoeRequired}, {sfFlags, SoeOptional}, {sfSourceTag, SoeOptional}, @@ -31,7 +31,7 @@ TxFormats::getCommonFields() {sfNetworkID, SoeOptional}, {sfDelegate, SoeOptional}, }; - return kCOMMON_FIELDS; + return kCommonFields; } TxFormats::TxFormats() @@ -56,8 +56,8 @@ TxFormats::TxFormats() TxFormats const& TxFormats::getInstance() { - static TxFormats const kINSTANCE; - return kINSTANCE; + static TxFormats const kInstance; + return kInstance; } } // namespace xrpl diff --git a/src/libxrpl/protocol/UintTypes.cpp b/src/libxrpl/protocol/UintTypes.cpp index adef5e2c14..486c11ba45 100644 --- a/src/libxrpl/protocol/UintTypes.cpp +++ b/src/libxrpl/protocol/UintTypes.cpp @@ -18,41 +18,41 @@ namespace detail { // Characters we are willing to allow in the ASCII representation of a // three-letter currency code. -constexpr std::string_view kISO_CHAR_SET = +constexpr std::string_view kIsoCharSet = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789" "<>(){}[]|?!@#$%^&*"; // The location (in bytes) of the 3 digit currency inside a 160-bit value -constexpr std::size_t kISO_CODE_OFFSET = 12; +constexpr std::size_t kIsoCodeOffset = 12; // The length of an ISO-4217 like code -constexpr std::size_t kISO_CODE_LENGTH = 3; +constexpr std::size_t kIsoCodeLength = 3; } // namespace detail std::string to_string(Currency const& currency) { - if (currency == beast::kZERO) + if (currency == beast::kZero) return systemCurrencyCode(); if (currency == noCurrency()) return "1"; - static constexpr Currency kS_ISO_BITS("FFFFFFFFFFFFFFFFFFFFFFFF000000FFFFFFFFFF"); + static constexpr Currency kSIsoBits("FFFFFFFFFFFFFFFFFFFFFFFF000000FFFFFFFFFF"); - if ((currency & kS_ISO_BITS).isZero()) + if ((currency & kSIsoBits).isZero()) { std::string const iso( - currency.data() + detail::kISO_CODE_OFFSET, - currency.data() + detail::kISO_CODE_OFFSET + detail::kISO_CODE_LENGTH); + currency.data() + detail::kIsoCodeOffset, + currency.data() + detail::kIsoCodeOffset + detail::kIsoCodeLength); // Specifying the system currency code using ISO-style representation // is not allowed. if ((iso != systemCurrencyCode()) && - (iso.find_first_not_of(detail::kISO_CHAR_SET) == std::string::npos)) + (iso.find_first_not_of(detail::kIsoCharSet) == std::string::npos)) { return iso; } @@ -66,19 +66,19 @@ toCurrency(Currency& currency, std::string const& code) { if (code.empty() || (code.compare(systemCurrencyCode()) == 0)) { - currency = beast::kZERO; + currency = beast::kZero; return true; } // Handle ISO-4217-like 3-digit character codes. - if (code.size() == detail::kISO_CODE_LENGTH) + if (code.size() == detail::kIsoCodeLength) { - if (code.find_first_not_of(detail::kISO_CHAR_SET) != std::string::npos) + if (code.find_first_not_of(detail::kIsoCharSet) != std::string::npos) return false; - currency = beast::kZERO; + currency = beast::kZero; - std::ranges::copy(code, currency.begin() + detail::kISO_CODE_OFFSET); + std::ranges::copy(code, currency.begin() + detail::kIsoCodeOffset); return true; } @@ -98,22 +98,22 @@ toCurrency(std::string const& code) Currency const& xrpCurrency() { - static Currency const kCURRENCY(beast::kZERO); - return kCURRENCY; + static Currency const kCurrency(beast::kZero); + return kCurrency; } Currency const& noCurrency() { - static Currency const kCURRENCY(1); - return kCURRENCY; + static Currency const kCurrency(1); + return kCurrency; } Currency const& badCurrency() { - static Currency const kCURRENCY(0x5852500000000000); - return kCURRENCY; + static Currency const kCurrency(0x5852500000000000); + return kCurrency; } } // namespace xrpl diff --git a/src/libxrpl/protocol/XChainAttestations.cpp b/src/libxrpl/protocol/XChainAttestations.cpp index f89ad6a52c..805d08c097 100644 --- a/src/libxrpl/protocol/XChainAttestations.cpp +++ b/src/libxrpl/protocol/XChainAttestations.cpp @@ -195,7 +195,7 @@ AttestationClaim::message( std::uint64_t claimID, std::optional const& dst) { - STObject o{kSF_GENERIC}; + STObject o{sfGeneric}; // Serialize in SField order to make python serializers easier to write o[sfXChainClaimID] = claimID; o[sfAmount] = sendingAmount; @@ -332,7 +332,7 @@ AttestationCreateAccount::message( std::uint64_t createCount, AccountID const& dst) { - STObject o{kSF_GENERIC}; + STObject o{sfGeneric}; // Serialize in SField order to make python serializers easier to write o[sfXChainAccountCreateCount] = createCount; o[sfAmount] = sendingAmount; @@ -668,7 +668,7 @@ XChainAttestationsBase::XChainAttestationsBase(json::Value const& attestations_ = [&] { auto const jAtts = v[jss::attestations]; - if (jAtts.size() > kMAX_ATTESTATIONS) + if (jAtts.size() > kMaxAttestations) Throw("XChainAttestationsBase exceeded max number of attestations"); std::vector r; @@ -682,7 +682,7 @@ XChainAttestationsBase::XChainAttestationsBase(json::Value const& template XChainAttestationsBase::XChainAttestationsBase(STArray const& arr) { - if (arr.size() > kMAX_ATTESTATIONS) + if (arr.size() > kMaxAttestations) Throw("XChainAttestationsBase exceeded max number of attestations"); attestations_.reserve(arr.size()); diff --git a/src/libxrpl/protocol/tokens.cpp b/src/libxrpl/protocol/tokens.cpp index 91063d3fa6..a43cbd9c85 100644 --- a/src/libxrpl/protocol/tokens.cpp +++ b/src/libxrpl/protocol/tokens.cpp @@ -122,15 +122,15 @@ coefficients sizes greatly speeds up the multi-precision computations. namespace xrpl { -static constexpr char const* kALPHABET_FORWARD = +static constexpr char const* kAlphabetForward = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"; -static constexpr std::array const kALPHABET_REVERSE = []() { +static constexpr std::array const kAlphabetReverse = []() { std::array map{}; for (auto& m : map) m = -1; - for (int i = 0, j = 0; kALPHABET_FORWARD[i] != 0; ++i) - map[static_cast(kALPHABET_FORWARD[i])] = j++; + for (int i = 0, j = 0; kAlphabetForward[i] != 0; ++i) + map[static_cast(kAlphabetForward[i])] = j++; return map; }(); @@ -239,9 +239,9 @@ encodeBase58(void const* message, std::size_t size, void* temp, std::size_t temp // Translate the result into a string. std::string str; str.reserve(zeroes + (b58end - iter)); - str.assign(zeroes, kALPHABET_FORWARD[0]); + str.assign(zeroes, kAlphabetForward[0]); while (iter != b58end) - str += kALPHABET_FORWARD[*(iter++)]; + str += kAlphabetForward[*(iter++)]; return str; } @@ -252,7 +252,7 @@ decodeBase58(std::string const& s) auto remain = s.size(); // Skip and count leading zeroes int zeroes = 0; - while (remain > 0 && kALPHABET_REVERSE[*psz] == 0) + while (remain > 0 && kAlphabetReverse[*psz] == 0) { ++zeroes; ++psz; @@ -267,7 +267,7 @@ decodeBase58(std::string const& s) std::vector b256((remain * 733 / 1000) + 1); while (remain > 0) { - auto carry = kALPHABET_REVERSE[*psz]; + auto carry = kAlphabetReverse[*psz]; if (carry == -1) return {}; // Apply "b256 = b256 * 58 + carry". @@ -425,7 +425,7 @@ b256ToB58Be(std::span input, std::span out) // Translate the result into the alphabet // Put all the zeros at the beginning, then all the values from the output - std::fill(out.begin(), out.begin() + inputZeros, ::xrpl::kALPHABET_FORWARD[0]); + std::fill(out.begin(), out.begin() + inputZeros, ::xrpl::kAlphabetForward[0]); // iterate through the base 58^10 coeff // convert to base 58 big endian then @@ -458,7 +458,7 @@ b256ToB58Be(std::span input, std::span out) } for (auto b58Coeff : b58BeS.subspan(toSkip)) { - out[outIndex] = ::xrpl::kALPHABET_FORWARD[b58Coeff]; + out[outIndex] = ::xrpl::kAlphabetForward[b58Coeff]; outIndex += 1; } } @@ -487,7 +487,7 @@ b58ToB256Be(std::string_view input, std::span out) std::size_t count = 0; for (auto const& c : col) { - if (c != ::xrpl::kALPHABET_FORWARD[0]) + if (c != ::xrpl::kAlphabetForward[0]) { return count; } @@ -510,7 +510,7 @@ b58ToB256Be(std::string_view input, std::span out) "xrpl::b58_fast::detail::b58_to_b256_be : maximum coeff"); for (unsigned char const c : input.substr(0, partial_coeff_len)) { - auto curVal = ::xrpl::kALPHABET_REVERSE[c]; + auto curVal = ::xrpl::kAlphabetReverse[c]; if (curVal < 0) { return Unexpected(TokenCodecErrc::InvalidEncodingChar); @@ -523,7 +523,7 @@ b58ToB256Be(std::string_view input, std::span out) for (int j = 0; j < num_full_coeffs; ++j) { unsigned char const c = input[partial_coeff_len + (j * 10) + i]; - auto curVal = ::xrpl::kALPHABET_REVERSE[c]; + auto curVal = ::xrpl::kAlphabetReverse[c]; if (curVal < 0) { return Unexpected(TokenCodecErrc::InvalidEncodingChar); @@ -610,9 +610,9 @@ encodeBase58Token( std::span input, std::span out) { - constexpr std::size_t kTMP_BUF_SIZE = 128; - std::array buf{}; - if (input.size() > kTMP_BUF_SIZE - 5) + static constexpr std::size_t kTmpBufSize = 128; + std::array buf{}; + if (input.size() > kTmpBufSize - 5) { return Unexpected(TokenCodecErrc::InputTooLarge); } diff --git a/src/libxrpl/resource/Fees.cpp b/src/libxrpl/resource/Fees.cpp index 8c9b72987f..bb825fa3c7 100644 --- a/src/libxrpl/resource/Fees.cpp +++ b/src/libxrpl/resource/Fees.cpp @@ -4,24 +4,24 @@ namespace xrpl::Resource { -Charge const kFEE_MALFORMED_REQUEST(200, "malformed request"); -Charge const kFEE_REQUEST_NO_REPLY(10, "unsatisfiable request"); -Charge const kFEE_INVALID_SIGNATURE(2000, "invalid signature"); -Charge const kFEE_USELESS_DATA(150, "useless data"); -Charge const kFEE_INVALID_DATA(400, "invalid data"); +Charge const kFeeMalformedRequest(200, "malformed request"); +Charge const kFeeRequestNoReply(10, "unsatisfiable request"); +Charge const kFeeInvalidSignature(2000, "invalid signature"); +Charge const kFeeUselessData(150, "useless data"); +Charge const kFeeInvalidData(400, "invalid data"); -Charge const kFEE_MALFORMED_RPC(100, "malformed RPC"); -Charge const kFEE_REFERENCE_RPC(20, "reference RPC"); -Charge const kFEE_EXCEPTION_RPC(100, "exceptioned RPC"); -Charge const kFEE_MEDIUM_BURDEN_RPC(400, "medium RPC"); -Charge const kFEE_HEAVY_BURDEN_RPC(3000, "heavy RPC"); +Charge const kFeeMalformedRpc(100, "malformed RPC"); +Charge const kFeeReferenceRpc(20, "reference RPC"); +Charge const kFeeExceptionRpc(100, "exceptioned RPC"); +Charge const kFeeMediumBurdenRpc(400, "medium RPC"); +Charge const kFeeHeavyBurdenRpc(3000, "heavy RPC"); -Charge const kFEE_TRIVIAL_PEER(1, "trivial peer request"); -Charge const kFEE_MODERATE_BURDEN_PEER(250, "moderate peer request"); -Charge const kFEE_HEAVY_BURDEN_PEER(2000, "heavy peer request"); +Charge const kFeeTrivialPeer(1, "trivial peer request"); +Charge const kFeeModerateBurdenPeer(250, "moderate peer request"); +Charge const kFeeHeavyBurdenPeer(2000, "heavy peer request"); -Charge const kFEE_WARNING(4000, "received warning"); -Charge const kFEE_DROP(6000, "dropped"); +Charge const kFeeWarning(4000, "received warning"); +Charge const kFeeDrop(6000, "dropped"); // See also Resource::Logic::charge for log level cutoff values diff --git a/src/libxrpl/server/LoadFeeTrack.cpp b/src/libxrpl/server/LoadFeeTrack.cpp index 085e846145..31b2fa2558 100644 --- a/src/libxrpl/server/LoadFeeTrack.cpp +++ b/src/libxrpl/server/LoadFeeTrack.cpp @@ -27,9 +27,9 @@ LoadFeeTrack::raiseLocalFee() localTxnLoadFee_ = std::max(localTxnLoadFee_, remoteTxnLoadFee_); // Increase slowly - localTxnLoadFee_ += (localTxnLoadFee_ / kLFT_FEE_INC_FRACTION); + localTxnLoadFee_ += (localTxnLoadFee_ / kLftFeeIncFraction); - localTxnLoadFee_ = std::min(localTxnLoadFee_, kLFT_FEE_MAX); + localTxnLoadFee_ = std::min(localTxnLoadFee_, kLftFeeMax); if (origFee == localTxnLoadFee_) return false; @@ -46,9 +46,9 @@ LoadFeeTrack::lowerLocalFee() raiseCount_ = 0; // Reduce slowly - localTxnLoadFee_ -= (localTxnLoadFee_ / kLFT_FEE_DEC_FRACTION); + localTxnLoadFee_ -= (localTxnLoadFee_ / kLftFeeDecFraction); - localTxnLoadFee_ = std::max(localTxnLoadFee_, kLFT_NORMAL_FEE); + localTxnLoadFee_ = std::max(localTxnLoadFee_, kLftNormalFee); if (origFee == localTxnLoadFee_) return false; diff --git a/src/libxrpl/server/Manifest.cpp b/src/libxrpl/server/Manifest.cpp index fd38d02d6b..b26c67e531 100644 --- a/src/libxrpl/server/Manifest.cpp +++ b/src/libxrpl/server/Manifest.cpp @@ -62,7 +62,7 @@ deserializeManifest(Slice s, beast::Journal journal) if (s.empty()) return std::nullopt; - static SOTemplate const kMANIFEST_FORMAT{ + static SOTemplate const kManifestFormat{ // A manifest must include: // - the master public key {sfPublicKey, SoeRequired}, @@ -90,9 +90,9 @@ deserializeManifest(Slice s, beast::Journal journal) try { SerialIter sit{s}; - STObject st{sit, kSF_GENERIC}; + STObject st{sit, sfGeneric}; - st.applyTemplate(kMANIFEST_FORMAT); + st.applyTemplate(kManifestFormat); // We only understand "version 0" manifests at this time: if (st.isFieldPresent(sfVersion) && st.getFieldU16(sfVersion) != 0) @@ -193,7 +193,7 @@ logMftAct( bool Manifest::verify() const { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); SerialIter sit(serialized.data(), serialized.size()); st.set(sit); @@ -213,7 +213,7 @@ Manifest::verify() const uint256 Manifest::hash() const { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); SerialIter sit(serialized.data(), serialized.size()); st.set(sit); return st.getHash(HashPrefix::Manifest); @@ -240,7 +240,7 @@ Manifest::revoked(std::uint32_t sequence) std::optional Manifest::getSignature() const { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); SerialIter sit(serialized.data(), serialized.size()); st.set(sit); if (!get(st, sfSignature)) @@ -251,7 +251,7 @@ Manifest::getSignature() const Blob Manifest::getMasterSignature() const { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); SerialIter sit(serialized.data(), serialized.size()); st.set(sit); return st.getFieldVL(sfMasterSignature); diff --git a/src/libxrpl/server/Port.cpp b/src/libxrpl/server/Port.cpp index 228b65df43..00c10b2b55 100644 --- a/src/libxrpl/server/Port.cpp +++ b/src/libxrpl/server/Port.cpp @@ -44,30 +44,30 @@ operator<<(std::ostream& os, Port const& p) { os << "'" << p.name << "' (ip=" << p.ip << ":" << p.port << ", "; - if (!p.admin_nets_v4.empty() || !p.admin_nets_v6.empty()) + if (!p.adminNetsV4.empty() || !p.adminNetsV6.empty()) { os << "admin nets:"; - for (auto const& net : p.admin_nets_v4) + for (auto const& net : p.adminNetsV4) { os << net.to_string(); os << ", "; } - for (auto const& net : p.admin_nets_v6) + for (auto const& net : p.adminNetsV6) { os << net.to_string(); os << ", "; } } - if (!p.secure_gateway_nets_v4.empty() || !p.secure_gateway_nets_v6.empty()) + if (!p.secureGatewayNetsV4.empty() || !p.secureGatewayNetsV6.empty()) { - os << "secureGateway nets:"; - for (auto const& net : p.secure_gateway_nets_v4) + os << "secure_gateway nets:"; + for (auto const& net : p.secureGatewayNetsV4) { os << net.to_string(); os << ", "; } - for (auto const& net : p.secure_gateway_nets_v6) + for (auto const& net : p.secureGatewayNetsV6) { os << net.to_string(); os << ", "; @@ -265,10 +265,10 @@ parsePort(ParsedPort& port, Section const& section, std::ostream& log) { try { - port.ws_queue_limit = beast::lexicalCastThrow(*optResult); + port.wsQueueLimit = beast::lexicalCastThrow(*optResult); // Queue must be greater than 0 - if (port.ws_queue_limit == 0) + if (port.wsQueueLimit == 0) Throw(); } catch (std::exception const&) @@ -281,32 +281,31 @@ parsePort(ParsedPort& port, Section const& section, std::ostream& log) else { // Default Websocket send queue size limit - port.ws_queue_limit = 100; + port.wsQueueLimit = 100; } } - 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); + populate(section, "admin", log, port.adminNetsV4, port.adminNetsV6); + populate(section, "secure_gateway", log, port.secureGatewayNetsV4, port.secureGatewayNetsV6); set(port.user, "user", section); set(port.password, "password", section); - set(port.admin_user, "admin_user", section); - set(port.admin_password, "admin_password", section); - set(port.ssl_key, "ssl_key", section); - set(port.ssl_cert, "ssl_cert", section); - set(port.ssl_chain, "ssl_chain", section); - set(port.ssl_ciphers, "ssl_ciphers", section); + set(port.adminUser, "admin_user", section); + set(port.adminPassword, "admin_password", section); + set(port.sslKey, "ssl_key", section); + set(port.sslCert, "ssl_cert", section); + set(port.sslChain, "ssl_chain", section); + set(port.sslCiphers, "ssl_ciphers", section); - port.pmd_options.server_enable = section.valueOr("permessage_deflate", true); - port.pmd_options.client_max_window_bits = section.valueOr("client_max_window_bits", 15); - port.pmd_options.server_max_window_bits = section.valueOr("server_max_window_bits", 15); - port.pmd_options.client_no_context_takeover = + port.pmdOptions.server_enable = section.valueOr("permessage_deflate", true); + port.pmdOptions.client_max_window_bits = section.valueOr("client_max_window_bits", 15); + port.pmdOptions.server_max_window_bits = section.valueOr("server_max_window_bits", 15); + port.pmdOptions.client_no_context_takeover = section.valueOr("client_no_context_takeover", false); - port.pmd_options.server_no_context_takeover = + port.pmdOptions.server_no_context_takeover = section.valueOr("server_no_context_takeover", false); - port.pmd_options.compLevel = section.valueOr("compress_level", 8); - port.pmd_options.memLevel = section.valueOr("memory_level", 4); + port.pmdOptions.compLevel = section.valueOr("compress_level", 8); + port.pmdOptions.memLevel = section.valueOr("memory_level", 4); } } // namespace xrpl 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/Vacuum.cpp b/src/libxrpl/server/Vacuum.cpp index 140ef04def..63d40af156 100644 --- a/src/libxrpl/server/Vacuum.cpp +++ b/src/libxrpl/server/Vacuum.cpp @@ -20,7 +20,7 @@ namespace xrpl { bool doVacuumDB(DatabaseCon::Setup const& setup, beast::Journal j) { - boost::filesystem::path const dbPath = setup.dataDir / kTX_DB_NAME; + boost::filesystem::path const dbPath = setup.dataDir / kTxDbName; uintmax_t const dbSize = file_size(dbPath); XRPL_ASSERT(dbSize != static_cast(-1), "xrpl::doVacuumDB : file_size succeeded"); @@ -34,14 +34,14 @@ doVacuumDB(DatabaseCon::Setup const& setup, beast::Journal j) return false; } - auto txnDB = std::make_unique(setup, kTX_DB_NAME, setup.txPragma, kTX_DB_INIT, j); + auto txnDB = std::make_unique(setup, kTxDbName, setup.txPragma, kTxDbInit, j); auto& session = txnDB->getSession(); std::uint32_t pageSize = 0; // Only the most trivial databases will fit in memory on typical // (recommended) hardware. Force temp files to be written to disk // regardless of the config settings. - session << boost::format(kCOMMON_DB_PRAGMA_TEMP) % "file"; + session << boost::format(kCommonDbPragmaTemp) % "file"; session << "PRAGMA page_size;", soci::into(pageSize); std::cout << "VACUUM beginning. page_size: " << pageSize << std::endl; diff --git a/src/libxrpl/server/Wallet.cpp b/src/libxrpl/server/Wallet.cpp index ee579c7b9f..f3ae9dc925 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 @@ -40,7 +40,7 @@ makeWalletDB(DatabaseCon::Setup const& setup, beast::Journal j) { // wallet database return std::make_unique( - setup, kWALLET_DB_NAME, std::array(), kWALLET_DB_INIT, j); + setup, kWalletDbName, std::array(), kWalletDbInit, j); } std::unique_ptr @@ -48,7 +48,7 @@ makeTestWalletDB(DatabaseCon::Setup const& setup, std::string const& dbname, bea { // wallet database return std::make_unique( - setup, dbname.data(), std::array(), kWALLET_DB_INIT, j); + setup, dbname.data(), std::array(), kWalletDbInit, j); } void diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp index 795c097118..d3a7d49da6 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 {}; } @@ -352,7 +352,7 @@ SHAMap::descend( { XRPL_ASSERT(parent->isInner(), "xrpl::SHAMap::descend : valid parent input"); XRPL_ASSERT( - (branch >= 0) && (branch < kBRANCH_FACTOR), "xrpl::SHAMap::descend : valid branch input"); + (branch >= 0) && (branch < kBranchFactor), "xrpl::SHAMap::descend : valid branch input"); XRPL_ASSERT( !parent->isEmptyBranch(branch), "xrpl::SHAMap::descend : parent branch is non-empty"); @@ -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); @@ -443,7 +443,7 @@ SHAMap::belowHelper( if (node->isLeaf()) { auto n = intr_ptr::staticPointerCast(node); - stack.push({node, {kLEAF_DEPTH, n->peekItem()->key()}}); + stack.push({node, {kLeafDepth, n->peekItem()->key()}}); return n.get(); } auto inner = intr_ptr::staticPointerCast(node); @@ -464,7 +464,7 @@ SHAMap::belowHelper( if (node->isLeaf()) { auto n = intr_ptr::staticPointerCast(node); - stack.push({n, {kLEAF_DEPTH, n->peekItem()->key()}}); + stack.push({n, {kLeafDepth, n->peekItem()->key()}}); return n.get(); } inner = intr_ptr::staticPointerCast(node); @@ -482,7 +482,7 @@ SHAMapLeafNode* SHAMap::lastBelow(intr_ptr::SharedPtr node, SharedPtrNodeStack& stack, int branch) const { - auto init = kBRANCH_FACTOR - 1; + auto init = kBranchFactor - 1; auto cmp = [](int i) { return i >= 0; }; auto incr = [](int& i) { --i; }; @@ -493,12 +493,12 @@ SHAMap::firstBelow(intr_ptr::SharedPtr node, SharedPtrNodeStack& const { auto init = 0; - auto cmp = [](int i) { return i <= kBRANCH_FACTOR; }; + auto cmp = [](int i) { return i <= kBranchFactor; }; auto incr = [](int& i) { ++i; }; return belowHelper(node, stack, branch, {init, cmp, incr}); } -static boost::intrusive_ptr const kNO_ITEM; +static boost::intrusive_ptr const kNoItem; boost::intrusive_ptr const& SHAMap::onlyBelow(SHAMapTreeNode* node) const @@ -509,12 +509,12 @@ SHAMap::onlyBelow(SHAMapTreeNode* node) const { SHAMapTreeNode* nextNode = nullptr; auto inner = safeDowncast(node); - for (int i = 0; i < kBRANCH_FACTOR; ++i) + for (int i = 0; i < kBranchFactor; ++i) { if (!inner->isEmptyBranch(i)) { if (nextNode != nullptr) - return kNO_ITEM; + return kNoItem; nextNode = descendThrow(inner, i); } @@ -524,7 +524,7 @@ SHAMap::onlyBelow(SHAMapTreeNode* node) const { // LCOV_EXCL_START UNREACHABLE("xrpl::SHAMap::onlyBelow : no next node"); - return kNO_ITEM; + return kNoItem; // LCOV_EXCL_STOP } @@ -564,7 +564,7 @@ SHAMap::peekNextItem(uint256 const& id, SharedPtrNodeStack& stack) const auto [node, nodeID] = stack.top(); XRPL_ASSERT(!node->isLeaf(), "xrpl::SHAMap::peekNextItem : another node is not leaf"); auto inner = intr_ptr::staticPointerCast(node); - for (auto i = selectBranch(nodeID, id) + 1; i < kBRANCH_FACTOR; ++i) + for (auto i = selectBranch(nodeID, id) + 1; i < kBranchFactor; ++i) { if (!inner->isEmptyBranch(i)) { @@ -588,7 +588,7 @@ SHAMap::peekItem(uint256 const& id) const SHAMapLeafNode const* leaf = findKey(id); if (leaf == nullptr) - return kNO_ITEM; + return kNoItem; return leaf->peekItem(); } @@ -599,7 +599,7 @@ SHAMap::peekItem(uint256 const& id, SHAMapHash& hash) const SHAMapLeafNode const* leaf = findKey(id); if (leaf == nullptr) - return kNO_ITEM; + return kNoItem; hash = leaf->getHash(); return leaf->peekItem(); @@ -622,7 +622,7 @@ SHAMap::upperBound(uint256 const& id) const else { auto inner = intr_ptr::staticPointerCast(node); - for (auto branch = selectBranch(nodeID, id) + 1; branch < kBRANCH_FACTOR; ++branch) + for (auto branch = selectBranch(nodeID, id) + 1; branch < kBranchFactor; ++branch) { if (!inner->isEmptyBranch(branch)) { @@ -737,7 +737,7 @@ SHAMap::delItem(uint256 const& id) if (item) { - for (int i = 0; i < kBRANCH_FACTOR; ++i) + for (int i = 0; i < kBranchFactor; ++i) { if (!node->isEmptyBranch(i)) { @@ -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; } @@ -1027,7 +1027,7 @@ SHAMap::walkSubTree(bool doWrite, NodeObjectType t) // We can't flush an inner node until we flush its children while (true) { - while (pos < kBRANCH_FACTOR) + while (pos < kBranchFactor) { if (node->isEmptyBranch(pos)) { @@ -1131,7 +1131,7 @@ SHAMap::dump(bool hash) const if (node->isInner()) { auto inner = safeDowncast(node); - for (int i = 0; i < kBRANCH_FACTOR; ++i) + for (int i = 0; i < kBranchFactor; ++i) { if (!inner->isEmptyBranch(i)) { @@ -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..f31b75ad39 100644 --- a/src/libxrpl/shamap/SHAMapInnerNode.cpp +++ b/src/libxrpl/shamap/SHAMapInnerNode.cpp @@ -122,18 +122,18 @@ intr_ptr::SharedPtr SHAMapInnerNode::makeFullInner(Slice data, SHAMapHash const& hash, bool hashValid) { // A full inner node is serialized as 16 256-bit hashes, back to back: - if (data.size() != kBRANCH_FACTOR * uint256::kBYTES) + if (data.size() != kBranchFactor * uint256::kBytes) Throw("Invalid FI node"); - auto ret = intr_ptr::makeShared(0, kBRANCH_FACTOR); + auto ret = intr_ptr::makeShared(0, kBranchFactor); SerialIter si(data); auto hashes = ret->hashesAndChildren_.getHashes(); - for (int i = 0; i < kBRANCH_FACTOR; ++i) + for (int i = 0; i < kBranchFactor; ++i) { - hashes[i].asUint256() = si.getBitString<256>(); + hashes[i].asUInt256() = si.getBitString<256>(); if (hashes[i].isNonZero()) ret->isBranch_ |= (1 << i); @@ -158,14 +158,14 @@ SHAMapInnerNode::makeCompressedInner(Slice data) { // A compressed inner node is serialized as a series of 33 byte chunks, // representing a one byte "position" and a 256-bit hash: - constexpr std::size_t kCHUNK_SIZE = uint256::kBYTES + 1; + static constexpr std::size_t kChunkSize = uint256::kBytes + 1; - if (auto const s = data.size(); (s % kCHUNK_SIZE != 0) || (s > kCHUNK_SIZE * kBRANCH_FACTOR)) + if (auto const s = data.size(); (s % kChunkSize != 0) || (s > kChunkSize * kBranchFactor)) Throw("Invalid CI node"); SerialIter si(data); - auto ret = intr_ptr::makeShared(0, kBRANCH_FACTOR); + auto ret = intr_ptr::makeShared(0, kBranchFactor); auto hashes = ret->hashesAndChildren_.getHashes(); @@ -174,10 +174,10 @@ SHAMapInnerNode::makeCompressedInner(Slice data) auto const hash = si.getBitString<256>(); auto const pos = si.get8(); - if (pos >= kBRANCH_FACTOR) + if (pos >= kBranchFactor) Throw("invalid CI node"); - hashes[pos].asUint256() = hash; + hashes[pos].asUInt256() = hash; if (hashes[pos].isNonZero()) ret->isBranch_ |= (1 << pos); @@ -228,15 +228,15 @@ 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); + s.add8(kWireTypeCompressedInner); } else { - iterChildren([&](SHAMapHash const& hh) { s.addBitString(hh.asUint256()); }); - s.add8(kWIRE_TYPE_INNER); + iterChildren([&](SHAMapHash const& hh) { s.addBitString(hh.asUInt256()); }); + s.add8(kWireTypeInner); } } @@ -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 @@ -268,7 +268,7 @@ void SHAMapInnerNode::setChild(int m, intr_ptr::SharedPtr child) { XRPL_ASSERT( - (m >= 0) && (m < kBRANCH_FACTOR), "xrpl::SHAMapInnerNode::setChild : valid branch input"); + (m >= 0) && (m < kBranchFactor), "xrpl::SHAMapInnerNode::setChild : valid branch input"); XRPL_ASSERT(cowid_, "xrpl::SHAMapInnerNode::setChild : nonzero cowid"); XRPL_ASSERT(child.get() != this, "xrpl::SHAMapInnerNode::setChild : valid child input"); @@ -310,7 +310,7 @@ void SHAMapInnerNode::shareChild(int m, intr_ptr::SharedPtr const& child) { XRPL_ASSERT( - (m >= 0) && (m < kBRANCH_FACTOR), "xrpl::SHAMapInnerNode::shareChild : valid branch input"); + (m >= 0) && (m < kBranchFactor), "xrpl::SHAMapInnerNode::shareChild : valid branch input"); XRPL_ASSERT(cowid_, "xrpl::SHAMapInnerNode::shareChild : nonzero cowid"); XRPL_ASSERT(child, "xrpl::SHAMapInnerNode::shareChild : non-null child input"); XRPL_ASSERT(child.get() != this, "xrpl::SHAMapInnerNode::shareChild : valid child input"); @@ -324,7 +324,7 @@ SHAMapTreeNode* SHAMapInnerNode::getChildPointer(int branch) { XRPL_ASSERT( - branch >= 0 && branch < kBRANCH_FACTOR, + branch >= 0 && branch < kBranchFactor, "xrpl::SHAMapInnerNode::getChildPointer : valid branch input"); XRPL_ASSERT( !isEmptyBranch(branch), "xrpl::SHAMapInnerNode::getChildPointer : non-empty branch input"); @@ -341,7 +341,7 @@ intr_ptr::SharedPtr SHAMapInnerNode::getChild(int branch) { XRPL_ASSERT( - branch >= 0 && branch < kBRANCH_FACTOR, + branch >= 0 && branch < kBranchFactor, "xrpl::SHAMapInnerNode::getChild : valid branch input"); XRPL_ASSERT(!isEmptyBranch(branch), "xrpl::SHAMapInnerNode::getChild : non-empty branch input"); @@ -357,19 +357,19 @@ SHAMapHash const& SHAMapInnerNode::getChildHash(int m) const { XRPL_ASSERT( - (m >= 0) && (m < kBRANCH_FACTOR), + (m >= 0) && (m < kBranchFactor), "xrpl::SHAMapInnerNode::getChildHash : valid branch input"); if (auto const i = getChildIndex(m)) return hashesAndChildren_.getHashes()[*i]; - return kZERO_SHA_MAP_HASH; + return kZeroShaMapHash; } intr_ptr::SharedPtr SHAMapInnerNode::canonicalizeChild(int branch, intr_ptr::SharedPtr node) { XRPL_ASSERT( - branch >= 0 && branch < kBRANCH_FACTOR, + branch >= 0 && branch < kBranchFactor, "xrpl::SHAMapInnerNode::canonicalizeChild : valid branch input"); XRPL_ASSERT(node != nullptr, "xrpl::SHAMapInnerNode::canonicalizeChild : valid node input"); XRPL_ASSERT( @@ -405,7 +405,7 @@ SHAMapInnerNode::invariants(bool isRoot) const [[maybe_unused]] unsigned count = 0; auto [numAllocated, hashes, children] = hashesAndChildren_.getHashesAndChildren(); - if (numAllocated != kBRANCH_FACTOR) + if (numAllocated != kBranchFactor) { auto const branchCount = getBranchCount(); for (int i = 0; i < branchCount; ++i) @@ -420,7 +420,7 @@ SHAMapInnerNode::invariants(bool isRoot) const } else { - for (int i = 0; i < kBRANCH_FACTOR; ++i) + for (int i = 0; i < kBranchFactor; ++i) { if (hashes[i].isNonZero()) { diff --git a/src/libxrpl/shamap/SHAMapLeafNode.cpp b/src/libxrpl/shamap/SHAMapLeafNode.cpp index ce41a64e56..2fc23d6bb3 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() >= kMinShaMapItemBytes, "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() >= kMinShaMapItemBytes, "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..16aaafe709 100644 --- a/src/libxrpl/shamap/SHAMapNodeID.cpp +++ b/src/libxrpl/shamap/SHAMapNodeID.cpp @@ -16,37 +16,35 @@ 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 kMaskSize = 65; struct MasksT { - uint256 entry[MaskSize]; + uint256 entry[kMaskSize]; MasksT() { uint256 selector; - for (int i = 0; i < MaskSize - 1; i += 2) + for (int i = 0; i < kMaskSize - 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[kMaskSize - 1] = selector; } }; - static MasksT const kMASKS; - return kMASKS.entry[depth]; + static MasksT const kMasks; + return kMasks.entry[depth]; } // canonicalize the hash to a node ID for this depth SHAMapNodeID::SHAMapNodeID(unsigned int depth, uint256 const& hash) : id_(hash), depth_(depth) { XRPL_ASSERT( - depth <= SHAMap::kLEAF_DEPTH, "xrpl::SHAMapNodeID::SHAMapNodeID : maximum depth input"); + depth <= SHAMap::kLeafDepth, "xrpl::SHAMapNodeID::SHAMapNodeID : maximum depth input"); XRPL_ASSERT( id_ == (id_ & depthMask(depth)), "xrpl::SHAMapNodeID::SHAMapNodeID : hash and depth inputs do match"); @@ -65,7 +63,7 @@ SHAMapNodeID SHAMapNodeID::getChildNodeID(unsigned int m) const { XRPL_ASSERT( - m < SHAMap::kBRANCH_FACTOR, "xrpl::SHAMapNodeID::getChildNodeID : valid branch input"); + m < SHAMap::kBranchFactor, "xrpl::SHAMapNodeID::getChildNodeID : valid branch input"); // A SHAMap has exactly 65 levels, so nodes must not exceed that // depth; if they do, this breaks the invariant of never allowing @@ -76,9 +74,9 @@ SHAMapNodeID::getChildNodeID(unsigned int m) const // entries at that depth are leaf nodes and have no children and even // constructing a child node from them would break the above invariant. XRPL_ASSERT( - depth_ <= SHAMap::kLEAF_DEPTH, "xrpl::SHAMapNodeID::getChildNodeID : maximum leaf depth"); + depth_ <= SHAMap::kLeafDepth, "xrpl::SHAMapNodeID::getChildNodeID : maximum leaf depth"); - if (depth_ >= SHAMap::kLEAF_DEPTH) + if (depth_ >= SHAMap::kLeafDepth) Throw("Request for child node ID of " + to_string(*this)); if (id_ != (id_ & depthMask(depth_))) @@ -97,7 +95,7 @@ deserializeSHAMapNodeID(void const* data, std::size_t size) if (size == 33) { unsigned int const depth = *(static_cast(data) + 32); - if (depth <= SHAMap::kLEAF_DEPTH) + if (depth <= SHAMap::kLeafDepth) { auto const id = uint256::fromVoid(data); @@ -124,7 +122,7 @@ selectBranch(SHAMapNodeID const& id, uint256 const& hash) branch >>= 4; } - XRPL_ASSERT(branch < SHAMap::kBRANCH_FACTOR, "xrpl::selectBranch : maximum result"); + XRPL_ASSERT(branch < SHAMap::kBranchFactor, "xrpl::selectBranch : maximum result"); return branch; } diff --git a/src/libxrpl/shamap/SHAMapSync.cpp b/src/libxrpl/shamap/SHAMapSync.cpp index 348928f863..cd2654c603 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(); } @@ -615,8 +615,8 @@ SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncF // Inner nodes must be at a level strictly less than 64 // but leaf nodes (while notionally at level 64) can be // at any depth up to and including 64: - if ((currNodeID.getDepth() > kLEAF_DEPTH) || - (newNode->isInner() && currNodeID.getDepth() == kLEAF_DEPTH)) + if ((currNodeID.getDepth() > kLeafDepth) || + (newNode->isInner() && currNodeID.getDepth() == kLeafDepth)) { // Map is provably invalid state_ = SHAMapState::Invalid; diff --git a/src/libxrpl/shamap/SHAMapTreeNode.cpp b/src/libxrpl/shamap/SHAMapTreeNode.cpp index ac405f3286..3b8d976c69 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() < kMinShaMapItemBytes) + { + Throw( + "Short TXN node: " + std::to_string(data.size()) + " bytes (minimum " + + std::to_string(kMinShaMapItemBytes) + " required)"); + } + auto item = makeShamapitem(sha512Half(HashPrefix::TransactionId, data), data); if (hashValid) @@ -43,14 +50,30 @@ SHAMapTreeNode::makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool uint256 tag; - if (s.size() < tag.kBYTES) - Throw("Short TXN+MD node"); + if (s.size() < tag.kBytes) + { + 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()) + ")"); + if (!s.getBitString(tag, s.size() - tag.kBytes)) + { + Throw( + "Short TXN+MD node: failed to read tag at offset " + + std::to_string(s.size() - tag.kBytes)); + } - s.chop(tag.kBYTES); + s.chop(tag.kBytes); + + if (s.size() < kMinShaMapItemBytes) + { + Throw( + "Short TXN+MD node: " + std::to_string(s.size()) + + " bytes after tag removal (minimum " + std::to_string(kMinShaMapItemBytes) + + " required)"); + } auto item = makeShamapitem(tag, s.slice()); @@ -67,18 +90,32 @@ SHAMapTreeNode::makeAccountState(Slice data, SHAMapHash const& hash, bool hashVa uint256 tag; - if (s.size() < tag.kBYTES) - Throw("short AS node"); + if (s.size() < tag.kBytes) + { + 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()) + ")"); + if (!s.getBitString(tag, s.size() - tag.kBytes)) + { + Throw( + "Short AS node: failed to read tag at offset " + std::to_string(s.size() - tag.kBytes)); + } - s.chop(tag.kBYTES); + s.chop(tag.kBytes); if (tag.isZero()) Throw("Invalid AS node"); + if (s.size() < kMinShaMapItemBytes) + { + Throw( + "Short AS node: " + std::to_string(s.size()) + " bytes after tag removal (minimum " + + std::to_string(kMinShaMapItemBytes) + " required)"); + } + auto item = makeShamapitem(tag, s.slice()); if (hashValid) @@ -100,19 +137,19 @@ SHAMapTreeNode::makeFromWire(Slice rawNode) bool const hashValid = false; SHAMapHash const hash; - if (type == kWIRE_TYPE_TRANSACTION) + if (type == kWireTypeTransaction) return makeTransaction(rawNode, hash, hashValid); - if (type == kWIRE_TYPE_ACCOUNT_STATE) + if (type == kWireTypeAccountState) return makeAccountState(rawNode, hash, hashValid); - if (type == kWIRE_TYPE_INNER) + if (type == kWireTypeInner) return SHAMapInnerNode::makeFullInner(rawNode, hash, hashValid); - if (type == kWIRE_TYPE_COMPRESSED_INNER) + if (type == kWireTypeCompressedInner) return SHAMapInnerNode::makeCompressedInner(rawNode); - if (type == kWIRE_TYPE_TRANSACTION_WITH_META) + if (type == kWireTypeTransactionWithMeta) return makeTransactionWithMeta(rawNode, hash, hashValid); Throw("wire: Unknown type (" + std::to_string(type) + ")"); 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/SignerEntries.cpp b/src/libxrpl/tx/SignerEntries.cpp index d425c86ca6..7251b8260f 100644 --- a/src/libxrpl/tx/SignerEntries.cpp +++ b/src/libxrpl/tx/SignerEntries.cpp @@ -28,7 +28,7 @@ SignerEntries::deserialize(STObject const& obj, beast::Journal journal, std::str } std::vector accountVec; - accountVec.reserve(STTx::kMAX_MULTI_SIGNERS); + accountVec.reserve(STTx::kMaxMultiSigners); STArray const& sEntries(obj.getFieldArray(sfSignerEntries)); for (STObject const& sEntry : sEntries) diff --git a/src/libxrpl/tx/Transactor.cpp b/src/libxrpl/tx/Transactor.cpp index 6f3dfd6f66..68a420f3e6 100644 --- a/src/libxrpl/tx/Transactor.cpp +++ b/src/libxrpl/tx/Transactor.cpp @@ -26,6 +26,7 @@ #include #include #include +#include #include #include #include // IWYU pragma: keep @@ -88,7 +89,7 @@ preflight0(PreflightContext const& ctx, std::uint32_t flagMask) auto const txID = ctx.tx.getTransactionID(); - if (txID == beast::kZERO) + if (txID == beast::kZero) { JLOG(ctx.j.warn()) << "applyTransaction: transaction id may not be zero"; return temINVALID; @@ -181,7 +182,7 @@ Transactor::preflight1(PreflightContext const& ctx, std::uint32_t flagMask) return ret; auto const id = ctx.tx.getAccountID(sfAccount); - if (id == beast::kZERO) + if (id == beast::kZero) { JLOG(ctx.j.warn()) << "preflight1: bad account id"; return temBAD_SRC_ACCOUNT; @@ -255,13 +256,22 @@ Transactor::preflight2(PreflightContext const& ctx) return tesSUCCESS; } +NotTEC +Transactor::preflightUniversal(PreflightContext const& ctx) +{ + if (ctx.rules.enabled(fixCleanup3_2_0) && hasInvalidAmount(ctx.tx, ctx.j)) + return temBAD_AMOUNT; + + return tesSUCCESS; +} + //------------------------------------------------------------------------------ Transactor::Transactor(ApplyContext& ctx) : ctx_(ctx) , sink_(ctx.journal, toShortString(ctx.tx.getTransactionID()) + " ") , j_(sink_) - , account_(ctx.tx.getAccountID(sfAccount)) + , accountID_(ctx.tx.getAccountID(sfAccount)) { } @@ -360,14 +370,14 @@ Transactor::checkFee(PreclaimContext const& ctx, XRPAmount baseFee) if ((ctx.flags & TapBatch) != 0u) { - if (feePaid == beast::kZERO) + if (feePaid == beast::kZero) return tesSUCCESS; JLOG(ctx.j.trace()) << "Batch: Fee must be zero."; return temBAD_FEE; // LCOV_EXCL_LINE } - if (!isLegalAmount(feePaid) || feePaid < beast::kZERO) + if (!isLegalAmount(feePaid) || feePaid < beast::kZero) return temBAD_FEE; // Only check fee is sufficient when the ledger is open. @@ -383,7 +393,7 @@ Transactor::checkFee(PreclaimContext const& ctx, XRPAmount baseFee) } } - if (feePaid == beast::kZERO) + if (feePaid == beast::kZero) return tesSUCCESS; auto const id = ctx.tx.getFeePayer(); @@ -405,7 +415,7 @@ Transactor::checkFee(PreclaimContext const& ctx, XRPAmount baseFee) JLOG(ctx.j.trace()) << "Insufficient balance:" << " balance=" << to_string(balance) << " paid=" << to_string(feePaid); - if ((balance > beast::kZERO) && !ctx.view.open()) + if ((balance > beast::kZero) && !ctx.view.open()) { // Closed ledger, non-zero balance, less than fee return tecINSUFF_FEE; @@ -430,7 +440,7 @@ Transactor::payFee() // Deduct the fee, so it's not available during the transaction. // Will only write the account back if the transaction succeeds. sle->setFieldAmount(sfBalance, sle->getFieldAmount(sfBalance) - feePaid); - if (feePayer != account_) + if (feePayer != accountID_) view().update(sle); // done in `apply()` for the account // VFALCO Should we call view().rawDestroyXRP() here as well? @@ -491,7 +501,7 @@ Transactor::checkSeqProxy(ReadView const& view, STTx const& tx, beast::Journal j } // Transaction can never succeed if the Ticket is not in the ledger. - if (!view.exists(keylet::kTICKET(id, tSeqProx))) + if (!view.exists(keylet::kTicket(id, tSeqProx))) { JLOG(j.trace()) << "applyTransaction: ticket already used or never created " << "a_seq=" << aSeq << " t_seq=" << tSeqProx; @@ -543,7 +553,7 @@ Transactor::consumeSeqProxy(SLE::pointer const& sleAccount) sleAccount->setFieldU32(sfSequence, seqProx.value() + 1); return tesSUCCESS; } - return ticketDelete(view(), account_, getTicketIndex(account_, seqProx), j_); + return ticketDelete(view(), accountID_, getTicketIndex(accountID_, seqProx), j_); } // Remove a single Ticket from the ledger. @@ -556,7 +566,7 @@ Transactor::ticketDelete( { // Delete the Ticket, adjust the account root ticket count, and // reduce the owner count. - SLE::pointer const sleTicket = view.peek(keylet::kTICKET(ticketIndex)); + SLE::pointer const sleTicket = view.peek(keylet::kTicket(ticketIndex)); if (!sleTicket) { // LCOV_EXCL_START @@ -616,7 +626,7 @@ Transactor::ticketDelete( void Transactor::preCompute() { - XRPL_ASSERT(account_ != beast::kZERO, "xrpl::Transactor::preCompute : nonzero account"); + XRPL_ASSERT(accountID_ != beast::kZero, "xrpl::Transactor::preCompute : nonzero account"); } TER @@ -626,12 +636,12 @@ Transactor::apply() // If the transactor requires a valid account and the transaction doesn't // list one, preflight will have already a flagged a failure. - auto const sle = view().peek(keylet::account(account_)); + auto const sle = view().peek(keylet::account(accountID_)); // sle must exist except for transactions // that allow zero account. XRPL_ASSERT( - sle != nullptr || account_ == beast::kZERO, + sle != nullptr || accountID_ == beast::kZero, "xrpl::Transactor::apply : non-null SLE or zero account"); if (sle) @@ -978,7 +988,7 @@ removeUnfundedOffers(ApplyView& view, std::vector const& offers, beast: { // offer is unfunded offerDelete(view, sleOffer, viewJ); - if (++removed == kUNFUNDED_OFFER_REMOVE_LIMIT) + if (++removed == kUnfundedOfferRemoveLimit) return; } } @@ -997,7 +1007,7 @@ removeExpiredNFTokenOffers( if (auto const offer = view.peek(keylet::nftoffer(index))) { nft::deleteTokenOffer(view, offer); - if (++removed == kEXPIRED_OFFER_REMOVE_LIMIT) + if (++removed == kExpiredOfferRemoveLimit) return; } } @@ -1009,7 +1019,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); + } + } } } @@ -1019,7 +1036,7 @@ removeDeletedTrustLines( std::vector const& trustLines, beast::Journal viewJ) { - if (trustLines.size() > kMAX_DELETABLE_AMM_TRUST_LINES) + if (trustLines.size() > kMaxDeletableAmmTrustLines) { JLOG(viewJ.error()) << "removeDeletedTrustLines: deleted trustlines exceed max " << trustLines.size(); @@ -1071,17 +1088,17 @@ Transactor::reset(XRPAmount fee) // The account should never be missing from the ledger. But if it // is missing then we can't very well charge it a fee, can we? if (!txnAcct) - return {tefINTERNAL, beast::kZERO}; + return {tefINTERNAL, beast::kZero}; auto const payerSle = view().peek(keylet::account(ctx_.tx.getFeePayer())); if (!payerSle) - return {tefINTERNAL, beast::kZERO}; // LCOV_EXCL_LINE + return {tefINTERNAL, beast::kZero}; // LCOV_EXCL_LINE auto const balance = payerSle->getFieldAmount(sfBalance).xrp(); // balance should have already been checked in checkFee / preFlight. XRPL_ASSERT( - balance != beast::kZERO && (!view().open() || balance >= fee), + balance != beast::kZero && (!view().open() || balance >= fee), "xrpl::Transactor::reset : valid balance"); // We retry/reject the transaction if the account balance is zero or @@ -1134,7 +1151,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; } } @@ -1144,7 +1161,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; } @@ -1195,8 +1212,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 } @@ -1223,12 +1240,12 @@ Transactor::operator()() bool applied = isTesSuccess(result); auto fee = ctx_.tx.getFieldAmount(sfFee).xrp(); - if (ctx_.size() > kOVERSIZE_META_DATA_CAP) + if (ctx_.size() > kOversizeMetaDataCap) result = tecOVERSIZE; if (isTecClaim(result) && ((view().flags() & TapFailHard) != 0u)) { - // If the tapFAIL_HARD flag is set, a tec result + // If the TapFailHard flag is set, a tec result // must not do anything ctx_.discard(); applied = false; @@ -1378,14 +1395,14 @@ Transactor::operator()() // The transactor and invariant checkers guarantee that this will // *never* trigger but if it, somehow, happens, don't allow a tx // that charges a negative fee. - if (fee < beast::kZERO) + if (fee < beast::kZero) Throw("fee charged is negative!"); // Charge whatever fee they specified. The fee has already been // deducted from the balance of the account that issued the // transaction. We just need to account for it in the ledger // header. - if (!view().open() && fee != beast::kZERO) + if (!view().open() && fee != beast::kZero) ctx_.destroyXRP(fee); // Once we call apply, we will no longer be able to look at view() diff --git a/src/libxrpl/tx/apply.cpp b/src/libxrpl/tx/apply.cpp index 3655b37c71..b70cb0d345 100644 --- a/src/libxrpl/tx/apply.cpp +++ b/src/libxrpl/tx/apply.cpp @@ -26,10 +26,10 @@ namespace xrpl { // These are the same flags defined as HashRouterFlags::PRIVATE1-4 in // HashRouter.h -constexpr HashRouterFlags kSF_SIGBAD = HashRouterFlags::PRIVATE1; // Signature is bad -constexpr HashRouterFlags kSF_SIGGOOD = HashRouterFlags::PRIVATE2; // Signature is good -constexpr HashRouterFlags kSF_LOCALBAD = HashRouterFlags::PRIVATE3; // Local checks failed -constexpr HashRouterFlags kSF_LOCALGOOD = HashRouterFlags::PRIVATE4; // Local checks passed +constexpr HashRouterFlags kSfSigbad = HashRouterFlags::PRIVATE1; // Signature is bad +constexpr HashRouterFlags kSfSiggood = HashRouterFlags::PRIVATE2; // Signature is good +constexpr HashRouterFlags kSfLocalbad = HashRouterFlags::PRIVATE3; // Local checks failed +constexpr HashRouterFlags kSfLocalgood = HashRouterFlags::PRIVATE4; // Local checks passed //------------------------------------------------------------------------------ @@ -56,41 +56,41 @@ checkValidity(HashRouter& router, STTx const& tx, Rules const& rules) std::string reason; if (!passesLocalChecks(tx, reason)) { - router.setFlags(id, kSF_LOCALBAD); + router.setFlags(id, kSfLocalbad); return {Validity::SigGoodOnly, reason}; } - router.setFlags(id, kSF_SIGGOOD); + router.setFlags(id, kSfSiggood); return {Validity::Valid, ""}; } } - if (any(flags & kSF_SIGBAD)) + if (any(flags & kSfSigbad)) { // Signature is known bad return {Validity::SigBad, "Transaction has bad signature."}; } - if (!any(flags & kSF_SIGGOOD)) + if (!any(flags & kSfSiggood)) { auto const sigVerify = tx.checkSign(rules); if (!sigVerify) { - router.setFlags(id, kSF_SIGBAD); + router.setFlags(id, kSfSigbad); return {Validity::SigBad, sigVerify.error()}; } - router.setFlags(id, kSF_SIGGOOD); + router.setFlags(id, kSfSiggood); } // Signature is now known good - if (any(flags & kSF_LOCALBAD)) + if (any(flags & kSfLocalbad)) { // ...but the local checks // are known bad. return {Validity::SigGoodOnly, "Local checks failed."}; } - if (any(flags & kSF_LOCALGOOD)) + if (any(flags & kSfLocalgood)) { // ...and the local checks // are known good. @@ -101,10 +101,10 @@ checkValidity(HashRouter& router, STTx const& tx, Rules const& rules) std::string reason; if (!passesLocalChecks(tx, reason)) { - router.setFlags(id, kSF_LOCALBAD); + router.setFlags(id, kSfLocalbad); return {Validity::SigGoodOnly, reason}; } - router.setFlags(id, kSF_LOCALGOOD); + router.setFlags(id, kSfLocalgood); return {Validity::Valid, ""}; } @@ -115,10 +115,10 @@ forceValidity(HashRouter& router, uint256 const& txid, Validity validity) switch (validity) { case Validity::Valid: - flags |= kSF_LOCALGOOD; + flags |= kSfLocalgood; [[fallthrough]]; case Validity::SigGoodOnly: - flags |= kSF_SIGGOOD; + flags |= kSfSiggood; [[fallthrough]]; case Validity::SigBad: // would be silly to call directly @@ -171,7 +171,7 @@ applyBatchTransactions( auto const mode = batchTxn.getFlags(); auto applyOneTransaction = [®istry, &j, &parentBatchId, &batchView](STTx const& tx) { - OpenView perTxBatchView(kBATCH_VIEW, batchView); + OpenView perTxBatchView(kBatchView, batchView); auto const ret = apply(registry, perTxBatchView, parentBatchId, tx, TapBatch, j); XRPL_ASSERT( @@ -245,7 +245,7 @@ applyTransaction( // its inner transactions as necessary. if (isTesSuccess(result.ter) && txn.getTxnType() == ttBATCH) { - OpenView wholeBatchView(kBATCH_VIEW, view); + OpenView wholeBatchView(kBatchView, view); if (applyBatchTransactions(registry, wholeBatchView, txn, j)) wholeBatchView.apply(view); diff --git a/src/libxrpl/tx/applySteps.cpp b/src/libxrpl/tx/applySteps.cpp index 77ffadee05..12a4d4592f 100644 --- a/src/libxrpl/tx/applySteps.cpp +++ b/src/libxrpl/tx/applySteps.cpp @@ -102,36 +102,36 @@ withTxnType(Rules const& rules, TxType txnType, F&& f) } } // namespace -// Templates so preflight does the right thing with T::kCONSEQUENCES_FACTORY. +// Templates so preflight does the right thing with T::kConsequencesFactory. // // This could be done more easily using if constexpr, but Visual Studio // 2017 doesn't handle if constexpr correctly. So once we're no longer // 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::kConsequencesFactory == 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::kConsequencesFactory == 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::kConsequencesFactory == Transactor::ConsequencesFactoryType::Custom) TxConsequences consequencesHelper(PreflightContext const& ctx) { @@ -154,7 +154,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 } @@ -182,7 +182,7 @@ invokePreclaim(PreclaimContext const& ctx) // a flagged a failure. auto const id = ctx.tx.getAccountID(sfAccount); - if (id != beast::kZERO) + if (id != beast::kZero) { if (NotTEC const preSigResult = [&]() -> NotTEC { if (NotTEC const result = T::checkSeqProxy(ctx.view, ctx.tx, ctx.j)) @@ -213,7 +213,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 } @@ -255,8 +255,8 @@ invokeCalculateBaseFee(ReadView const& view, STTx const& tx) TxConsequences::TxConsequences(NotTEC pfResult) : isBlocker_(false) - , fee_(beast::kZERO) - , potentialSpend_(beast::kZERO) + , fee_(beast::kZero) + , potentialSpend_(beast::kZero) , seqProx_(SeqProxy::sequence(0)) , sequencesConsumed_(0) { @@ -266,8 +266,8 @@ TxConsequences::TxConsequences(NotTEC pfResult) TxConsequences::TxConsequences(STTx const& tx) : isBlocker_(false) - , fee_(tx[sfFee].native() && !tx[sfFee].negative() ? tx[sfFee].xrp() : beast::kZERO) - , potentialSpend_(beast::kZERO) + , fee_(tx[sfFee].native() && !tx[sfFee].negative() ? tx[sfFee].xrp() : beast::kZero) + , potentialSpend_(beast::kZero) , seqProx_(tx.getSeqProxy()) , sequencesConsumed_(tx.getSeqProxy().isSeq() ? 1 : 0) { @@ -303,7 +303,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/AMMInvariant.cpp b/src/libxrpl/tx/invariants/AMMInvariant.cpp index 6469799eb6..be2a803e93 100644 --- a/src/libxrpl/tx/invariants/AMMInvariant.cpp +++ b/src/libxrpl/tx/invariants/AMMInvariant.cpp @@ -44,8 +44,9 @@ ValidAMM::visitEntry( } // AMM pool changed else if ( - (type == ltRIPPLE_STATE && ((after->getFlags() & lsfAMMNode) != 0u)) || - (type == ltACCOUNT_ROOT && after->isFieldPresent(sfAMMID))) + (type == ltRIPPLE_STATE && after->isFlag(lsfAMMNode)) || + (type == ltACCOUNT_ROOT && after->isFieldPresent(sfAMMID)) || + (type == ltMPTOKEN && after->isFlag(lsfMPTAMM))) { ammPoolChanged_ = true; } @@ -69,11 +70,11 @@ validBalances( ValidAMM::ZeroAllowed zeroAllowed) { bool const positive = - amount > beast::kZERO && amount2 > beast::kZERO && lptAMMBalance > beast::kZERO; + amount > beast::kZero && amount2 > beast::kZero && lptAMMBalance > beast::kZero; if (zeroAllowed == ValidAMM::ZeroAllowed::Yes) { return positive || - (amount == beast::kZERO && amount2 == beast::kZERO && lptAMMBalance == beast::kZERO); + (amount == beast::kZero && amount2 == beast::kZero && lptAMMBalance == beast::kZero); } return positive; } @@ -85,9 +86,9 @@ ValidAMM::finalizeVote(bool enforce, beast::Journal const& j) const { // LPTokens and the pool can not change on vote // LCOV_EXCL_START - JLOG(j.error()) << "AMMVote invariant failed: " << lptAMMBalanceBefore_.value_or(STAmount{}) - << " " << lptAMMBalanceAfter_.value_or(STAmount{}) << " " - << ammPoolChanged_; + JLOG(j.error()) << "Invariant failed: AMMVote failed, " + << lptAMMBalanceBefore_.value_or(STAmount{}) << " " + << lptAMMBalanceAfter_.value_or(STAmount{}) << " " << ammPoolChanged_; if (enforce) return false; // LCOV_EXCL_STOP @@ -103,7 +104,7 @@ ValidAMM::finalizeBid(bool enforce, beast::Journal const& j) const { // The pool can not change on bid // LCOV_EXCL_START - JLOG(j.error()) << "AMMBid invariant failed: pool changed"; + JLOG(j.error()) << "Invariant failed: AMMBid failed, pool changed"; if (enforce) return false; // LCOV_EXCL_STOP @@ -111,10 +112,10 @@ ValidAMM::finalizeBid(bool enforce, beast::Journal const& j) const // LPTokens are burnt, therefore there should be fewer LPTokens else if ( lptAMMBalanceBefore_ && lptAMMBalanceAfter_ && - (*lptAMMBalanceAfter_ > *lptAMMBalanceBefore_ || *lptAMMBalanceAfter_ <= beast::kZERO)) + (*lptAMMBalanceAfter_ > *lptAMMBalanceBefore_ || *lptAMMBalanceAfter_ <= beast::kZero)) { // LCOV_EXCL_START - JLOG(j.error()) << "AMMBid invariant failed: " << *lptAMMBalanceBefore_ << " " + JLOG(j.error()) << "Invariant failed: AMMBid failed, " << *lptAMMBalanceBefore_ << " " << *lptAMMBalanceAfter_; if (enforce) return false; @@ -134,7 +135,7 @@ ValidAMM::finalizeCreate( if (!ammAccount_) { // LCOV_EXCL_START - JLOG(j.error()) << "AMMCreate invariant failed: AMM object is not created"; + JLOG(j.error()) << "Invariant failed: AMMCreate failed, AMM object is not created"; if (enforce) return false; // LCOV_EXCL_STOP @@ -157,8 +158,8 @@ ValidAMM::finalizeCreate( if (!validBalances(amount, amount2, *lptAMMBalanceAfter_, ZeroAllowed::No) || ammLPTokens(amount, amount2, lptAMMBalanceAfter_->get()) != *lptAMMBalanceAfter_) { - JLOG(j.error()) << "AMMCreate invariant failed: " << amount << " " << amount2 << " " - << *lptAMMBalanceAfter_; + JLOG(j.error()) << "Invariant failed: AMMCreate failed, " << amount << " " << amount2 + << " " << *lptAMMBalanceAfter_; if (enforce) return false; } @@ -176,7 +177,7 @@ ValidAMM::finalizeDelete(bool enforce, TER res, beast::Journal const& j) const // LCOV_EXCL_START std::string const msg = (isTesSuccess(res)) ? "AMM object is not deleted on tesSUCCESS" : "AMM object is changed on tecINCOMPLETE"; - JLOG(j.error()) << "AMMDelete invariant failed: " << msg; + JLOG(j.error()) << "Invariant failed: AMMDelete failed, " << msg; if (enforce) return false; // LCOV_EXCL_STOP @@ -191,7 +192,7 @@ ValidAMM::finalizeDEX(bool enforce, beast::Journal const& j) const if (ammAccount_) { // LCOV_EXCL_START - JLOG(j.error()) << "AMM swap invariant failed: AMM object changed"; + JLOG(j.error()) << "Invariant failed: AMM swap failed, AMM object changed"; if (enforce) return false; // LCOV_EXCL_STOP @@ -227,16 +228,16 @@ ValidAMM::generalInvariant( bool const strongInvariantCheck = poolProductMean >= *lptAMMBalanceAfter_; // Allow for a small relative error if strongInvariantCheck fails auto weakInvariantCheck = [&]() { - return *lptAMMBalanceAfter_ != beast::kZERO && + return *lptAMMBalanceAfter_ != beast::kZero && withinRelativeDistance(poolProductMean, Number{*lptAMMBalanceAfter_}, Number{1, -11}); }; if (!nonNegativeBalances || (!strongInvariantCheck && !weakInvariantCheck())) { - JLOG(j.error()) << "AMM " << tx.getTxnType() - << " invariant failed: " << tx.getHash(HashPrefix::TransactionId) << " " - << ammPoolChanged_ << " " << amount << " " << amount2 << " " - << poolProductMean << " " << lptAMMBalanceAfter_->getText() << " " - << ((*lptAMMBalanceAfter_ == beast::kZERO) + JLOG(j.error()) << "Invariant failed: AMM " << tx.getTxnType() << " " + << tx.getHash(HashPrefix::TransactionId) << " " << ammPoolChanged_ << " " + << amount << " " << amount2 << " " << poolProductMean << " " + << lptAMMBalanceAfter_->getText() << " " + << ((*lptAMMBalanceAfter_ == beast::kZero) ? Number{1} : ((*lptAMMBalanceAfter_ - poolProductMean) / poolProductMean)); return false; @@ -256,7 +257,7 @@ ValidAMM::finalizeDeposit( if (!ammAccount_) { // LCOV_EXCL_START - JLOG(j.error()) << "AMMDeposit invariant failed: AMM object is deleted"; + JLOG(j.error()) << "Invariant failed: AMMDeposit failed, AMM object is deleted"; if (enforce) return false; // LCOV_EXCL_STOP diff --git a/src/libxrpl/tx/invariants/DirectoryInvariant.cpp b/src/libxrpl/tx/invariants/DirectoryInvariant.cpp new file mode 100644 index 0000000000..1624a19830 --- /dev/null +++ b/src/libxrpl/tx/invariants/DirectoryInvariant.cpp @@ -0,0 +1,104 @@ +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace xrpl { + +namespace { + +[[nodiscard]] bool +isRootBookDirectory(SLE const& dir) +{ + // Child page keys do not encode book quality. + return dir.isFieldPresent(sfExchangeRate) || dir.isFieldPresent(sfTakerPaysCurrency) || + dir.isFieldPresent(sfTakerPaysIssuer) || dir.isFieldPresent(sfTakerPaysMPT) || + dir.isFieldPresent(sfTakerGetsCurrency) || dir.isFieldPresent(sfTakerGetsIssuer) || + dir.isFieldPresent(sfTakerGetsMPT) || dir.isFieldPresent(sfDomainID); +} + +[[nodiscard]] bool +badExchangeRate(SLE const& dir) +{ + return isRootBookDirectory(dir) && + (!dir.isFieldPresent(sfExchangeRate) || + dir.getFieldU64(sfExchangeRate) != getQuality(dir.key())); +} + +} // namespace + +void +ValidBookDirectory::visitEntry( + bool isDelete, + std::shared_ptr const& before, + std::shared_ptr const& after) +{ + // New root directories must have matching exchange-rate metadata. New + // child directories, and modified directories that change sfRootIndex, must + // point to an existing root. + + // Only validate newly-created directories and sfRootIndex changes; + // LedgerStateFix handles legacy bad exchange-rate metadata. Skip deletions + // because `after` is not guaranteed to be null. + if (badBookDirectory_ || isDelete || !after || after->getType() != ltDIR_NODE) + return; + + auto const rootIndex = after->getFieldH256(sfRootIndex); + // Ignore ordinary modifications that do not change which root this + // directory belongs to. That tolerates legacy bad exchange-rate metadata + // during normal operation while still checking sfRootIndex changes. + if (before && before->getFieldH256(sfRootIndex) == rootIndex) + return; + + if (after->key() == rootIndex && !badBookDirectory_) + { + badBookDirectory_ = badBookDirectory_ || badExchangeRate(*after); + return; + } + + rootIndexes_.insert(rootIndex); +} + +bool +ValidBookDirectory::finalize( + STTx const&, + TER const, + XRPAmount const, + ReadView const& view, + beast::Journal const& j) +{ + if (!view.rules().enabled(fixCleanup3_2_0)) + return true; + + if (badBookDirectory_) + { + JLOG(j.fatal()) << "Invariant failed: book directory exchange rate " + "does not match directory quality"; + return false; + } + + for (auto const& rootIndex : rootIndexes_) + { + auto const root = view.read(Keylet(ltDIR_NODE, rootIndex)); + if (!root) + { + JLOG(j.fatal()) << "Invariant failed: book directory root missing"; + return false; + } + } + + return true; +} + +} // namespace xrpl diff --git a/src/libxrpl/tx/invariants/InvariantCheck.cpp b/src/libxrpl/tx/invariants/InvariantCheck.cpp index 4f25a91bdf..0154dca747 100644 --- a/src/libxrpl/tx/invariants/InvariantCheck.cpp +++ b/src/libxrpl/tx/invariants/InvariantCheck.cpp @@ -89,7 +89,7 @@ TransactionFeeCheck::finalize( // We should never charge a fee that's greater than or equal to the // entire XRP supply. - if (fee >= kINITIAL_XRP) + if (fee >= kInitialXrp) { JLOG(j.fatal()) << "Invariant failed: fee paid exceeds system limit: " << fee.drops(); return false; @@ -205,7 +205,7 @@ XRPBalanceChecks::visitEntry( // Can't have more than the number of drops instantiated // in the genesis ledger. - if (drops > kINITIAL_XRP) + if (drops > kInitialXrp) return true; // Can't have a negative balance (0 is OK) @@ -249,10 +249,10 @@ NoBadOffers::visitEntry( { auto isBad = [](STAmount const& pays, STAmount const& gets) { // An offer should never be negative - if (pays < beast::kZERO) + if (pays < beast::kZero) return true; - if (gets < beast::kZERO) + if (gets < beast::kZero) return true; // Can't have an XRP to XRP offer: @@ -298,7 +298,7 @@ NoZeroEscrow::visitEntry( if (amount.xrp() <= XRPAmount{0}) return true; - if (amount.xrp() >= kINITIAL_XRP) + if (amount.xrp() >= kInitialXrp) return true; } else @@ -306,7 +306,7 @@ NoZeroEscrow::visitEntry( return amount.asset().visit( [&](Issue const& issue) { // IOU case - if (amount <= beast::kZERO) + if (amount <= beast::kZero) return true; if (badCurrency() == issue.currency) @@ -318,10 +318,10 @@ NoZeroEscrow::visitEntry( // MPT case , [&](MPTIssue const&) { - if (amount <= beast::kZERO) + if (amount <= beast::kZero) return true; - if (amount.mpt() > MPTAmount{kMAX_MP_TOKEN_AMOUNT}) + if (amount.mpt() > MPTAmount{kMaxMpTokenAmount}) return true; // LCOV_EXCL_LINE return false; @@ -337,11 +337,11 @@ NoZeroEscrow::visitEntry( bad_ |= isBad((*after)[sfAmount]); auto checkAmount = [this](std::int64_t amount) { - if (amount > kMAX_MP_TOKEN_AMOUNT || amount < 0) + if (amount > kMaxMpTokenAmount || amount < 0) 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); @@ -501,7 +501,7 @@ AccountRootsDeletedClean::finalize( { auto const accountID = before->getAccountID(sfAccount); // An account should not be deleted with a balance - if (after->at(sfBalance) != beast::kZERO) + if (after->at(sfBalance) != beast::kZero) { JLOG(j.fatal()) << "Invariant failed: account deletion left " "behind a non-zero balance"; @@ -525,7 +525,7 @@ AccountRootsDeletedClean::finalize( return false; } // Simple types - for (auto const& [keyletfunc, _1, _2] : kDIRECT_ACCOUNT_KEYLETS) + for (auto const& [keyletfunc, _1, _2] : kDirectAccountKeylets) { // TODO: use '_' for both unused variables above once we are in C++26 if (objectExists(std::invoke(keyletfunc, accountID)) && enforce) @@ -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) @@ -841,7 +840,7 @@ ValidClawback::finalize( [&](MPTIssue const& issue) { return accountHolds( view, - issuer, + holder, issue, FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, @@ -991,9 +990,7 @@ NoModifiedUnmodifiableFields::finalize( ReadView const& view, beast::Journal const& j) { - static auto const kFIELD_CHANGED = [](auto const& before, - auto const& after, - auto const& field) { + static auto const kFieldChanged = [](auto const& before, auto const& after, auto const& field) { bool const beforeField = before->isFieldPresent(field); bool const afterField = after->isFieldPresent(field); return beforeField != afterField || (afterField && before->at(field) != after->at(field)); @@ -1014,17 +1011,17 @@ NoModifiedUnmodifiableFields::finalize( * potential issues even when the amendment is disabled. */ enforce = view.rules().enabled(featureLendingProtocol); - bad = kFIELD_CHANGED(before, after, sfLedgerEntryType) || - kFIELD_CHANGED(before, after, sfLedgerIndex) || - kFIELD_CHANGED(before, after, sfSequence) || - kFIELD_CHANGED(before, after, sfOwnerNode) || - kFIELD_CHANGED(before, after, sfVaultNode) || - kFIELD_CHANGED(before, after, sfVaultID) || - kFIELD_CHANGED(before, after, sfAccount) || - kFIELD_CHANGED(before, after, sfOwner) || - kFIELD_CHANGED(before, after, sfManagementFeeRate) || - kFIELD_CHANGED(before, after, sfCoverRateMinimum) || - kFIELD_CHANGED(before, after, sfCoverRateLiquidation); + bad = kFieldChanged(before, after, sfLedgerEntryType) || + kFieldChanged(before, after, sfLedgerIndex) || + kFieldChanged(before, after, sfSequence) || + kFieldChanged(before, after, sfOwnerNode) || + kFieldChanged(before, after, sfVaultNode) || + kFieldChanged(before, after, sfVaultID) || + kFieldChanged(before, after, sfAccount) || + kFieldChanged(before, after, sfOwner) || + kFieldChanged(before, after, sfManagementFeeRate) || + kFieldChanged(before, after, sfCoverRateMinimum) || + kFieldChanged(before, after, sfCoverRateLiquidation); break; case ltLOAN: /* @@ -1033,26 +1030,26 @@ NoModifiedUnmodifiableFields::finalize( * potential issues even when the amendment is disabled. */ enforce = view.rules().enabled(featureLendingProtocol); - bad = kFIELD_CHANGED(before, after, sfLedgerEntryType) || - kFIELD_CHANGED(before, after, sfLedgerIndex) || - kFIELD_CHANGED(before, after, sfSequence) || - kFIELD_CHANGED(before, after, sfOwnerNode) || - kFIELD_CHANGED(before, after, sfLoanBrokerNode) || - kFIELD_CHANGED(before, after, sfLoanBrokerID) || - kFIELD_CHANGED(before, after, sfBorrower) || - kFIELD_CHANGED(before, after, sfLoanOriginationFee) || - kFIELD_CHANGED(before, after, sfLoanServiceFee) || - kFIELD_CHANGED(before, after, sfLatePaymentFee) || - kFIELD_CHANGED(before, after, sfClosePaymentFee) || - kFIELD_CHANGED(before, after, sfOverpaymentFee) || - kFIELD_CHANGED(before, after, sfInterestRate) || - kFIELD_CHANGED(before, after, sfLateInterestRate) || - kFIELD_CHANGED(before, after, sfCloseInterestRate) || - kFIELD_CHANGED(before, after, sfOverpaymentInterestRate) || - kFIELD_CHANGED(before, after, sfStartDate) || - kFIELD_CHANGED(before, after, sfPaymentInterval) || - kFIELD_CHANGED(before, after, sfGracePeriod) || - kFIELD_CHANGED(before, after, sfLoanScale); + bad = kFieldChanged(before, after, sfLedgerEntryType) || + kFieldChanged(before, after, sfLedgerIndex) || + kFieldChanged(before, after, sfSequence) || + kFieldChanged(before, after, sfOwnerNode) || + kFieldChanged(before, after, sfLoanBrokerNode) || + kFieldChanged(before, after, sfLoanBrokerID) || + kFieldChanged(before, after, sfBorrower) || + kFieldChanged(before, after, sfLoanOriginationFee) || + kFieldChanged(before, after, sfLoanServiceFee) || + kFieldChanged(before, after, sfLatePaymentFee) || + kFieldChanged(before, after, sfClosePaymentFee) || + kFieldChanged(before, after, sfOverpaymentFee) || + kFieldChanged(before, after, sfInterestRate) || + kFieldChanged(before, after, sfLateInterestRate) || + kFieldChanged(before, after, sfCloseInterestRate) || + kFieldChanged(before, after, sfOverpaymentInterestRate) || + kFieldChanged(before, after, sfStartDate) || + kFieldChanged(before, after, sfPaymentInterval) || + kFieldChanged(before, after, sfGracePeriod) || + kFieldChanged(before, after, sfLoanScale); break; default: /* @@ -1065,8 +1062,8 @@ NoModifiedUnmodifiableFields::finalize( * was added. */ enforce = view.rules().enabled(featureLendingProtocol); - bad = kFIELD_CHANGED(before, after, sfLedgerEntryType) || - kFIELD_CHANGED(before, after, sfLedgerIndex); + bad = kFieldChanged(before, after, sfLedgerEntryType) || + kFieldChanged(before, after, sfLedgerIndex); } XRPL_ASSERT( !bad || enforce, @@ -1083,4 +1080,35 @@ NoModifiedUnmodifiableFields::finalize( return true; } +void +ValidAmounts::visitEntry( + bool isDelete, + std::shared_ptr const&, + std::shared_ptr const& after) +{ + if (!isDelete && after) + afterEntries_.push_back(after); +} + +bool +ValidAmounts::finalize( + STTx const&, + TER const, + XRPAmount const, + ReadView const& view, + beast::Journal const& j) const +{ + bool const badLedgerEntry = std::ranges::any_of( + afterEntries_, [&](auto const& sle) { return hasInvalidAmount(*sle, j); }); + + if (badLedgerEntry) + { + JLOG(j.fatal()) + << "Invariant failed: ledger entry contains non-canonical MPT or XRP amount"; + return !view.rules().enabled(fixCleanup3_2_0); + } + + return true; +} + } // namespace xrpl 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/LoanInvariant.cpp b/src/libxrpl/tx/invariants/LoanInvariant.cpp index e3dff3dde9..3eef0957e5 100644 --- a/src/libxrpl/tx/invariants/LoanInvariant.cpp +++ b/src/libxrpl/tx/invariants/LoanInvariant.cpp @@ -44,9 +44,9 @@ ValidLoan::finalize( // https://github.com/Tapanito/XRPL-Standards/blob/xls-66-lending-protocol/XLS-0066d-lending-protocol/README.md#3223-invariants // If `Loan.PaymentRemaining = 0` then the loan MUST be fully paid off if (after->at(sfPaymentRemaining) == 0 && - (after->at(sfTotalValueOutstanding) != beast::kZERO || - after->at(sfPrincipalOutstanding) != beast::kZERO || - after->at(sfManagementFeeOutstanding) != beast::kZERO)) + (after->at(sfTotalValueOutstanding) != beast::kZero || + after->at(sfPrincipalOutstanding) != beast::kZero || + after->at(sfManagementFeeOutstanding) != beast::kZero)) { JLOG(j.fatal()) << "Invariant failed: Loan with zero payments " "remaining has not been paid off"; @@ -55,9 +55,9 @@ ValidLoan::finalize( // If `Loan.PaymentRemaining != 0` then the loan MUST NOT be fully paid // off if (after->at(sfPaymentRemaining) != 0 && - after->at(sfTotalValueOutstanding) == beast::kZERO && - after->at(sfPrincipalOutstanding) == beast::kZERO && - after->at(sfManagementFeeOutstanding) == beast::kZERO) + after->at(sfTotalValueOutstanding) == beast::kZero && + after->at(sfPrincipalOutstanding) == beast::kZero && + after->at(sfManagementFeeOutstanding) == beast::kZero) { JLOG(j.fatal()) << "Invariant failed: Fully paid off Loan still has payments remaining"; return false; diff --git a/src/libxrpl/tx/invariants/MPTInvariant.cpp b/src/libxrpl/tx/invariants/MPTInvariant.cpp index 9b8838f145..635af25b61 100644 --- a/src/libxrpl/tx/invariants/MPTInvariant.cpp +++ b/src/libxrpl/tx/invariants/MPTInvariant.cpp @@ -5,16 +5,19 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include #include #include #include +#include #include #include @@ -30,6 +33,13 @@ ValidMPTIssuance::visitEntry( std::shared_ptr const& before, std::shared_ptr const& after) { + // The sfReferenceHolding tracking and the deleted-holding capture are + // only meaningful post-fixCleanup3_2_0 (the field is never set + // pre-amendment, and the holding-deletion rule does not apply). + // Skip both blocks when the amendment is off so we avoid wasted work + // on the hot path. + bool const fix320Enabled = isFeatureEnabled(fixCleanup3_2_0); + if (after && after->getType() == ltMPTOKEN_ISSUANCE) { if (isDelete) @@ -39,6 +49,21 @@ ValidMPTIssuance::visitEntry( else if (!before) { mptIssuancesCreated_++; + if (fix320Enabled && after->isFieldPresent(sfReferenceHolding)) + referenceHoldingSetOnCreate_ = true; + } + else if (fix320Enabled) + { + // Modified issuance: detect any change to sfReferenceHolding. + bool const beforePresent = before->isFieldPresent(sfReferenceHolding); + bool const afterPresent = after->isFieldPresent(sfReferenceHolding); + if (beforePresent != afterPresent || + (afterPresent && + before->getFieldH256(sfReferenceHolding) != + after->getFieldH256(sfReferenceHolding))) + { + referenceHoldingMutated_ = true; + } } } @@ -47,6 +72,8 @@ ValidMPTIssuance::visitEntry( if (isDelete) { mptokensDeleted_++; + if (fix320Enabled) + deletedHoldings_.push_back(after); } else if (!before) { @@ -56,6 +83,11 @@ ValidMPTIssuance::visitEntry( mptCreatedByIssuer_ = true; } } + + // Capture deleted RippleState SLEs so finalize() can verify none of + // them were owned by a vault pseudo-account outside VaultDelete. + if (fix320Enabled && isDelete && after && after->getType() == ltRIPPLE_STATE) + deletedHoldings_.push_back(after); } bool @@ -68,6 +100,63 @@ ValidMPTIssuance::finalize( { auto const& rules = view.rules(); bool const mptV2Enabled = rules.enabled(featureMPTokensV2); + + // Post-fixCleanup3_2_0: + // - sfReferenceHolding is set only by VaultCreate at share-issuance + // creation, and is immutable thereafter. + // - A vault pseudo-account's MPToken or RippleState may only be + // deleted by VaultDelete; the share's sfReferenceHolding pointer + // must not dangle outside that controlled lifecycle. + if (rules.enabled(fixCleanup3_2_0)) + { + bool invariantPasses = true; + if (referenceHoldingMutated_) + { + JLOG(j.fatal()) << "Invariant failed: sfReferenceHolding was modified " + "on an existing MPTokenIssuance"; + invariantPasses = false; + } + if (referenceHoldingSetOnCreate_ && tx.getTxnType() != ttVAULT_CREATE) + { + JLOG(j.fatal()) << "Invariant failed: sfReferenceHolding set on a new " + "MPTokenIssuance by a non-VaultCreate transaction"; + invariantPasses = false; + } + if (!deletedHoldings_.empty() && tx.getTxnType() != ttVAULT_DELETE) + { + auto const isVaultPseudo = [&](AccountID const& acct) { + auto const sle = view.read(keylet::account(acct)); + return sle && sle->isFieldPresent(sfVaultID); + }; + for (auto const& sleHolding : deletedHoldings_) + { + bool offending = false; + if (sleHolding->getType() == ltMPTOKEN) + { + offending = isVaultPseudo(sleHolding->at(sfAccount)); + } + else // ltRIPPLE_STATE + { + auto const lowLimit = sleHolding->getFieldAmount(sfLowLimit); + auto const highLimit = sleHolding->getFieldAmount(sfHighLimit); + // Each limit's STAmount.issuer is the COUNTERPARTY of + // that side's owner: lowLimit's issuer is the high + // account, highLimit's issuer is the low account. + offending = + isVaultPseudo(lowLimit.getIssuer()) || isVaultPseudo(highLimit.getIssuer()); + } + if (offending) + { + JLOG(j.fatal()) << "Invariant failed: vault pseudo-account holding " + "deleted by a non-VaultDelete transaction"; + invariantPasses = false; + } + } + } + if (!invariantPasses) + return false; + } + if (isTesSuccess(result) || (mptV2Enabled && result == tecINCOMPLETE)) { [[maybe_unused]] @@ -299,7 +388,7 @@ ValidMPTPayment::visitEntry( if (type == ltMPTOKEN_ISSUANCE) { auto const outstanding = sle[sfOutstandingAmount]; - if (outstanding > kMAX_MP_TOKEN_AMOUNT) + if (outstanding > kMaxMpTokenAmount) { overflow_ = true; return false; @@ -310,8 +399,8 @@ ValidMPTPayment::visitEntry( { auto const mptAmt = sle[sfMPTAmount]; auto const lockedAmt = sle[~sfLockedAmount].value_or(0); - if (mptAmt > kMAX_MP_TOKEN_AMOUNT || lockedAmt > kMAX_MP_TOKEN_AMOUNT || - lockedAmt > (kMAX_MP_TOKEN_AMOUNT - mptAmt)) + if (mptAmt > kMaxMpTokenAmount || lockedAmt > kMaxMpTokenAmount || + lockedAmt > (kMaxMpTokenAmount - mptAmt)) { overflow_ = true; return false; @@ -354,30 +443,29 @@ ValidMPTPayment::finalize( { if (isTesSuccess(result)) { - bool const enforce = view.rules().enabled(featureMPTokensV2); + bool const invariantPasses = !view.rules().enabled(featureMPTokensV2); if (overflow_) { JLOG(j.fatal()) << "Invariant failed: OutstandingAmount overflow"; - return !enforce; + return invariantPasses; } - auto const signedMax = static_cast(kMAX_MP_TOKEN_AMOUNT); + auto const signedMax = static_cast(kMaxMpTokenAmount); for (auto const& [id, data] : data_) { (void)id; - constexpr auto kI_BEFORE = static_cast(Order::Before); - constexpr auto kI_AFTER = static_cast(Order::After); + static constexpr auto kIBefore = static_cast(Order::Before); + static constexpr auto kIAfter = static_cast(Order::After); bool const addOverflows = - (data.mptAmount > 0 && - data.outstanding[kI_BEFORE] > (signedMax - data.mptAmount)) || - (data.mptAmount < 0 && data.outstanding[kI_BEFORE] < (-signedMax - data.mptAmount)); + (data.mptAmount > 0 && data.outstanding[kIBefore] > (signedMax - data.mptAmount)) || + (data.mptAmount < 0 && data.outstanding[kIBefore] < (-signedMax - data.mptAmount)); if (addOverflows || - data.outstanding[kI_AFTER] != (data.outstanding[kI_BEFORE] + data.mptAmount)) + data.outstanding[kIAfter] != (data.outstanding[kIBefore] + data.mptAmount)) { JLOG(j.fatal()) << "Invariant failed: invalid OutstandingAmount balance " - << data.outstanding[kI_BEFORE] << " " << data.outstanding[kI_AFTER] + << data.outstanding[kIBefore] << " " << data.outstanding[kIAfter] << " " << data.mptAmount; - return !enforce; + return invariantPasses; } } } @@ -385,4 +473,147 @@ ValidMPTPayment::finalize( return true; } +void +ValidMPTTransfer::visitEntry( + bool isDelete, + std::shared_ptr const& before, + std::shared_ptr const& after) +{ + // Record the before/after MPTAmount for each (issuanceID, account) pair + // so finalize() can determine whether a transfer actually occurred. + auto update = [&](SLE const& sle, bool isBefore) { + if (sle.getType() == ltMPTOKEN) + { + auto const issuanceID = sle[sfMPTokenIssuanceID]; + auto const account = sle[sfAccount]; + auto const amount = sle[sfMPTAmount]; + if (isBefore) + { + amount_[issuanceID][account].amtBefore = amount; + } + else + { + amount_[issuanceID][account].amtAfter = amount; + } + if (isDelete && isBefore) + { + deletedAuthorized_[sle.key()] = sle.isFlag(lsfMPTAuthorized); + } + } + }; + + if (before) + update(*before, true); + + if (after) + update(*after, false); +} + +bool +ValidMPTTransfer::isAuthorized( + ReadView const& view, + MPTID const& mptid, + AccountID const& holder, + bool reqAuth) const +{ + auto const key = keylet::mptoken(mptid, holder); + auto const it = deletedAuthorized_.find(key.key); + if (it != deletedAuthorized_.end()) + return !reqAuth || it->second; + return isTesSuccess(requireAuth(view, MPTIssue{mptid}, holder)); +} + +bool +ValidMPTTransfer::finalize( + STTx const& tx, + TER const, + XRPAmount const, + ReadView const& view, + beast::Journal const& j) +{ + if (hasPrivilege(tx, OverrideFreeze)) + return true; + + // DEX transactions (AMM[Create,Deposit], cross-currency payments, offer creates) are + // subject to the MPTCanTrade flag in addition to the standard transfer rules. + // A payment is only DEX if it is a cross-currency payment. + auto const txnType = tx.getTxnType(); + auto const isDEX = [&] { + if (txnType == ttPAYMENT) + { + // A payment is cross-currency (and thus DEX) only if SendMax is present + // and its asset differs from the destination asset. + auto const amount = tx[sfAmount]; + return tx[~sfSendMax].value_or(amount).asset() != amount.asset(); + } + return txnType == ttAMM_CREATE || txnType == ttAMM_DEPOSIT || txnType == ttOFFER_CREATE; + }(); + + // Only enforce once MPTokensV2 is enabled to preserve consensus with non-V2 nodes. + // Log invariant failure error even if MPTokensV2 is disabled. + auto const invariantPasses = !view.rules().enabled(featureMPTokensV2); + + for (auto const& [mptID, values] : amount_) + { + std::uint16_t senders = 0; + std::uint16_t receivers = 0; + bool invalidTransfer = false; + auto const sleIssuance = view.read(keylet::mptIssuance(mptID)); + if (!sleIssuance) + { + continue; + } + + // These transactions are recovery/settlement paths. They may move an + // existing MPT position even after the issuer clears CanTransfer, so + // holders are not trapped in AMM, vault, or loan protocol accounts. + auto const waivesCanTransfer = txnType == ttAMM_WITHDRAW || + (view.rules().enabled(fixCleanup3_2_0) && + (txnType == ttVAULT_WITHDRAW || txnType == ttLOAN_BROKER_COVER_WITHDRAW || + txnType == ttLOAN_PAY)); + auto const canTransfer = sleIssuance->isFlag(lsfMPTCanTransfer) || waivesCanTransfer; + auto const canTrade = sleIssuance->isFlag(lsfMPTCanTrade); + auto const reqAuth = sleIssuance->isFlag(lsfMPTRequireAuth); + + for (auto const& [account, value] : values) + { + // Classify each account as a sender or receiver based on whether their MPTAmount + // decreased or increased. Count new MPToken holders (no amtBefore) as receivers. + // Skip deleted MPToken holders (amtAfter is nullopt); deletion requires zero balance. + if (value.amtAfter.has_value() && value.amtBefore.value_or(0) != *value.amtAfter) + { + if (!value.amtBefore.has_value() || *value.amtAfter > *value.amtBefore) + { + ++receivers; + } + else + { + ++senders; + } + + // Check once: if any involved account is frozen, the whole + // issuance transfer is considered frozen. Only need to check for + // frozen if there is a transfer of funds. + if (!invalidTransfer && + (isFrozen(view, account, MPTIssue{mptID}) || + !isAuthorized(view, mptID, account, reqAuth))) + { + invalidTransfer = true; + } + } + } + // A transfer between holders has occurred (senders > 0 && receivers > 0). + // Fail if the issuance is frozen, does not permit transfers, or — for + // DEX transactions — does not permit trading. + if ((invalidTransfer || !canTransfer || (isDEX && !canTrade)) && senders > 0 && + receivers > 0) + { + JLOG(j.fatal()) << "Invariant failed: invalid MPToken transfer between holders"; + return invariantPasses; + } + } + + return true; +} + } // namespace xrpl diff --git a/src/libxrpl/tx/invariants/NFTInvariant.cpp b/src/libxrpl/tx/invariants/NFTInvariant.cpp index da415d2ad8..09ae9db925 100644 --- a/src/libxrpl/tx/invariants/NFTInvariant.cpp +++ b/src/libxrpl/tx/invariants/NFTInvariant.cpp @@ -31,16 +31,16 @@ ValidNFTokenPage::visitEntry( std::shared_ptr const& before, std::shared_ptr const& after) { - static constexpr uint256 const& kPAGE_BITS = nft::kPAGE_MASK; - static constexpr uint256 const kACCOUNT_BITS = ~kPAGE_BITS; + static constexpr uint256 const& kPageBits = nft::kPageMask; + static constexpr uint256 kAccountBits = ~kPageBits; if ((before && before->getType() != ltNFTOKEN_PAGE) || (after && after->getType() != ltNFTOKEN_PAGE)) return; auto check = [this, isDelete](std::shared_ptr const& sle) { - uint256 const account = sle->key() & kACCOUNT_BITS; - uint256 const hiLimit = sle->key() & kPAGE_BITS; + uint256 const account = sle->key() & kAccountBits; + uint256 const hiLimit = sle->key() & kPageBits; std::optional const prev = (*sle)[~sfPreviousPageMin]; // Make sure that any page links... @@ -48,19 +48,19 @@ ValidNFTokenPage::visitEntry( // 2. The page is correctly ordered between links. if (prev) { - if (account != (*prev & kACCOUNT_BITS)) + if (account != (*prev & kAccountBits)) badLink_ = true; - if (hiLimit <= (*prev & kPAGE_BITS)) + if (hiLimit <= (*prev & kPageBits)) badLink_ = true; } if (auto const next = (*sle)[~sfNextPageMin]) { - if (account != (*next & kACCOUNT_BITS)) + if (account != (*next & kAccountBits)) badLink_ = true; - if (hiLimit >= (*next & kPAGE_BITS)) + if (hiLimit >= (*next & kPageBits)) badLink_ = true; } @@ -69,12 +69,12 @@ ValidNFTokenPage::visitEntry( // An NFTokenPage should never contain too many tokens or be empty. if (std::size_t const nftokenCount = nftokens.size(); - (!isDelete && nftokenCount == 0) || nftokenCount > kDIR_MAX_TOKENS_PER_PAGE) + (!isDelete && nftokenCount == 0) || nftokenCount > kDirMaxTokensPerPage) invalidSize_ = true; // If prev is valid, use it to establish a lower bound for // page entries. If prev is not valid the lower bound is zero. - uint256 const loLimit = prev ? *prev & kPAGE_BITS : uint256(beast::kZERO); + uint256 const loLimit = prev ? *prev & kPageBits : uint256(beast::kZero); // Also verify that all NFTokenIDs in the page are sorted. uint256 loCmp = loLimit; @@ -87,7 +87,7 @@ ValidNFTokenPage::visitEntry( // None of the NFTs on this page should belong on lower or // higher pages. - if (uint256 const tokenPageBits = tokenID & kPAGE_BITS; + if (uint256 const tokenPageBits = tokenID & kPageBits; tokenPageBits < loLimit || tokenPageBits >= hiLimit) badEntry_ = true; @@ -104,7 +104,7 @@ ValidNFTokenPage::visitEntry( // While an account's NFToken directory contains any NFTokens, the last // NFTokenPage (with 96 bits of 1 in the low part of the index) should // never be deleted. - if (isDelete && (before->key() & nft::kPAGE_MASK) == nft::kPAGE_MASK && + if (isDelete && (before->key() & nft::kPageMask) == nft::kPageMask && before->isFieldPresent(sfPreviousPageMin)) { deletedFinalPage_ = true; @@ -121,7 +121,7 @@ ValidNFTokenPage::visitEntry( // 2. This is not the last page in the directory // Then we have identified a corruption in the links between the // NFToken pages in the NFToken directory. - if ((before->key() & nft::kPAGE_MASK) != nft::kPAGE_MASK && + if ((before->key() & nft::kPageMask) != nft::kPageMask && before->isFieldPresent(sfNextPageMin) && !after->isFieldPresent(sfNextPageMin)) { deletedLink_ = true; diff --git a/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp b/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp index 6466812743..282df85302 100644 --- a/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp +++ b/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp @@ -20,7 +20,7 @@ namespace xrpl { void ValidPermissionedDEX::visitEntry( - bool, + bool isDelete, std::shared_ptr const& before, std::shared_ptr const& after) { @@ -38,17 +38,19 @@ ValidPermissionedDEX::visitEntry( } else { - regularOffers_ = true; + regularOffersOld_ = true; + if (!isDelete) + 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 +72,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"; @@ -100,7 +102,9 @@ ValidPermissionedDEX::finalize( } } - if (regularOffers_) + bool const hasRegularOffers = + view.rules().enabled(fixCleanup3_2_0) ? regularOffers_ : regularOffersOld_; + if (hasRegularOffers) { JLOG(j.fatal()) << "Invariant failed: domain transaction" " affected regular offers"; diff --git a/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp b/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp index 784a2503ca..93c1b2058e 100644 --- a/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp +++ b/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp @@ -77,7 +77,7 @@ ValidPermissionedDomain::finalize( return false; } - if (sleStatus.credentialsSize > kMAX_PERMISSIONED_DOMAIN_CREDENTIALS_ARRAY_SIZE) + if (sleStatus.credentialsSize > kMaxPermissionedDomainCredentialsArraySize) { JLOG(j.fatal()) << "Invariant failed: permissioned domain bad " "credentials size " @@ -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/invariants/VaultInvariant.cpp b/src/libxrpl/tx/invariants/VaultInvariant.cpp index 0dad8c18a0..2947be3bd4 100644 --- a/src/libxrpl/tx/invariants/VaultInvariant.cpp +++ b/src/libxrpl/tx/invariants/VaultInvariant.cpp @@ -58,7 +58,7 @@ ValidVault::Shares::make(SLE const& from) ValidVault::Shares self; self.share = MPTIssue(makeMptID(from.getFieldU32(sfSequence), from.getAccountID(sfIssuer))); self.sharesTotal = from.at(sfOutstandingAmount); - self.sharesMaximum = from[~sfMaximumAmount].value_or(kMAX_MP_TOKEN_AMOUNT); + self.sharesMaximum = from[~sfMaximumAmount].value_or(kMaxMpTokenAmount); return self; } @@ -81,7 +81,7 @@ ValidVault::visitEntry( // validation. It is used to validate that the change in account // balances matches the change in vault balances, stored to deltas_ at the // end of this function. - DeltaInfo balanceDelta{.delta = kNUM_ZERO, .scale = std::nullopt}; + DeltaInfo balanceDelta{.delta = kNumZero, .scale = std::nullopt}; std::int8_t sign = 0; if (before) @@ -279,13 +279,13 @@ ValidVault::finalize( "shares outstanding"; result = false; } - if (beforeVault.assetsTotal != kZERO) + if (beforeVault.assetsTotal != kZero) { JLOG(j.fatal()) << "Invariant failed: deleted vault must have no " "assets outstanding"; result = false; } - if (beforeVault.assetsAvailable != kZERO) + if (beforeVault.assetsAvailable != kZero) { JLOG(j.fatal()) << "Invariant failed: deleted vault must have no " "assets available"; @@ -348,13 +348,13 @@ ValidVault::finalize( if (updatedShares->sharesTotal == 0) { - if (afterVault.assetsTotal != kZERO) + if (afterVault.assetsTotal != kZero) { JLOG(j.fatal()) << "Invariant failed: updated zero sized " "vault must have no assets outstanding"; result = false; } - if (afterVault.assetsAvailable != kZERO) + if (afterVault.assetsAvailable != kZero) { JLOG(j.fatal()) << "Invariant failed: updated zero sized " "vault must have no assets available"; @@ -369,7 +369,7 @@ ValidVault::finalize( result = false; } - if (afterVault.assetsAvailable < kZERO) + if (afterVault.assetsAvailable < kZero) { JLOG(j.fatal()) << "Invariant failed: assets available must be positive"; result = false; @@ -389,13 +389,13 @@ ValidVault::finalize( result = false; } - if (afterVault.assetsTotal < kZERO) + if (afterVault.assetsTotal < kZero) { JLOG(j.fatal()) << "Invariant failed: assets outstanding must be positive"; result = false; } - if (afterVault.assetsMaximum < kZERO) + if (afterVault.assetsMaximum < kZero) { JLOG(j.fatal()) << "Invariant failed: assets maximum must be positive"; result = false; @@ -482,7 +482,7 @@ ValidVault::finalize( return ret; ret->delta += fee.drops(); - if (ret->delta == kZERO) + if (ret->delta == kZero) return std::nullopt; return ret; @@ -519,8 +519,8 @@ ValidVault::finalize( result = false; } - if (afterVault.assetsAvailable != kZERO || afterVault.assetsTotal != kZERO || - afterVault.lossUnrealized != kZERO || updatedShares->sharesTotal != 0) + if (afterVault.assetsAvailable != kZero || afterVault.assetsTotal != kZero || + afterVault.lossUnrealized != kZero || updatedShares->sharesTotal != 0) { JLOG(j.fatal()) // << "Invariant failed: created vault must be empty"; @@ -586,7 +586,7 @@ ValidVault::finalize( result = false; } - if (afterVault.assetsMaximum > kZERO && + if (afterVault.assetsMaximum > kZero && afterVault.assetsTotal > afterVault.assetsMaximum) { JLOG(j.fatal()) << // @@ -652,7 +652,7 @@ ValidVault::finalize( result = false; } - if (vaultDeltaAssets <= kZERO) + if (vaultDeltaAssets <= kZero) { JLOG(j.fatal()) << // "Invariant failed: deposit must increase vault balance"; @@ -685,7 +685,7 @@ ValidVault::finalize( auto const localVaultDeltaAssets = roundToAsset(vaultAsset, vaultDeltaAssets, localMinScale); - if (accountDeltaAssets >= kZERO) + if (accountDeltaAssets >= kZero) { JLOG(j.fatal()) << // "Invariant failed: deposit must decrease depositor " @@ -702,7 +702,7 @@ ValidVault::finalize( } } - if (afterVault.assetsMaximum > kZERO && + if (afterVault.assetsMaximum > kZero && afterVault.assetsTotal > afterVault.assetsMaximum) { JLOG(j.fatal()) << // @@ -721,7 +721,7 @@ ValidVault::finalize( } // We don't need to round shares, they are integral MPT auto const& accountDeltaShares = *maybeAccDeltaShares; - if (accountDeltaShares.delta <= kZERO) + if (accountDeltaShares.delta <= kZero) { JLOG(j.fatal()) << // "Invariant failed: deposit must increase depositor " @@ -730,7 +730,7 @@ ValidVault::finalize( } auto const maybeVaultDeltaShares = deltaShares(afterVault.pseudoId); - if (!maybeVaultDeltaShares || maybeVaultDeltaShares->delta == kZERO) + if (!maybeVaultDeltaShares || maybeVaultDeltaShares->delta == kZero) { JLOG(j.fatal()) << // "Invariant failed: deposit must change vault shares"; @@ -796,7 +796,7 @@ ValidVault::finalize( auto const vaultPseudoDeltaAssets = roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale); - if (vaultPseudoDeltaAssets >= kZERO) + if (vaultPseudoDeltaAssets >= kZero) { JLOG(j.fatal()) << "Invariant failed: withdrawal must " "decrease vault balance"; @@ -841,7 +841,7 @@ ValidVault::finalize( auto const roundedDestinationDelta = roundToAsset(vaultAsset, destinationDelta.delta, localMinScale); - if (roundedDestinationDelta <= kZERO) + if (roundedDestinationDelta <= kZero) { JLOG(j.fatal()) << // "Invariant failed: withdrawal must increase " @@ -870,7 +870,7 @@ ValidVault::finalize( return false; } - if (accountDeltaShares->delta >= kZERO) + if (accountDeltaShares->delta >= kZero) { JLOG(j.fatal()) << // "Invariant failed: withdrawal must decrease depositor " @@ -880,7 +880,7 @@ ValidVault::finalize( // We don't need to round shares, they are integral MPT auto const vaultDeltaShares = deltaShares(afterVault.pseudoId); - if (!vaultDeltaShares || vaultDeltaShares->delta == kZERO) + if (!vaultDeltaShares || vaultDeltaShares->delta == kZero) { JLOG(j.fatal()) << // "Invariant failed: withdrawal must change vault shares"; @@ -950,7 +950,7 @@ ValidVault::finalize( computeCoarsestScale({*maybeVaultDeltaAssets, totalDelta, availableDelta}); auto const vaultDeltaAssets = roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale); - if (vaultDeltaAssets >= kZERO) + if (vaultDeltaAssets >= kZero) { JLOG(j.fatal()) << // "Invariant failed: clawback must decrease vault " @@ -995,7 +995,7 @@ ValidVault::finalize( "Invariant failed: clawback must change holder shares"; return false; // That's all we can do } - if (maybeAccountDeltaShares->delta >= kZERO) + if (maybeAccountDeltaShares->delta >= kZero) { JLOG(j.fatal()) << // "Invariant failed: clawback must decrease holder " @@ -1005,7 +1005,7 @@ ValidVault::finalize( // We don't need to round shares, they are integral MPT auto const vaultDeltaShares = deltaShares(afterVault.pseudoId); - if (!vaultDeltaShares || vaultDeltaShares->delta == kZERO) + if (!vaultDeltaShares || vaultDeltaShares->delta == kZero) { JLOG(j.fatal()) << // "Invariant failed: clawback must change vault shares"; @@ -1067,7 +1067,7 @@ ValidVault::computeCoarsestScale(std::vector const& numbers) numbers, [](auto const& a, auto const& b) -> bool { return a.scale < b.scale; }); XRPL_ASSERT_PARTS( max->scale, "xrpl::ValidVault::computeCoarsestScale", "scale set for destinationDelta"); - return max->scale.value_or(STAmount::kMAX_OFFSET); + return max->scale.value_or(STAmount::kMaxOffset); } } // namespace xrpl diff --git a/src/libxrpl/tx/paths/AMMLiquidity.cpp b/src/libxrpl/tx/paths/AMMLiquidity.cpp index 87eb29f104..0d1c66ead8 100644 --- a/src/libxrpl/tx/paths/AMMLiquidity.cpp +++ b/src/libxrpl/tx/paths/AMMLiquidity.cpp @@ -54,7 +54,7 @@ AMMLiquidity::fetchBalances(ReadView const& view) const auto const amountIn = ammAccountHolds(view, ammAccountID_, assetIn_); auto const amountOut = ammAccountHolds(view, ammAccountID_, assetOut_); // This should not happen. - if (amountIn < beast::kZERO || amountOut < beast::kZERO) + if (amountIn < beast::kZero || amountOut < beast::kZero) Throw("AMMLiquidity: invalid balances"); return TAmounts{get(amountIn), get(amountOut)}; @@ -68,7 +68,7 @@ AMMLiquidity::generateFibSeqOffer(TAmounts const& balances cur.in = toAmount( getAsset(balances.in), - kINITIAL_FIB_SEQ_PCT * initialBalances_.in, + kInitialFibSeqPct * initialBalances_.in, Number::RoundingMode::Upward); cur.out = swapAssetIn(initialBalances_, cur.in, tradingFee_); @@ -76,7 +76,7 @@ AMMLiquidity::generateFibSeqOffer(TAmounts const& balances return cur; // clang-format off - constexpr std::uint32_t kFIB[AMMContext::kMAX_ITERATIONS] = { + static constexpr std::uint32_t kFib[AMMContext::kMaxIterations] = { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269}; @@ -88,7 +88,7 @@ AMMLiquidity::generateFibSeqOffer(TAmounts const& balances cur.out = toAmount( getAsset(balances.out), - cur.out * kFIB[ammContext_.curIters() - 1], + cur.out * kFib[ammContext_.curIters() - 1], Number::RoundingMode::Downward); // swapAssetOut() returns negative in this case if (cur.out >= balances.out) @@ -106,19 +106,19 @@ maxAmount() { if constexpr (std::is_same_v) { - return XRPAmount(STAmount::kMAX_NATIVE); + return XRPAmount(STAmount::kMaxNative); } else if constexpr (std::is_same_v) { - return IOUAmount(STAmount::kMAX_VALUE / 2, STAmount::kMAX_OFFSET); + return IOUAmount(STAmount::kMaxValue / 2, STAmount::kMaxOffset); } else if constexpr (std::is_same_v) { - return STAmount(STAmount::kMAX_VALUE / 2, STAmount::kMAX_OFFSET); + return STAmount(STAmount::kMaxValue / 2, STAmount::kMaxOffset); } else if constexpr (std::is_same_v) { - return MPTAmount(kMAX_MP_TOKEN_AMOUNT); + return MPTAmount(kMaxMpTokenAmount); } } @@ -163,7 +163,7 @@ AMMLiquidity::getOffer(ReadView const& view, std::optional c auto const balances = fetchBalances(view); // Frozen accounts - if (balances.in == beast::kZERO || balances.out == beast::kZERO) + if (balances.in == beast::kZero || balances.out == beast::kZero) { JLOG(j_.debug()) << "AMMLiquidity::getOffer, frozen accounts"; return std::nullopt; @@ -239,7 +239,7 @@ AMMLiquidity::getOffer(ReadView const& view, std::optional c if (offer) { - if (offer->amount().in > beast::kZERO && offer->amount().out > beast::kZERO) + if (offer->amount().in > beast::kZero && offer->amount().out > beast::kZero) { JLOG(j_.trace()) << "AMMLiquidity::getOffer, created " << to_string(offer->amount().in) << "/" << assetIn_ << " " << to_string(offer->amount().out) << "/" diff --git a/src/libxrpl/tx/paths/BookStep.cpp b/src/libxrpl/tx/paths/BookStep.cpp index 113155e530..5cc2a987b8 100644 --- a/src/libxrpl/tx/paths/BookStep.cpp +++ b/src/libxrpl/tx/paths/BookStep.cpp @@ -57,7 +57,7 @@ class BookStep : public StepImp> protected: enum class OfferType { Amm, Clob }; - static constexpr uint32_t kMAX_OFFERS_TO_CONSUME{1000}; + static constexpr uint32_t kMaxOffersToConsume{1000}; Book book_; AccountID strandSrc_; AccountID strandDst_; @@ -104,7 +104,7 @@ private: , strandDeliver_(ctx.strandDeliver) { if (auto const ammSle = ctx.view.read(keylet::amm(in, out)); - ammSle && ammSle->getFieldAmount(sfLPTokenBalance) != beast::kZERO) + ammSle && ammSle->getFieldAmount(sfLPTokenBalance) != beast::kZero) { ammLiquidity_.emplace( ctx.view, @@ -350,12 +350,12 @@ public: // Calculate amount that goes to the taker and the amount charged the // offer owner auto const trIn = - redeems(prevStepDir) ? this->rate(v, this->book_.in, this->strandDst_) : kPARITY_RATE; + redeems(prevStepDir) ? this->rate(v, this->book_.in, this->strandDst_) : kParityRate; // Always charge the transfer fee, even if the owner is the issuer, // unless the fee is waived auto const trOut = (this->ownerPaysTransferFee_ && waiveFee == WaiveTransferFee::No) ? this->rate(v, this->book_.out, this->strandDst_) - : kPARITY_RATE; + : kParityRate; Quality const q1{getRate(STAmount(trOut.value), STAmount(trIn.value))}; return composedQuality(q1, ofrQ); @@ -537,9 +537,9 @@ public: } auto const trIn = - redeems(prevStepDir) ? this->rate(v, this->book_.in, this->strandDst_) : kPARITY_RATE; + redeems(prevStepDir) ? this->rate(v, this->book_.in, this->strandDst_) : kParityRate; // AMM doesn't pay the transfer fee on the out amount - auto const trOut = kPARITY_RATE; + auto const trOut = kParityRate; Quality const q1{getRate(STAmount(trOut.value), STAmount(trIn.value))}; return composedQuality(q1, ofrQ); @@ -598,10 +598,10 @@ BookStep::getQualityFunc(ReadView const& v, DebtDirection p // AMM if (!res->isConst()) { - auto static const kQ_ONE = Quality{STAmount::kU_RATE_ONE}; + auto static const kQOne = Quality{STAmount::kURateOne}; auto const q = static_cast(this)->adjustQualityWithFees( - v, kQ_ONE, prevStepDir, WaiveTransferFee::Yes, OfferType::Amm, v.rules()); - if (q == kQ_ONE) + v, kQOne, prevStepDir, WaiveTransferFee::Yes, OfferType::Amm, v.rules()); + if (q == kQOne) return {res, dir}; QualityFunction qf{q, QualityFunction::CLOBLikeTag{}}; qf.combine(*res); @@ -700,7 +700,7 @@ BookStep::forEachOffer( std::uint32_t const trOut = ownerPaysTransferFee_ ? rate(sb, book_.out, this->strandDst_).value : QUALITY_ONE; - typename FlowOfferStream::StepCounter counter(kMAX_OFFERS_TO_CONSUME, j_); + typename FlowOfferStream::StepCounter counter(kMaxOffersToConsume, j_); FlowOfferStream offers(sb, afView, book_, sb.parentCloseTime(), counter, j_); @@ -989,7 +989,7 @@ sum(TCollection const& col) { using TResult = std::decay_t; if (col.empty()) - return TResult{beast::kZERO}; + return TResult{beast::kZero}; return std::accumulate(col.begin() + 1, col.end(), *col.begin()); }; @@ -1003,7 +1003,7 @@ BookStep::revImp( { cache_.reset(); - TAmounts result(beast::kZERO, beast::kZERO); + TAmounts result(beast::kZero, beast::kZero); auto remainingOut = out; @@ -1022,7 +1022,7 @@ BookStep::revImp( TOut const& ownerGives, std::uint32_t transferRateIn, std::uint32_t transferRateOut) mutable -> bool { - if (remainingOut <= beast::kZERO) + if (remainingOut <= beast::kZero) return false; if (stpAmt.out <= remainingOut) @@ -1048,7 +1048,7 @@ BookStep::revImp( transferRateIn, transferRateOut, remainingOut); - remainingOut = beast::kZERO; + remainingOut = beast::kZero; savedIns.insert(stpAdjAmt.in); savedOuts.insert(remainingOut); result.in = sum(savedIns); @@ -1076,7 +1076,7 @@ BookStep::revImp( setUnion(ofrsToRm, toRm); // Too many iterations, mark this strand as inactive - if (offersConsumed >= kMAX_OFFERS_TO_CONSUME) + if (offersConsumed >= kMaxOffersToConsume) { inactive_ = true; } @@ -1089,8 +1089,8 @@ BookStep::revImp( // LCOV_EXCL_START JLOG(j_.error()) << "BookStep remainingOut < 0 " << to_string(remainingOut); UNREACHABLE("xrpl::BookStep::revImp : remaining less than zero"); - cache_.emplace(beast::kZERO, beast::kZERO); - return {beast::kZERO, beast::kZERO}; + cache_.emplace(beast::kZero, beast::kZero); + return {beast::kZero, beast::kZero}; // LCOV_EXCL_STOP } case 0: { @@ -1114,7 +1114,7 @@ BookStep::fwdImp( { XRPL_ASSERT(cache_, "xrpl::BookStep::fwdImp : cache is set"); - TAmounts result(beast::kZERO, beast::kZERO); + TAmounts result(beast::kZero, beast::kZero); auto remainingIn = in; @@ -1133,7 +1133,7 @@ BookStep::fwdImp( std::uint32_t transferRateOut) mutable -> bool { XRPL_ASSERT(cache_, "xrpl::BookStep::fwdImp::eachOffer : cache is set"); - if (remainingIn <= beast::kZERO) + if (remainingIn <= beast::kZero) return false; bool processMore = true; @@ -1238,7 +1238,7 @@ BookStep::fwdImp( setUnion(ofrsToRm, toRm); // Too many iterations, mark this strand as inactive (dry) - if (offersConsumed >= kMAX_OFFERS_TO_CONSUME) + if (offersConsumed >= kMaxOffersToConsume) { inactive_ = true; } @@ -1251,8 +1251,8 @@ BookStep::fwdImp( // something went very wrong JLOG(j_.error()) << "BookStep remainingIn < 0 " << to_string(remainingIn); UNREACHABLE("xrpl::BookStep::fwdImp : remaining less than zero"); - cache_.emplace(beast::kZERO, beast::kZERO); - return {beast::kZERO, beast::kZERO}; + cache_.emplace(beast::kZero, beast::kZero); + return {beast::kZero, beast::kZero}; // LCOV_EXCL_STOP } case 0: { @@ -1276,7 +1276,7 @@ BookStep::validFwd( if (!cache_) { JLOG(j_.trace()) << "Expected valid cache in validFwd"; - return {false, EitherAmount(TOut(beast::kZERO))}; + return {false, EitherAmount(TOut(beast::kZero))}; } auto const savCache = *cache_; @@ -1288,7 +1288,7 @@ BookStep::validFwd( } catch (FlowException const&) { - return {false, EitherAmount(TOut(beast::kZERO))}; + return {false, EitherAmount(TOut(beast::kZero))}; } // NOLINTBEGIN(bugprone-unchecked-optional-access) fwdImp sets cache_ on success @@ -1357,24 +1357,22 @@ 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; }, - [&](MPTIssue const& issue) -> std::optional { - // Check if can trade on DEX. - if (auto const ter = canTrade(view, book_.in); !isTesSuccess(ter)) - return ter; - if (auto const ter = canTrade(view, book_.out); !isTesSuccess(ter)) - return ter; - return std::nullopt; - }); + [&](MPTIssue const& issue) -> std::optional { return std::nullopt; }); if (err) return *err; } } + // Check if the offer can be traded on DEX. + if (auto const ter = canTrade(ctx.view, book_.in); !isTesSuccess(ter)) + return ter; + if (auto const ter = canTrade(ctx.view, book_.out); !isTesSuccess(ter)) + return ter; + return tesSUCCESS; } @@ -1385,12 +1383,22 @@ BookStep::rate( Asset const& asset, AccountID const& dstAccount) const { - auto const& issuer = asset.getIssuer(); - if (isXRP(issuer) || issuer == dstAccount) - return kPARITY_RATE; return asset.visit( - [&](Issue const&) { return transferRate(view, issuer); }, - [&](MPTIssue const& issue) { return transferRate(view, issue.getMptID()); }); + [&](Issue const& issue) -> Rate { + if (isXRP(issue.account) || issue.account == dstAccount) + return kParityRate; + return transferRate(view, issue.account); + }, + [&](MPTIssue const& mptIssue) -> Rate { + // For MPT, parity applies only when this asset is the final strand + // delivery AND the destination is the MPT issuer (holder → issuer, + // which is fee-free). Using strandDst_ alone is wrong because it + // incorrectly suppresses the fee when MPT is an intermediate or + // the in-side of a book that precedes the issuer's XRP receipt. + if (asset == strandDeliver_ && mptIssue.getIssuer() == dstAccount) + return kParityRate; + return transferRate(view, mptIssue.getMptID()); + }); }; template diff --git a/src/libxrpl/tx/paths/DirectStep.cpp b/src/libxrpl/tx/paths/DirectStep.cpp index 7373f8a341..a16c3afd6a 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; } } @@ -451,7 +449,7 @@ DirectIPaymentStep::check(StrandContext const& ctx, std::shared_ptr c { auto const owed = creditBalance(ctx.view, dst_, src_, currency_); - if (owed <= beast::kZERO) + if (owed <= beast::kZero) { auto const limit = creditLimit(ctx.view, dst_, src_, currency_); if (-owed >= limit) @@ -528,8 +526,8 @@ DirectStepI::revImp( { JLOG(j_.trace()) << "DirectStepI::rev: dry"; cache_.emplace( - IOUAmount(beast::kZERO), IOUAmount(beast::kZERO), IOUAmount(beast::kZERO), srcDebtDir); - return {beast::kZERO, beast::kZERO}; + IOUAmount(beast::kZero), IOUAmount(beast::kZero), IOUAmount(beast::kZero), srcDebtDir); + return {beast::kZero, beast::kZero}; } IOUAmount const srcToDst = mulRatio(out, QUALITY_ONE, dstQIn, /*roundUp*/ true); @@ -641,8 +639,8 @@ DirectStepI::fwdImp( { JLOG(j_.trace()) << "DirectStepI::fwd: dry"; cache_.emplace( - IOUAmount(beast::kZERO), IOUAmount(beast::kZERO), IOUAmount(beast::kZERO), srcDebtDir); - return {beast::kZERO, beast::kZERO}; + IOUAmount(beast::kZero), IOUAmount(beast::kZero), IOUAmount(beast::kZero), srcDebtDir); + return {beast::kZero, beast::kZero}; } IOUAmount const srcToDst = mulRatio(in, QUALITY_ONE, srcQOut, /*roundUp*/ false); @@ -690,7 +688,7 @@ DirectStepI::validFwd(PaymentSandbox& sb, ApplyView& afView, EitherAmo if (!cache_) { JLOG(j_.trace()) << "Expected valid cache in validFwd"; - return {false, EitherAmount(IOUAmount(beast::kZERO))}; + return {false, EitherAmount(IOUAmount(beast::kZero))}; } auto const savCache = *cache_; @@ -708,7 +706,7 @@ DirectStepI::validFwd(PaymentSandbox& sb, ApplyView& afView, EitherAmo } catch (FlowException const&) { - return {false, EitherAmount(IOUAmount(beast::kZERO))}; + return {false, EitherAmount(IOUAmount(beast::kZero))}; } // NOLINTBEGIN(bugprone-unchecked-optional-access) fwdImp sets cache_ on success diff --git a/src/libxrpl/tx/paths/MPTEndpointStep.cpp b/src/libxrpl/tx/paths/MPTEndpointStep.cpp index 25c9062e47..5595f8ea65 100644 --- a/src/libxrpl/tx/paths/MPTEndpointStep.cpp +++ b/src/libxrpl/tx/paths/MPTEndpointStep.cpp @@ -385,7 +385,7 @@ MPTEndpointPaymentStep::check(StrandContext const& ctx, std::shared_ptr const&) { + // The standard checks are all we can do because any remaining checks + // require the existence of a MPToken. Offer crossing does not + // require a pre-existing MPToken. return tesSUCCESS; } @@ -487,12 +490,12 @@ MPTEndpointStep::revImp( { JLOG(j_.trace()) << "MPTEndpointStep::rev: dry"; resetCache(srcDebtDir); - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; } if (auto const err = static_cast(this)->checkCreateMPT(sb, srcDebtDir); !isTesSuccess(err)) - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; // Don't have to factor in dstQIn since it is always QUALITY_ONE MPTAmount const srcToDst = out; @@ -512,7 +515,7 @@ MPTEndpointStep::revImp( { JLOG(j_.trace()) << "MPTEndpointStep::rev: error " << ter; resetCache(srcDebtDir); - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; } JLOG(j_.trace()) << "MPTEndpointStep::rev: Non-limiting" << " srcRedeems: " << redeems(srcDebtDir) << " in: " << to_string(in) @@ -537,7 +540,7 @@ MPTEndpointStep::revImp( { JLOG(j_.trace()) << "MPTEndpointStep::rev: error " << ter; resetCache(srcDebtDir); - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; } JLOG(j_.trace()) << "MPTEndpointStep::rev: Limiting" << " srcRedeems: " << redeems(srcDebtDir) << " in: " << to_string(in) @@ -618,12 +621,12 @@ MPTEndpointStep::fwdImp( { JLOG(j_.trace()) << "MPTEndpointStep::fwd: dry"; resetCache(srcDebtDir); - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; } if (auto const err = static_cast(this)->checkCreateMPT(sb, srcDebtDir); !isTesSuccess(err)) - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; MPTAmount const srcToDst = mulRatio(in, QUALITY_ONE, srcQOut, /*roundUp*/ false); @@ -643,7 +646,7 @@ MPTEndpointStep::fwdImp( { JLOG(j_.trace()) << "MPTEndpointStep::fwd: error " << ter; resetCache(srcDebtDir); - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; } JLOG(j_.trace()) << "MPTEndpointStep::fwd: Non-limiting" << " srcRedeems: " << redeems(srcDebtDir) << " in: " << to_string(in) @@ -667,7 +670,7 @@ MPTEndpointStep::fwdImp( { JLOG(j_.trace()) << "MPTEndpointStep::fwd: error " << ter; resetCache(srcDebtDir); - return {beast::kZERO, beast::kZERO}; + return {beast::kZero, beast::kZero}; } JLOG(j_.trace()) << "MPTEndpointStep::fwd: Limiting" << " srcRedeems: " << redeems(srcDebtDir) << " in: " << to_string(actualIn) @@ -684,7 +687,7 @@ MPTEndpointStep::validFwd(PaymentSandbox& sb, ApplyView& afView, Eithe if (!cache_) { JLOG(j_.trace()) << "Expected valid cache in validFwd"; - return {false, EitherAmount(MPTAmount(beast::kZERO))}; + return {false, EitherAmount(MPTAmount(beast::kZero))}; } auto const savCache = *cache_; @@ -701,7 +704,7 @@ MPTEndpointStep::validFwd(PaymentSandbox& sb, ApplyView& afView, Eithe } catch (FlowException const&) { - return {false, EitherAmount(MPTAmount(beast::kZERO))}; + return {false, EitherAmount(MPTAmount(beast::kZero))}; } // NOLINTBEGIN(bugprone-unchecked-optional-access) fwdImp sets cache_ on success @@ -838,10 +841,17 @@ MPTEndpointStep::check(StrandContext const& ctx) const } // pure issue/redeem can't be frozen (issuer/holder) + // For the first step: check global freeze of the step's own asset. + // For the last step: check only the per-holder MPToken lock. + // Global freeze of the deliver asset is not checked here + // because MPT semantics allow issuer<->holder transfers even when globally + // locked — only holder-to-holder DEX paths are restricted. if (!(ctx.isLast && ctx.isFirst)) { auto const& account = ctx.isFirst ? src_ : dst_; - if (isFrozen(ctx.view, account, mptIssue_)) + bool const frozen = (ctx.isFirst && isGlobalFrozen(ctx.view, mptIssue_)) || + isIndividualFrozen(ctx.view, account, mptIssue_); + if (frozen) return terLOCKED; } @@ -893,7 +903,7 @@ template void MPTEndpointStep::resetCache(xrpl::DebtDirection dir) { - cache_.emplace(MPTAmount(beast::kZERO), MPTAmount(beast::kZERO), MPTAmount(beast::kZERO), dir); + cache_.emplace(MPTAmount(beast::kZero), MPTAmount(beast::kZero), MPTAmount(beast::kZero), dir); } //------------------------------------------------------------------------------ diff --git a/src/libxrpl/tx/paths/OfferStream.cpp b/src/libxrpl/tx/paths/OfferStream.cpp index b5ac45503a..bfe2bbd1bb 100644 --- a/src/libxrpl/tx/paths/OfferStream.cpp +++ b/src/libxrpl/tx/paths/OfferStream.cpp @@ -138,10 +138,10 @@ TOfferStreamBase::shouldRmSmallIncreasedQOffer() const // Consider removing the offer if: // o `TakerPays` is XRP (because of XRP drops granularity) or // o `TakerPays` and `TakerGets` are both IOU and `TakerPays`<`TakerGets` - constexpr bool const kIN_IS_XRP = std::is_same_v; - constexpr bool const kOUT_IS_XRP = std::is_same_v; + static constexpr bool kInIsXrp = std::is_same_v; + static constexpr bool kOutIsXrp = std::is_same_v; - if constexpr (kOUT_IS_XRP) + if constexpr (kOutIsXrp) { // If `TakerGets` is XRP, the worst this offer's quality can change is // to about 10^-81 `TakerPays` and 1 drop `TakerGets`. This will be @@ -156,7 +156,7 @@ TOfferStreamBase::shouldRmSmallIncreasedQOffer() const TAmounts const ofrAmts{ toAmount(offer_.amount().in), toAmount(offer_.amount().out)}; - if constexpr (!kIN_IS_XRP && !kOUT_IS_XRP) + if constexpr (!kInIsXrp && !kOutIsXrp) { if (Number(ofrAmts.in) >= Number(ofrAmts.out)) return false; @@ -271,7 +271,7 @@ TOfferStreamBase::step() j_); // Check for unfunded offer - if (*ownerFunds_ <= beast::kZERO) + if (*ownerFunds_ <= beast::kZero) { // If the owner's balance in the pristine view is the same, // we haven't modified the balance and therefore the diff --git a/src/libxrpl/tx/paths/PaySteps.cpp b/src/libxrpl/tx/paths/PaySteps.cpp index 68bd501d87..0a5adeb77f 100644 --- a/src/libxrpl/tx/paths/PaySteps.cpp +++ b/src/libxrpl/tx/paths/PaySteps.cpp @@ -189,9 +189,9 @@ toStrand( (dst == noAccount()) || (deliver.getIssuer() == noAccount())) return {temBAD_PATH, Strand{}}; - if ((deliver.holds() && deliver.getIssuer() == beast::kZERO) || + if ((deliver.holds() && deliver.getIssuer() == beast::kZero) || (sendMaxAsset && sendMaxAsset->holds() && - sendMaxAsset->getIssuer() == beast::kZERO)) + sendMaxAsset->getIssuer() == beast::kZero)) return {temBAD_PATH, Strand{}}; for (std::size_t i = 0; i < path.size(); ++i) @@ -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/paths/RippleCalc.cpp b/src/libxrpl/tx/paths/RippleCalc.cpp index 06e386344d..cc497b7935 100644 --- a/src/libxrpl/tx/paths/RippleCalc.cpp +++ b/src/libxrpl/tx/paths/RippleCalc.cpp @@ -59,13 +59,13 @@ RippleCalc::rippleCalculate( bool const partialPayment = (pInputs == nullptr) ? false : pInputs->partialPaymentAllowed; auto const limitQuality = [&]() -> std::optional { - if (pInputs && pInputs->limitQuality && saMaxAmountReq > beast::kZERO) + if (pInputs && pInputs->limitQuality && saMaxAmountReq > beast::kZero) return Quality{Amounts(saMaxAmountReq, saDstAmountReq)}; return std::nullopt; }(); auto const sendMax = [&]() -> std::optional { - if (saMaxAmountReq >= beast::kZERO || + if (saMaxAmountReq >= beast::kZero || !equalTokens(saMaxAmountReq.asset(), saDstAmountReq.asset()) || saMaxAmountReq.getIssuer() != uSrcAccountID) { diff --git a/src/libxrpl/tx/paths/XRPEndpointStep.cpp b/src/libxrpl/tx/paths/XRPEndpointStep.cpp index 244e1cffea..314780c3a7 100644 --- a/src/libxrpl/tx/paths/XRPEndpointStep.cpp +++ b/src/libxrpl/tx/paths/XRPEndpointStep.cpp @@ -253,7 +253,7 @@ template std::pair, DebtDirection> XRPEndpointStep::qualityUpperBound(ReadView const& v, DebtDirection prevStepDir) const { - return {Quality{STAmount::kU_RATE_ONE}, this->debtDirection(v, StrandDirection::Forward)}; + return {Quality{STAmount::kURateOne}, this->debtDirection(v, StrandDirection::Forward)}; } template @@ -272,7 +272,7 @@ XRPEndpointStep::revImp( auto& receiver = isLast_ ? acc_ : xrpAccount(); auto ter = accountSend(sb, sender, receiver, toSTAmount(result), j_); if (!isTesSuccess(ter)) - return {XRPAmount{beast::kZERO}, XRPAmount{beast::kZERO}}; + return {XRPAmount{beast::kZero}, XRPAmount{beast::kZero}}; cache_.emplace(result); return {result, result}; @@ -295,7 +295,7 @@ XRPEndpointStep::fwdImp( auto& receiver = isLast_ ? acc_ : xrpAccount(); auto ter = accountSend(sb, sender, receiver, toSTAmount(result), j_); if (!isTesSuccess(ter)) - return {XRPAmount{beast::kZERO}, XRPAmount{beast::kZERO}}; + return {XRPAmount{beast::kZero}, XRPAmount{beast::kZero}}; cache_.emplace(result); return {result, result}; @@ -308,7 +308,7 @@ XRPEndpointStep::validFwd(PaymentSandbox& sb, ApplyView& afView, Eithe if (!cache_) { JLOG(j_.error()) << "Expected valid cache in validFwd"; - return {false, EitherAmount(XRPAmount(beast::kZERO))}; + return {false, EitherAmount(XRPAmount(beast::kZero))}; } XRPL_ASSERT(in.holds(), "xrpl::XRPEndpointStep::validFwd : input is XRP"); diff --git a/src/libxrpl/tx/transactors/account/AccountDelete.cpp b/src/libxrpl/tx/transactors/account/AccountDelete.cpp index f9d1913dff..c0e8fe05c6 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; @@ -275,8 +275,8 @@ AccountDelete::preclaim(PreclaimContext const& ctx) // // We look at the account's Sequence rather than the transaction's // Sequence in preparation for Tickets. - constexpr std::uint32_t kSEQ_DELTA{255}; - if ((*sleAccount)[sfSequence] + kSEQ_DELTA > ctx.view.seq()) + static constexpr std::uint32_t kSeqDelta{255}; + if ((*sleAccount)[sfSequence] + kSeqDelta > ctx.view.seq()) return tecTOO_SOON; // We don't allow an account to be deleted if @@ -291,7 +291,7 @@ AccountDelete::preclaim(PreclaimContext const& ctx) // NFTokenSequence of this NFToken is the same as the one that the // authorized minter minted in a previous ledger. if ((*sleAccount)[~sfFirstNFTokenSequence].value_or(0) + - (*sleAccount)[~sfMintedNFTokens].value_or(0) + kSEQ_DELTA > + (*sleAccount)[~sfMintedNFTokens].value_or(0) + kSeqDelta > ctx.view.seq()) return tecTOO_SOON; @@ -303,7 +303,7 @@ AccountDelete::preclaim(PreclaimContext const& ctx) std::shared_ptr sleDirNode{}; unsigned int uDirEntry{0}; - uint256 dirEntry{beast::kZERO}; + uint256 dirEntry{beast::kZero}; // Account has no directory at all. This _should_ have been caught // by the dirIsEmpty() check earlier, but it's okay to catch it here. @@ -333,7 +333,7 @@ AccountDelete::preclaim(PreclaimContext const& ctx) // We found a deletable directory entry. Count it. If we find too // many deletable directory entries then bail out. - if (++deletableDirEntryCount > kMAX_DELETABLE_DIR_ENTRIES) + if (++deletableDirEntryCount > kMaxDeletableDirEntries) return tefTOO_BIG; } while (cdirNext(ctx.view, ownerDirKeylet.key, sleDirNode, uDirEntry, dirEntry)); @@ -344,7 +344,7 @@ AccountDelete::preclaim(PreclaimContext const& ctx) TER AccountDelete::doApply() { - auto src = view().peek(keylet::account(account_)); + auto src = view().peek(keylet::account(accountID_)); XRPL_ASSERT(src, "xrpl::AccountDelete::doApply : non-null source account"); auto const dstID = ctx_.tx[sfDestination]; @@ -357,12 +357,12 @@ AccountDelete::doApply() if (ctx_.tx.isFieldPresent(sfCredentialIDs)) { if (auto err = - verifyDepositPreauth(ctx_.tx, ctx_.view(), account_, dstID, dst, ctx_.journal); + verifyDepositPreauth(ctx_.tx, ctx_.view(), accountID_, dstID, dst, ctx_.journal); !isTesSuccess(err)) return err; } - Keylet const ownerDirKeylet{keylet::ownerDir(account_)}; + Keylet const ownerDirKeylet{keylet::ownerDir(accountID_)}; auto const ter = cleanupOnAccountDelete( view(), ownerDirKeylet, @@ -371,7 +371,7 @@ AccountDelete::doApply() std::shared_ptr& sleItem) -> std::pair { if (auto deleter = nonObligationDeleter(nodeType)) { - TER const result{deleter(ctx_.registry, view(), account_, dirEntry, sleItem, j_)}; + TER const result{deleter(ctx_.registry, view(), accountID_, dirEntry, sleItem, j_)}; return {result, SkipEntry::No}; } @@ -402,7 +402,7 @@ AccountDelete::doApply() // delete it. if (view().exists(ownerDirKeylet) && !view().emptyDirDelete(ownerDirKeylet)) { - JLOG(j_.error()) << "AccountDelete cannot delete root dir node of " << toBase58(account_); + JLOG(j_.error()) << "AccountDelete cannot delete root dir node of " << toBase58(accountID_); return tecHAS_OBLIGATIONS; } @@ -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..b52db14720 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) { @@ -143,7 +137,7 @@ AccountSet::preflight(PreflightContext const& ctx) { auto uTickSize = tx[sfTickSize]; if ((uTickSize != 0u) && - ((uTickSize < Quality::kMIN_TICK_SIZE) || (uTickSize > Quality::kMAX_TICK_SIZE))) + ((uTickSize < Quality::kMinTickSize) || (uTickSize > Quality::kMaxTickSize))) { JLOG(j.trace()) << "Malformed transaction: Bad tick size."; return temBAD_TICK_SIZE; @@ -159,7 +153,7 @@ AccountSet::preflight(PreflightContext const& ctx) } } - if (auto const domain = tx[~sfDomain]; domain && domain->size() > kMAX_DOMAIN_LENGTH) + if (auto const domain = tx[~sfDomain]; domain && domain->size() > kMaxDomainLength) { JLOG(j.trace()) << "domain too long"; return telBAD_DOMAIN; @@ -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; @@ -290,7 +279,7 @@ AccountSet::preclaim(PreclaimContext const& ctx) TER AccountSet::doApply() { - auto const sle = view().peek(keylet::account(account_)); + auto const sle = view().peek(keylet::account(accountID_)); if (!sle) return tefINTERNAL; // LCOV_EXCL_LINE @@ -302,18 +291,14 @@ 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_]() { + bool const sigWithMaster{[&tx, &acct = accountID_]() { auto const spk = tx.getSigningPubKey(); if (publicKeyType(makeSlice(spk))) @@ -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) { @@ -382,7 +367,7 @@ AccountSet::doApply() return tecNEED_MASTER_KEY; } - if ((!sle->isFieldPresent(sfRegularKey)) && (!view().peek(keylet::signers(account_)))) + if ((!sle->isFieldPresent(sfRegularKey)) && (!view().peek(keylet::signers(accountID_)))) { // Account has no regular key or multi-signer signer list. return tecNO_ALTERNATIVE_KEY; @@ -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; @@ -574,7 +559,7 @@ AccountSet::doApply() if (tx.isFieldPresent(sfTickSize)) { auto uTickSize = tx[sfTickSize]; - if ((uTickSize == 0) || (uTickSize == Quality::kMAX_TICK_SIZE)) + if ((uTickSize == 0) || (uTickSize == Quality::kMaxTickSize)) { JLOG(j_.trace()) << "unset tick size"; sle->makeFieldAbsent(sfTickSize); @@ -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..66a0bef336 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}; @@ -55,7 +55,7 @@ SetRegularKey::preflight(PreflightContext const& ctx) TER SetRegularKey::doApply() { - auto const sle = view().peek(keylet::account(account_)); + auto const sle = view().peek(keylet::account(accountID_)); if (!sle) return tefINTERNAL; // LCOV_EXCL_LINE @@ -69,7 +69,7 @@ SetRegularKey::doApply() else { // Account has disabled master key and no multi-signer signer list. - if (sle->isFlag(lsfDisableMaster) && !view().peek(keylet::signers(account_))) + if (sle->isFlag(lsfDisableMaster) && !view().peek(keylet::signers(accountID_))) return tecNO_ALTERNATIVE_KEY; sle->makeFieldAbsent(sfRegularKey); @@ -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..7a5d2c60b0 100644 --- a/src/libxrpl/tx/transactors/account/SignerListSet.cpp +++ b/src/libxrpl/tx/transactors/account/SignerListSet.cpp @@ -37,7 +37,7 @@ namespace xrpl { // We're prepared for there to be multiple signer lists in the future, // but we don't need them yet. So for the time being we're manually // setting the sfSignerListID to zero in all cases. -static std::uint32_t const kDEFAULT_SIGNER_LIST_ID = 0; +static std::uint32_t const kDefaultSignerListId = 0; std::tuple, SignerListSet::Operation> SignerListSet::determineOperation(STTx const& tx, ApplyFlags flags, beast::Journal j) @@ -168,10 +168,10 @@ signerCountBasedOwnerCountDelta(std::size_t entryCount, Rules const& rules) // be in the range from 1 to 32. // We've got a lot of room to grow. XRPL_ASSERT( - entryCount >= STTx::kMIN_MULTI_SIGNERS, + entryCount >= STTx::kMinMultiSigners, "xrpl::signerCountBasedOwnerCountDelta : minimum signers"); XRPL_ASSERT( - entryCount <= STTx::kMAX_MULTI_SIGNERS, + entryCount <= STTx::kMaxMultiSigners, "xrpl::signerCountBasedOwnerCountDelta : maximum signers"); return 2 + static_cast(entryCount); } @@ -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 = @@ -249,7 +249,7 @@ SignerListSet::validateQuorumAndSignerEntries( // Reject if there are too many or too few entries in the list. { std::size_t const signerCount = signers.size(); - if (signerCount < STTx::kMIN_MULTI_SIGNERS || signerCount > STTx::kMAX_MULTI_SIGNERS) + if (signerCount < STTx::kMinMultiSigners || signerCount > STTx::kMaxMultiSigners) { JLOG(j.trace()) << "Too many or too few signers in signer list."; return temMALFORMED; @@ -300,9 +300,9 @@ SignerListSet::validateQuorumAndSignerEntries( TER SignerListSet::replaceSignerList() { - auto const accountKeylet = keylet::account(account_); - auto const ownerDirKeylet = keylet::ownerDir(account_); - auto const signerListKeylet = keylet::signers(account_); + auto const accountKeylet = keylet::account(accountID_); + auto const ownerDirKeylet = keylet::ownerDir(accountID_); + auto const signerListKeylet = keylet::signers(accountID_); // This may be either a create or a replace. Preemptively remove any // old signer list. May reduce the reserve, so this is done before @@ -318,10 +318,10 @@ SignerListSet::replaceSignerList() // Compute new reserve. Verify the account has funds to meet the reserve. std::uint32_t const oldOwnerCount{(*sle)[sfOwnerCount]}; - constexpr int kADDED_OWNER_COUNT = 1; + static constexpr int kAddedOwnerCount = 1; std::uint32_t const flags{lsfOneOwnerCount}; - XRPAmount const newReserve{view().fees().accountReserve(oldOwnerCount + kADDED_OWNER_COUNT)}; + XRPAmount const newReserve{view().fees().accountReserve(oldOwnerCount + kAddedOwnerCount)}; // We check the reserve against the starting balance because we want to // allow dipping into the reserve to pay fees. This behavior is consistent @@ -337,9 +337,9 @@ SignerListSet::replaceSignerList() auto viewJ = ctx_.registry.get().getJournal("View"); // Add the signer list to the account's directory. auto const page = - ctx_.view().dirInsert(ownerDirKeylet, signerListKeylet, describeOwnerDir(account_)); + ctx_.view().dirInsert(ownerDirKeylet, signerListKeylet, describeOwnerDir(accountID_)); - JLOG(j_.trace()) << "Create signer list for account " << toBase58(account_) << ": " + JLOG(j_.trace()) << "Create signer list for account " << toBase58(accountID_) << ": " << (page ? "success" : "failure"); if (!page) @@ -349,14 +349,14 @@ SignerListSet::replaceSignerList() // If we succeeded, the new entry counts against the // creator's reserve. - adjustOwnerCount(view(), sle, kADDED_OWNER_COUNT, viewJ); + adjustOwnerCount(view(), sle, kAddedOwnerCount, viewJ); return tesSUCCESS; } TER SignerListSet::destroySignerList() { - auto const accountKeylet = keylet::account(account_); + auto const accountKeylet = keylet::account(accountID_); // Destroying the signer list is only allowed if either the master key // is enabled or there is a regular key. SLE::pointer const ledgerEntry = view().peek(accountKeylet); @@ -366,8 +366,8 @@ SignerListSet::destroySignerList() if ((ledgerEntry->isFlag(lsfDisableMaster)) && (!ledgerEntry->isFieldPresent(sfRegularKey))) return tecNO_ALTERNATIVE_KEY; - auto const ownerDirKeylet = keylet::ownerDir(account_); - auto const signerListKeylet = keylet::signers(account_); + auto const ownerDirKeylet = keylet::ownerDir(accountID_); + auto const signerListKeylet = keylet::signers(accountID_); return removeSignersFromLedger( ctx_.registry, view(), accountKeylet, ownerDirKeylet, signerListKeylet, j_); } @@ -378,10 +378,10 @@ SignerListSet::writeSignersToSLE(SLE::pointer const& ledgerEntry, std::uint32_t // Assign the quorum, default SignerListID, and flags. if (ctx_.view().rules().enabled(fixIncludeKeyletFields)) { - ledgerEntry->setAccountID(sfOwner, account_); + ledgerEntry->setAccountID(sfOwner, accountID_); } ledgerEntry->setFieldU32(sfSignerQuorum, quorum_); - ledgerEntry->setFieldU32(sfSignerListID, kDEFAULT_SIGNER_LIST_ID); + ledgerEntry->setFieldU32(sfSignerListID, kDefaultSignerListId); if (flags != 0u) // Only set flags if they are non-default (default is zero). ledgerEntry->setFieldU32(sfFlags, flags); @@ -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..76b274a609 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; @@ -981,7 +981,7 @@ applyCreateAccountAttestations( { return tecXCHAIN_ACCOUNT_CREATE_PAST; } - if (attBegin->createCount >= claimCount + kXBRIDGE_MAX_ACCOUNT_CREATE_CLAIMS) + if (attBegin->createCount >= claimCount + kXbridgeMaxAccountCreateClaims) { // Limit the number of claims on the account return tecXCHAIN_ACCOUNT_CREATE_TOO_MANY; @@ -1369,9 +1369,9 @@ XChainCreateBridge::preflight(PreflightContext const& ctx) // Issuing account must be the root account for XRP (which presumably // owns all the XRP). This is done so the issuing account can't "run // out" of wrapped tokens. - static auto const kROOT_ACCOUNT = calcAccountID( + static auto const kRootAccount = calcAccountID( generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase")).first); - if (bridgeSpec.issuingChainDoor() != kROOT_ACCOUNT) + if (bridgeSpec.issuingChainDoor() != kRootAccount) { return temXCHAIN_BRIDGE_BAD_ISSUES; } @@ -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) @@ -1826,7 +1826,7 @@ XChainCommit::makeTxConsequences(PreflightContext const& ctx) auto const amount = ctx.tx[sfAmount]; if (amount.native() && amount.signum() > 0) return amount.xrp(); - return XRPAmount{beast::kZERO}; + return XRPAmount{beast::kZero}; }(); return TxConsequences{ctx.tx, maxSpend}; @@ -1920,7 +1920,7 @@ XChainCommit::doApply() // Support dipping into reserves to pay the fee TransferHelperSubmittingAccountInfo submittingAccountInfo{ - .account = account_, + .account = accountID_, .preFeeBalance = preFeeBalance_, .postFeeBalance = (*sleAccount)[sfBalance]}; @@ -2197,7 +2197,9 @@ XChainCreateAccountCommit::doApply() // Support dipping into reserves to pay the fee TransferHelperSubmittingAccountInfo submittingAccountInfo{ - .account = account_, .preFeeBalance = preFeeBalance_, .postFeeBalance = (*sle)[sfBalance]}; + .account = accountID_, + .preFeeBalance = preFeeBalance_, + .postFeeBalance = (*sle)[sfBalance]}; STAmount const toTransfer = amount + reward; auto const thTer = transferHelper( psb, @@ -2228,6 +2230,7 @@ XChainCreateBridge::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2238,6 +2241,7 @@ XChainCreateBridge::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2247,6 +2251,7 @@ BridgeModify::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2257,6 +2262,7 @@ BridgeModify::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2266,11 +2272,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 +2288,7 @@ XChainCommit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2290,6 +2299,7 @@ XChainCommit::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2299,6 +2309,7 @@ XChainCreateClaimID::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2309,6 +2320,7 @@ XChainCreateClaimID::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2318,6 +2330,7 @@ XChainAddClaimAttestation::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2328,6 +2341,7 @@ XChainAddClaimAttestation::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2337,6 +2351,7 @@ XChainAddAccountCreateAttestation::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2347,6 +2362,7 @@ XChainAddAccountCreateAttestation::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } @@ -2356,6 +2372,7 @@ XChainCreateAccountCommit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -2366,6 +2383,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 34288425a5..af903ff177 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. @@ -140,6 +139,11 @@ CheckCash::preclaim(PreclaimContext const& ctx) }(ctx.tx)}; STAmount const sendMax = sleCheck->at(sfSendMax); + // A legacy Check may contain a non-canonical MPT sfSendMax. Universal + // preflight only validates the CheckCash transaction, not the stored Check. + if (ctx.view.rules().enabled(fixCleanup3_2_0) && !isLegalMPT(sendMax)) + return tefBAD_LEDGER; + if (!equalTokens(value.asset(), sendMax.asset())) { JLOG(ctx.j.warn()) << "Check cash does not match check currency."; @@ -200,7 +204,7 @@ CheckCash::preclaim(PreclaimContext const& ctx) return tecNO_ISSUER; } - if ((sleIssuer->at(sfFlags) & lsfRequireAuth) != 0u) + if (sleIssuer->isFlag(lsfRequireAuth)) { if (!sleTrustLine) { @@ -265,9 +269,10 @@ CheckCash::preclaim(PreclaimContext const& ctx) return tecLOCKED; } - if (auto const err = canTrade(ctx.view, value.asset()); !isTesSuccess(err)) + if (auto const err = canTransfer(ctx.view, issue, srcId, dstId); + !isTesSuccess(err)) { - JLOG(ctx.j.warn()) << "MPT DEX is not allowed."; + JLOG(ctx.j.warn()) << "MPT transfer is disabled."; return err; } @@ -295,7 +300,7 @@ CheckCash::doApply() } AccountID const srcId{sleCheck->getAccountID(sfAccount)}; - if (!psb.exists(keylet::account(srcId)) || !psb.exists(keylet::account(account_))) + if (!psb.exists(keylet::account(srcId)) || !psb.exists(keylet::account(accountID_))) { // LCOV_EXCL_START JLOG(ctx_.journal.fatal()) << "Precheck did not verify source or destination's existence."; @@ -316,7 +321,7 @@ CheckCash::doApply() auto viewJ = ctx_.registry.get().getJournal("View"); auto const optDeliverMin = ctx_.tx[~sfDeliverMin]; - if (srcId != account_) + if (srcId != accountID_) { STAmount const sendMax = sleCheck->at(sfSendMax); @@ -354,7 +359,7 @@ CheckCash::doApply() } // The source account has enough XRP so make the ledger change. - if (TER const ter{transferXRP(psb, srcId, account_, xrpDeliver, viewJ)}; + if (TER const ter{transferXRP(psb, srcId, accountID_, xrpDeliver, viewJ)}; !isTesSuccess(ter)) { // The transfer failed. Return the error code. @@ -372,12 +377,10 @@ CheckCash::doApply() return optDeliverMin->asset().visit( [&](Issue const&) { return STAmount( - optDeliverMin->asset(), - STAmount::kMAX_VALUE / 2, - STAmount::kMAX_OFFSET); + optDeliverMin->asset(), STAmount::kMaxValue / 2, STAmount::kMaxOffset); }, [&](MPTIssue const&) { - return STAmount(optDeliverMin->asset(), kMAX_MP_TOKEN_AMOUNT / 2); + return STAmount(optDeliverMin->asset(), kMaxMpTokenAmount / 2); }); }; STAmount const flowDeliver{ @@ -386,7 +389,7 @@ CheckCash::doApply() // Check reserve. Return destination account SLE if enough reserve, // otherwise return nullptr. auto checkReserve = [&]() -> std::shared_ptr { - auto sleDst = psb.peek(keylet::account(account_)); + auto sleDst = psb.peek(keylet::account(accountID_)); // Can the account cover the trust line's or MPT reserve? if (std::uint32_t const ownerCount = {sleDst->at(sfOwnerCount)}; @@ -408,9 +411,9 @@ CheckCash::doApply() [&](Issue const& issue) -> std::optional { // If a trust line does not exist yet create one. Issue const& trustLineIssue = issue; - AccountID const truster = deliverIssuer == account_ ? srcId : account_; + AccountID const truster = deliverIssuer == accountID_ ? srcId : accountID_; trustLineKey = keylet::line(truster, trustLineIssue); - destLow = deliverIssuer > account_; + destLow = deliverIssuer > accountID_; if (!psb.exists(*trustLineKey)) { @@ -433,21 +436,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 + accountID_, // 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, accountID_), // limit of zero + 0, // quality in + 0, // quality out + viewJ); // journal !isTesSuccess(ter)) { return ter; @@ -476,24 +479,24 @@ CheckCash::doApply() // Set the trust line limit to the highest possible // value while flow runs. STAmount const bigAmount( - trustLineIssue, STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET); + trustLineIssue, STAmount::kMaxValue, STAmount::kMaxOffset); sleTrustLine->at(tweakedLimit) = bigAmount; return std::nullopt; }, [&](MPTIssue const& issue) -> std::optional { - if (account_ != deliverIssuer) + if (accountID_ != deliverIssuer) { auto const& mptID = issue.getMptID(); // Create MPT if it doesn't exist - auto const mptokenKey = keylet::mptoken(mptID, account_); + auto const mptokenKey = keylet::mptoken(mptID, accountID_); if (!psb.exists(mptokenKey)) { auto sleDst = checkReserve(); if (sleDst == nullptr) return tecINSUFFICIENT_RESERVE; - if (auto const err = checkCreateMPT(psb, mptID, account_, j_); + if (auto const err = checkCreateMPT(psb, mptID, accountID_, j_); !isTesSuccess(err)) { return err; @@ -521,7 +524,7 @@ CheckCash::doApply() psb, flowDeliver, srcId, - account_, + accountID_, STPathSet{}, true, // default path static_cast(optDeliverMin), // partial payment @@ -559,9 +562,9 @@ CheckCash::doApply() // Check was cashed. If not a self send (and it shouldn't be), remove // check link from destination directory. - if (srcId != account_ && + if (srcId != accountID_ && !psb.dirRemove( - keylet::ownerDir(account_), sleCheck->at(sfDestinationNode), sleCheck->key(), true)) + keylet::ownerDir(accountID_), sleCheck->at(sfDestinationNode), sleCheck->key(), true)) { // LCOV_EXCL_START JLOG(j_.fatal()) << "Unable to delete check from destination."; @@ -594,11 +597,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 6a13819615..d2d84536de 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. @@ -113,10 +111,10 @@ CheckCreate::preclaim(PreclaimContext const& ctx) { // The currency may not be globally frozen AccountID const& issuerId{sendMax.getIssuer()}; - if (isGlobalFrozen(ctx.view, sendMax.asset())) + if (auto const ter = checkGlobalFrozen(ctx.view, sendMax.asset()); !isTesSuccess(ter)) { - JLOG(ctx.j.warn()) << "Creating a check for frozen asset"; - return sendMax.asset().holds() ? tecLOCKED : tecFROZEN; + JLOG(ctx.j.warn()) << "Creating a check for frozen or locked asset"; + return ter; } auto const err = sendMax.asset().visit( [&](Issue const& issue) -> std::optional { @@ -155,9 +153,21 @@ CheckCreate::preclaim(PreclaimContext const& ctx) }, [&](MPTIssue const& issue) -> std::optional { if (srcId != issuerId && isFrozen(ctx.view, srcId, issue)) + { + JLOG(ctx.j.warn()) << "Creating a check for locked MPT."; return tecLOCKED; + } if (dstId != issuerId && isFrozen(ctx.view, dstId, issue)) + { + JLOG(ctx.j.warn()) << "Creating a check for locked MPT."; return tecLOCKED; + } + if (auto const ter = canTransfer(ctx.view, issue, srcId, dstId); + !isTesSuccess(ter)) + { + JLOG(ctx.j.warn()) << "MPT transfer is disabled."; + return ter; + } return std::nullopt; }); @@ -171,13 +181,13 @@ CheckCreate::preclaim(PreclaimContext const& ctx) return tecEXPIRED; } - return canTrade(ctx.view, ctx.tx[sfSendMax].asset()); + return tesSUCCESS; } TER CheckCreate::doApply() { - auto const sle = view().peek(keylet::account(account_)); + auto const sle = view().peek(keylet::account(accountID_)); if (!sle) return tefINTERNAL; // LCOV_EXCL_LINE @@ -194,10 +204,10 @@ CheckCreate::doApply() // Note that we use the value from the sequence or ticket as the // Check sequence. For more explanation see comments in SeqProxy.h. std::uint32_t const seq = ctx_.tx.getSeqValue(); - Keylet const checkKeylet = keylet::check(account_, seq); + Keylet const checkKeylet = keylet::check(accountID_, seq); auto sleCheck = std::make_shared(checkKeylet); - sleCheck->setAccountID(sfAccount, account_); + sleCheck->setAccountID(sfAccount, accountID_); AccountID const dstAccountId = ctx_.tx[sfDestination]; sleCheck->setAccountID(sfDestination, dstAccountId); sleCheck->setFieldU32(sfSequence, seq); @@ -216,7 +226,7 @@ CheckCreate::doApply() auto viewJ = ctx_.registry.get().getJournal("View"); // If it's not a self-send (and it shouldn't be), add Check to the // destination's owner directory. - if (dstAccountId != account_) + if (dstAccountId != accountID_) { auto const page = view().dirInsert( keylet::ownerDir(dstAccountId), checkKeylet, describeOwnerDir(dstAccountId)); @@ -231,8 +241,8 @@ CheckCreate::doApply() } { - auto const page = - view().dirInsert(keylet::ownerDir(account_), checkKeylet, describeOwnerDir(account_)); + auto const page = view().dirInsert( + keylet::ownerDir(accountID_), checkKeylet, describeOwnerDir(accountID_)); JLOG(j_.trace()) << "Adding Check to owner directory " << to_string(checkKeylet.key) << ": " << (page ? "success" : "failure"); @@ -253,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..4e9857d782 100644 --- a/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp +++ b/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp @@ -43,7 +43,7 @@ CredentialAccept::preflight(PreflightContext const& ctx) } auto const credType = ctx.tx[sfCredentialType]; - if (credType.empty() || (credType.size() > kMAX_CREDENTIAL_TYPE_LENGTH)) + if (credType.empty() || (credType.size() > kMaxCredentialTypeLength)) { JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType."; return temMALFORMED; @@ -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; @@ -89,7 +89,7 @@ CredentialAccept::doApply() AccountID const issuer{ctx_.tx[sfIssuer]}; // Both exist as credential object exist itself (checked in preclaim) - auto const sleSubject = view().peek(keylet::account(account_)); + auto const sleSubject = view().peek(keylet::account(accountID_)); auto const sleIssuer = view().peek(keylet::account(issuer)); if (!sleSubject || !sleIssuer) @@ -103,10 +103,12 @@ CredentialAccept::doApply() } auto const credType(ctx_.tx[sfCredentialType]); - Keylet const credentialKey = keylet::credential(account_, issuer, credType); + Keylet const credentialKey = keylet::credential(accountID_, 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..bcb0a6fefa 100644 --- a/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp +++ b/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp @@ -62,14 +62,14 @@ CredentialCreate::preflight(PreflightContext const& ctx) } auto const uri = tx[~sfURI]; - if (uri && (uri->empty() || (uri->size() > kMAX_CREDENTIAL_URI_LENGTH))) + if (uri && (uri->empty() || (uri->size() > kMaxCredentialUriLength))) { JLOG(j.trace()) << "Malformed transaction: invalid size of URI."; return temMALFORMED; } auto const credType = tx[sfCredentialType]; - if (credType.empty() || (credType.size() > kMAX_CREDENTIAL_TYPE_LENGTH)) + if (credType.empty() || (credType.size() > kMaxCredentialTypeLength)) { JLOG(j.trace()) << "Malformed transaction: invalid size of CredentialType."; return temMALFORMED; @@ -104,7 +104,7 @@ CredentialCreate::doApply() { auto const subject = ctx_.tx[sfSubject]; auto const credType(ctx_.tx[sfCredentialType]); - Keylet const credentialKey = keylet::credential(subject, account_, credType); + Keylet const credentialKey = keylet::credential(subject, accountID_, credType); auto const sleCred = std::make_shared(credentialKey); if (!sleCred) @@ -126,7 +126,7 @@ CredentialCreate::doApply() sleCred->setFieldU32(sfExpiration, *optExp); } - auto const sleIssuer = view().peek(keylet::account(account_)); + auto const sleIssuer = view().peek(keylet::account(accountID_)); if (!sleIssuer) return tefINTERNAL; // LCOV_EXCL_LINE @@ -138,15 +138,15 @@ CredentialCreate::doApply() } sleCred->setAccountID(sfSubject, subject); - sleCred->setAccountID(sfIssuer, account_); + sleCred->setAccountID(sfIssuer, accountID_); sleCred->setFieldVL(sfCredentialType, credType); if (ctx_.tx.isFieldPresent(sfURI)) sleCred->setFieldVL(sfURI, ctx_.tx.getFieldVL(sfURI)); { - auto const page = - view().dirInsert(keylet::ownerDir(account_), credentialKey, describeOwnerDir(account_)); + auto const page = view().dirInsert( + keylet::ownerDir(accountID_), credentialKey, describeOwnerDir(accountID_)); JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key) << ": " << (page ? "success" : "failure"); if (!page) @@ -156,7 +156,7 @@ CredentialCreate::doApply() adjustOwnerCount(view(), sleIssuer, 1, j_); } - if (subject == account_) + if (subject == accountID_) { sleCred->setFieldU32(sfFlags, lsfAccepted); } @@ -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..fcd1848cbe 100644 --- a/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp +++ b/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp @@ -52,7 +52,7 @@ CredentialDelete::preflight(PreflightContext const& ctx) } auto const credType = ctx.tx[sfCredentialType]; - if (credType.empty() || (credType.size() > kMAX_CREDENTIAL_TYPE_LENGTH)) + if (credType.empty() || (credType.size() > kMaxCredentialTypeLength)) { JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType."; return temMALFORMED; @@ -78,16 +78,16 @@ CredentialDelete::preclaim(PreclaimContext const& ctx) TER CredentialDelete::doApply() { - auto const subject = ctx_.tx[~sfSubject].value_or(account_); - auto const issuer = ctx_.tx[~sfIssuer].value_or(account_); + auto const subject = ctx_.tx[~sfSubject].value_or(accountID_); + auto const issuer = ctx_.tx[~sfIssuer].value_or(accountID_); auto const credType(ctx_.tx[sfCredentialType]); auto const sleCred = view().peek(keylet::credential(subject, issuer, credType)); if (!sleCred) return tefINTERNAL; // LCOV_EXCL_LINE - if ((subject != account_) && (issuer != account_) && - !checkExpired(sleCred, ctx_.view().header().parentCloseTime)) + if ((subject != accountID_) && (issuer != accountID_) && + !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..30d703686c 100644 --- a/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp +++ b/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp @@ -25,7 +25,7 @@ NotTEC DelegateSet::preflight(PreflightContext const& ctx) { auto const& permissions = ctx.tx.getFieldArray(sfPermissions); - if (permissions.size() > kPERMISSION_MAX_SIZE) + if (permissions.size() > kPermissionMaxSize) return temARRAY_TOO_LARGE; // can not authorize self @@ -68,12 +68,12 @@ DelegateSet::preclaim(PreclaimContext const& ctx) TER DelegateSet::doApply() { - auto const sleOwner = ctx_.view().peek(keylet::account(account_)); + auto const sleOwner = ctx_.view().peek(keylet::account(accountID_)); if (!sleOwner) return tefINTERNAL; // LCOV_EXCL_LINE auto const& authAccount = ctx_.tx[sfAuthorize]; - auto const delegateKey = keylet::delegate(account_, authAccount); + auto const delegateKey = keylet::delegate(accountID_, authAccount); auto sle = ctx_.view().peek(delegateKey); if (sle) @@ -101,22 +101,22 @@ DelegateSet::doApply() return tecINSUFFICIENT_RESERVE; sle = std::make_shared(delegateKey); - sle->setAccountID(sfAccount, account_); + sle->setAccountID(sfAccount, accountID_); sle->setAccountID(sfAuthorize, authAccount); sle->setFieldArray(sfPermissions, permissions); // Add to delegating account's owner directory - auto const page = - ctx_.view().dirInsert(keylet::ownerDir(account_), delegateKey, describeOwnerDir(account_)); + auto const page = ctx_.view().dirInsert( + keylet::ownerDir(accountID_), delegateKey, describeOwnerDir(accountID_)); if (!page) return tecDIR_FULL; // LCOV_EXCL_LINE (*sle)[sfOwnerNode] = *page; - // Add to authorized account's owner directory so the object can be found - // and cleaned up when the authorized account is deleted. + // Add to authorized account's owner directory so AccountDelete can find + // and clean up inbound delegations when the authorized account is deleted. auto const destPage = ctx_.view().dirInsert( keylet::ownerDir(authAccount), delegateKey, describeOwnerDir(authAccount)); @@ -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..b3b41fbfa2 100644 --- a/src/libxrpl/tx/transactors/dex/AMMBid.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMBid.cpp @@ -77,7 +77,7 @@ AMMBid::preflight(PreflightContext const& ctx) if (ctx.tx.isFieldPresent(sfAuthAccounts)) { auto const authAccounts = ctx.tx.getFieldArray(sfAuthAccounts); - if (authAccounts.size() > kAUCTION_SLOT_MAX_AUTH_ACCOUNTS) + if (authAccounts.size() > kAuctionSlotMaxAuthAccounts) { JLOG(ctx.j.debug()) << "AMM Bid: Invalid number of AuthAccounts."; return temMALFORMED; @@ -113,7 +113,7 @@ AMMBid::preclaim(PreclaimContext const& ctx) } auto const lpTokensBalance = (*ammSle)[sfLPTokenBalance]; - if (lpTokensBalance == beast::kZERO) + if (lpTokensBalance == beast::kZero) return tecAMM_EMPTY; if (ctx.tx.isFieldPresent(sfAuthAccounts)) @@ -130,7 +130,7 @@ AMMBid::preclaim(PreclaimContext const& ctx) auto const lpTokens = ammLPHolds(ctx.view, *ammSle, ctx.tx[sfAccount], ctx.j); // Not LP - if (lpTokens == beast::kZERO) + if (lpTokens == beast::kZero) { JLOG(ctx.j.debug()) << "AMM Bid: account is not LP."; return tecAMM_INVALID_TOKENS; @@ -201,12 +201,12 @@ applyBid(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journa auto const current = duration_cast(ctx.view().header().parentCloseTime.time_since_epoch()).count(); // Auction slot discounted fee - auto const discountedFee = (*ammSle)[sfTradingFee] / kAUCTION_SLOT_DISCOUNTED_FEE_FRACTION; + auto const discountedFee = (*ammSle)[sfTradingFee] / kAuctionSlotDiscountedFeeFraction; auto const tradingFee = getFee((*ammSle)[sfTradingFee]); // Min price - auto const minSlotPrice = lptAMMBalance * tradingFee / kAUCTION_SLOT_MIN_FEE_FRACTION; + auto const minSlotPrice = lptAMMBalance * tradingFee / kAuctionSlotMinFeeFraction; - std::uint32_t constexpr kTAILING_SLOT = kAUCTION_SLOT_TIME_INTERVALS - 1; + static constexpr std::uint32_t kTailingSlot = kAuctionSlotTimeIntervals - 1; // If seated then it is the current slot-holder time slot, otherwise // the auction slot is not owned. Slot range is in {0-19} @@ -216,12 +216,12 @@ applyBid(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journa auto validOwner = [&](AccountID const& account) { // Valid range is 0-19 but the tailing slot pays MinSlotPrice // and doesn't refund so the check is < instead of <= to optimize. - return timeSlot && *timeSlot < kTAILING_SLOT && sb.read(keylet::account(account)); + return timeSlot && *timeSlot < kTailingSlot && sb.read(keylet::account(account)); }; auto updateSlot = [&](std::uint32_t fee, Number const& minPrice, Number const& burn) -> TER { auctionSlot.setAccountID(sfAccount, account); - auctionSlot.setFieldU32(sfExpiration, current + kTOTAL_TIME_SLOT_SECS); + auctionSlot.setFieldU32(sfExpiration, current + kTotalTimeSlotSecs); if (fee != 0) { auctionSlot.setFieldU16(sfDiscountedFee, fee); @@ -322,7 +322,7 @@ applyBid(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journa STAmount const pricePurchased = auctionSlot[sfPrice]; XRPL_ASSERT(timeSlot, "xrpl::applyBid : timeSlot is set"); // NOLINTBEGIN(bugprone-unchecked-optional-access) - auto const fractionUsed = (Number(*timeSlot) + 1) / kAUCTION_SLOT_TIME_INTERVALS; + auto const fractionUsed = (Number(*timeSlot) + 1) / kAuctionSlotTimeIntervals; auto const fractionRemaining = Number(1) - fractionUsed; auto const computedPrice = [&]() -> Number { auto const p105 = Number(105, -2); @@ -371,7 +371,7 @@ AMMBid::doApply() // as we go on processing transactions. Sandbox sb(&ctx_.view()); - auto const result = applyBid(ctx_, sb, account_, j_); + auto const result = applyBid(ctx_, sb, accountID_, j_); if (result.second) sb.apply(ctx_.rawView()); @@ -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..43abc6ae29 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"; @@ -94,7 +92,7 @@ AMMClawback::preflight(PreflightContext const& ctx) return temBAD_AMOUNT; } - if (clawAmount && *clawAmount <= beast::kZERO) + if (clawAmount && *clawAmount <= beast::kZero) return temBAD_AMOUNT; return tesSUCCESS; @@ -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())); @@ -191,7 +187,7 @@ AMMClawback::applyGuts(Sandbox& sb) { // retrieve LP token balance inside the amendment gate to avoid inconsistent error behavior auto const lpTokenBalance = ammLPHolds(sb, *ammSle, holder, j_); - if (lpTokenBalance == beast::kZERO) + if (lpTokenBalance == beast::kZero) return tecAMM_BALANCE; if (auto const res = verifyAndAdjustLPTokenBalance(sb, lpTokenBalance, ammSle, holder); @@ -220,7 +216,7 @@ AMMClawback::applyGuts(Sandbox& sb) // calling a second time on purpose since `verifyAndAdjustLPTokenBalance` rounds and may adjust // the balance auto const holdLPtokens = ammLPHolds(sb, *ammSle, holder, j_); - if (holdLPtokens == beast::kZERO) + if (holdLPtokens == beast::kZero) return tecAMM_BALANCE; if (!clawAmount) @@ -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; @@ -340,7 +335,7 @@ AMMClawback::equalWithdrawMatchingOneAmount( auto tokensAdj = getRoundedLPTokens(rules, lptAMMBalance, frac, IsDeposit::No); // LCOV_EXCL_START - if (tokensAdj == beast::kZERO) + if (tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}, STAmount{}, std::nullopt}; // LCOV_EXCL_STOP @@ -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 c90ea0a6ab..60508eab85 100644 --- a/src/libxrpl/tx/transactors/dex/AMMCreate.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include @@ -76,7 +75,7 @@ AMMCreate::preflight(PreflightContext const& ctx) return err; } - if (ctx.tx[sfTradingFee] > kTRADING_FEE_THRESHOLD) + if (ctx.tx[sfTradingFee] > kTradingFeeThreshold) { JLOG(ctx.j.debug()) << "AMM Instance: invalid trading fee."; return temBAD_FEE; @@ -120,11 +119,16 @@ AMMCreate::preclaim(PreclaimContext const& ctx) } // Globally or individually frozen - if (isFrozen(ctx.view, accountID, amount.asset()) || - isFrozen(ctx.view, accountID, amount2.asset())) + if (auto const ter = checkFrozen(ctx.view, accountID, amount.asset()); !isTesSuccess(ter)) + { - JLOG(ctx.j.debug()) << "AMM Instance: involves frozen asset."; - return tecFROZEN; + JLOG(ctx.j.debug()) << "AMM Instance: involves frozen or locked asset."; + return ter; + } + if (auto const ter = checkFrozen(ctx.view, accountID, amount2.asset()); !isTesSuccess(ter)) + { + JLOG(ctx.j.debug()) << "AMM Instance: involves frozen or locked asset."; + return ter; } auto noDefaultRipple = [](ReadView const& view, Asset const& asset) { @@ -132,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; }; @@ -146,7 +150,7 @@ AMMCreate::preclaim(PreclaimContext const& ctx) // Check the reserve for LPToken trustline STAmount const xrpBalance = xrpLiquid(ctx.view, accountID, 1, ctx.j); // Insufficient reserve - if (xrpBalance <= beast::kZERO) + if (xrpBalance <= beast::kZero) { JLOG(ctx.j.debug()) << "AMM Instance: insufficient reserves"; return tecINSUF_RESERVE_LINE; @@ -187,14 +191,14 @@ AMMCreate::preclaim(PreclaimContext const& ctx) { if (auto const accountId = pseudoAccountAddress(ctx.view, keylet::amm(amount.asset(), amount2.asset()).key); - accountId == beast::kZERO) + accountId == beast::kZero) return terADDRESS_COLLISION; } - if (auto const ter = checkMPTTxAllowed(ctx.view, ttAMM_CREATE, amount.asset(), accountID); + if (auto const ter = canMPTTradeAndTransfer(ctx.view, amount.asset(), accountID, accountID); !isTesSuccess(ter)) return ter; - if (auto const ter = checkMPTTxAllowed(ctx.view, ttAMM_CREATE, amount2.asset(), accountID); + if (auto const ter = canMPTTradeAndTransfer(ctx.view, amount2.asset(), accountID, accountID); !isTesSuccess(ter)) return ter; @@ -301,22 +305,14 @@ applyCreate(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Jou // Authorize MPT return amount.asset().visit( [&](MPTIssue const& issue) -> TER { - // Authorize MPT auto const& mptIssue = issue; auto const& mptID = mptIssue.getMptID(); - std::uint32_t flags = lsfMPTAMM; - if (auto const err = - requireAuth(ctx.view(), mptIssue, accountId, AuthType::WeakAuth); + // Implicitly authorize MPT asset for AMM pseudo-account. + std::uint32_t const flags = lsfMPTAMM | lsfMPTAuthorized; + if (auto const err = requireAuth(sb, mptIssue, accountId, AuthType::WeakAuth); !isTesSuccess(err)) { - if (err == tecNO_AUTH) - { - flags |= lsfMPTAuthorized; - } - else - { - return err; - } + return err; } if (auto const err = createMPToken(sb, mptID, accountId, flags); !isTesSuccess(err)) @@ -368,7 +364,7 @@ applyCreate(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Jou << lpTokens << " " << amount << " " << amount2; auto addOrderBook = [&](Asset const& assetIn, Asset const& assetOut, std::uint64_t uRate) { Book const book{assetIn, assetOut, std::nullopt}; - auto const dir = keylet::quality(keylet::kBOOK(book), uRate); + auto const dir = keylet::quality(keylet::kBook(book), uRate); if (auto const bookExisted = static_cast(sb.read(dir)); !bookExisted) ctx.registry.get().getOrderBookDB().addOrderBook(book); }; @@ -385,7 +381,7 @@ AMMCreate::doApply() // as we go on processing transactions. Sandbox sb(&ctx_.view()); - auto const result = applyCreate(ctx_, sb, account_, j_); + auto const result = applyCreate(ctx_, sb, accountID_, j_); if (result.second) sb.apply(ctx_.rawView()); @@ -398,11 +394,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..8a8cab1c03 100644 --- a/src/libxrpl/tx/transactors/dex/AMMDelete.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMDelete.cpp @@ -46,7 +46,7 @@ AMMDelete::preclaim(PreclaimContext const& ctx) } auto const lpTokensBalance = (*ammSle)[sfLPTokenBalance]; - if (lpTokensBalance != beast::kZERO) + if (lpTokensBalance != beast::kZero) return tecAMM_NOT_EMPTY; return tesSUCCESS; @@ -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 d2995c309f..f45529f617 100644 --- a/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp @@ -21,7 +21,6 @@ #include #include #include -#include #include #include @@ -75,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; @@ -124,7 +123,7 @@ AMMDeposit::preflight(PreflightContext const& ctx) return temBAD_AMM_TOKENS; } - if (lpTokens && *lpTokens <= beast::kZERO) + if (lpTokens && *lpTokens <= beast::kZero) { JLOG(ctx.j.debug()) << "AMM Deposit: invalid LPTokens"; return temBAD_AMM_TOKENS; @@ -166,7 +165,7 @@ AMMDeposit::preflight(PreflightContext const& ctx) } } - if (tradingFee > kTRADING_FEE_THRESHOLD) + if (tradingFee > kTradingFeeThreshold) { JLOG(ctx.j.debug()) << "AMM Deposit: invalid trading fee."; return temBAD_FEE; @@ -198,11 +197,11 @@ 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) + if (lptAMMBalance != beast::kZero) return tecAMM_NOT_EMPTY; - if (amountBalance != beast::kZERO || amount2Balance != beast::kZERO) + if (amountBalance != beast::kZero || amount2Balance != beast::kZero) { // LCOV_EXCL_START JLOG(ctx.j.debug()) << "AMM Deposit: tokens balance is not zero."; @@ -212,10 +211,10 @@ AMMDeposit::preclaim(PreclaimContext const& ctx) } else { - if (lptAMMBalance == beast::kZERO) + if (lptAMMBalance == beast::kZero) return tecAMM_EMPTY; - if (amountBalance <= beast::kZERO || amount2Balance <= beast::kZERO || - lptAMMBalance < beast::kZERO) + if (amountBalance <= beast::kZero || amount2Balance <= beast::kZero || + lptAMMBalance < beast::kZero) { // LCOV_EXCL_START JLOG(ctx.j.debug()) << "AMM Deposit: reserves or tokens balance is zero."; @@ -267,12 +266,12 @@ AMMDeposit::preclaim(PreclaimContext const& ctx) return ter; } - if (isFrozen(ctx.view, accountID, asset)) + if (auto const ter = checkFrozen(ctx.view, accountID, asset); !isTesSuccess(ter)) { - JLOG(ctx.j.debug()) << "AMM Deposit: account or currency is frozen, " + JLOG(ctx.j.debug()) << "AMM Deposit: account or currency is frozen or locked, " << to_string(accountID) << " " << to_string(asset); - return tecFROZEN; + return ter; } return tesSUCCESS; @@ -304,18 +303,20 @@ AMMDeposit::preclaim(PreclaimContext const& ctx) // LCOV_EXCL_STOP } // AMM account or currency frozen - if (isFrozen(ctx.view, ammAccountID, amount->asset())) + if (auto const ter = checkFrozen(ctx.view, ammAccountID, amount->asset()); + !isTesSuccess(ter)) { - JLOG(ctx.j.debug()) - << "AMM Deposit: AMM account or currency is frozen, " << to_string(accountID); - return tecFROZEN; + JLOG(ctx.j.debug()) << "AMM Deposit: AMM account or currency is frozen or locked, " + << to_string(accountID); + return ter; } // Account frozen - if (isIndividualFrozen(ctx.view, accountID, amount->asset())) + if (auto const ter = checkIndividualFrozen(ctx.view, accountID, amount->asset()); + !isTesSuccess(ter)) { - JLOG(ctx.j.debug()) << "AMM Deposit: account is frozen, " << to_string(accountID) - << " " << to_string(amount->asset()); - return tecFROZEN; + JLOG(ctx.j.debug()) << "AMM Deposit: account is frozen or locked, " + << to_string(accountID) << " " << to_string(amount->asset()); + return ter; } if (checkBalance) { @@ -331,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; @@ -357,21 +358,21 @@ AMMDeposit::preclaim(PreclaimContext const& ctx) // Check the reserve for LPToken trustline if not LP. // We checked above but need to check again if depositing IOU only. - if (ammLPHolds(ctx.view, *ammSle, accountID, ctx.j) == beast::kZERO) + if (ammLPHolds(ctx.view, *ammSle, accountID, ctx.j) == beast::kZero) { STAmount const xrpBalance = xrpLiquid(ctx.view, accountID, 1, ctx.j); // Insufficient reserve - if (xrpBalance <= beast::kZERO) + if (xrpBalance <= beast::kZero) { JLOG(ctx.j.debug()) << "AMM Instance: insufficient reserves"; return tecINSUF_RESERVE_LINE; } } - if (auto const ter = checkMPTTxAllowed(ctx.view, ttAMM_DEPOSIT, ctx.tx[sfAsset], accountID); + if (auto const ter = canMPTTradeAndTransfer(ctx.view, ctx.tx[sfAsset], accountID, accountID); !isTesSuccess(ter)) return ter; - if (auto const ter = checkMPTTxAllowed(ctx.view, ttAMM_DEPOSIT, ctx.tx[sfAsset2], accountID); + if (auto const ter = canMPTTradeAndTransfer(ctx.view, ctx.tx[sfAsset2], accountID, accountID); !isTesSuccess(ter)) return ter; @@ -401,9 +402,9 @@ AMMDeposit::applyGuts(Sandbox& sb) if (!expected) return {expected.error(), false}; // LCOV_EXCL_LINE auto const [amountBalance, amount2Balance, lptAMMBalance] = *expected; - auto const tfee = (lptAMMBalance == beast::kZERO) + auto const tfee = (lptAMMBalance == beast::kZero) ? ctx_.tx[~sfTradingFee].value_or(0) - : getTradingFee(ctx_.view(), *ammSle, account_); + : getTradingFee(ctx_.view(), *ammSle, accountID_); auto const subTxType = ctx_.tx.getFlags() & tfDepositSubTx; @@ -468,13 +469,13 @@ AMMDeposit::applyGuts(Sandbox& sb) if (isTesSuccess(result)) { XRPL_ASSERT( - newLPTokenBalance > beast::kZERO, + newLPTokenBalance > beast::kZero, "xrpl::AMMDeposit::applyGuts : valid new LP token balance"); ammSle->setFieldAmount(sfLPTokenBalance, newLPTokenBalance); // LP depositing into AMM empty state gets the auction slot // and the voting - if (lptAMMBalance == beast::kZERO) - initializeFeeAuctionVote(sb, ammSle, account_, lptAMMBalance.asset(), tfee); + if (lptAMMBalance == beast::kZero) + initializeFeeAuctionVote(sb, ammSle, accountID_, lptAMMBalance.asset(), tfee); sb.update(ammSle); } @@ -513,20 +514,20 @@ AMMDeposit::deposit( // Check account has sufficient funds. // Return true if it does, false otherwise. auto checkBalance = [&](auto const& depositAmount) -> TER { - if (depositAmount <= beast::kZERO) + if (depositAmount <= beast::kZero) return temBAD_AMOUNT; if (isXRP(depositAmount)) { auto const& lpIssue = lpTokensDeposit.get(); // Adjust the reserve if LP doesn't have LPToken trustline - auto const sle = view.read(keylet::line(account_, lpIssue.account, lpIssue.currency)); - if (xrpLiquid(view, account_, !sle, j_) >= depositAmount) + auto const sle = view.read(keylet::line(accountID_, lpIssue.account, lpIssue.currency)); + if (xrpLiquid(view, accountID_, !sle, j_) >= depositAmount) return tesSUCCESS; } else if ( accountFunds( view, - account_, + accountID_, depositAmount, FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, @@ -547,7 +548,7 @@ AMMDeposit::deposit( tfee, IsDeposit::Yes); - if (lpTokensDepositActual <= beast::kZERO) + if (lpTokensDepositActual <= beast::kZero) { JLOG(ctx_.journal.debug()) << "AMM Deposit: adjusted tokens zero"; return {tecAMM_INVALID_TOKENS, STAmount{}}; @@ -574,7 +575,7 @@ AMMDeposit::deposit( } auto res = accountSend( - view, account_, ammAccount, amountDepositActual, ctx_.journal, WaiveTransferFee::Yes); + view, accountID_, ammAccount, amountDepositActual, ctx_.journal, WaiveTransferFee::Yes); if (!isTesSuccess(res)) { JLOG(ctx_.journal.debug()) << "AMM Deposit: failed to deposit " << amountDepositActual; @@ -593,7 +594,12 @@ AMMDeposit::deposit( } res = accountSend( - view, account_, ammAccount, *amount2DepositActual, ctx_.journal, WaiveTransferFee::Yes); + view, + accountID_, + ammAccount, + *amount2DepositActual, + ctx_.journal, + WaiveTransferFee::Yes); if (!isTesSuccess(res)) { JLOG(ctx_.journal.debug()) @@ -603,7 +609,7 @@ AMMDeposit::deposit( } // Deposit LP tokens - res = accountSend(view, ammAccount, account_, lpTokensDepositActual, ctx_.journal); + res = accountSend(view, ammAccount, accountID_, lpTokensDepositActual, ctx_.journal); if (!isTesSuccess(res)) { JLOG(ctx_.journal.debug()) << "AMM Deposit: failed to deposit LPTokens"; @@ -642,7 +648,7 @@ AMMDeposit::equalDepositTokens( try { auto const tokensAdj = adjustLPTokensOut(view.rules(), lptAMMBalance, lpTokensDeposit); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; auto const frac = divide(tokensAdj, lptAMMBalance, lptAMMBalance.asset()); // amounts factor in the adjusted tokens @@ -714,7 +720,7 @@ AMMDeposit::equalDepositLimit( { auto frac = Number{amount} / amountBalance; auto tokensAdj = getRoundedLPTokens(view.rules(), lptAMMBalance, frac, IsDeposit::Yes); - if (tokensAdj == beast::kZERO) + if (tokensAdj == beast::kZero) { if (!view.rules().enabled(fixAMMv1_3)) { @@ -743,7 +749,7 @@ AMMDeposit::equalDepositLimit( } frac = Number{amount2} / amount2Balance; tokensAdj = getRoundedLPTokens(view.rules(), lptAMMBalance, frac, IsDeposit::Yes); - if (tokensAdj == beast::kZERO) + if (tokensAdj == beast::kZero) { if (!view.rules().enabled(fixAMMv1_3)) { @@ -793,7 +799,7 @@ AMMDeposit::singleDeposit( { auto const tokens = adjustLPTokensOut( view.rules(), lptAMMBalance, lpTokensOut(amountBalance, amount, lptAMMBalance, tfee)); - if (tokens == beast::kZERO) + if (tokens == beast::kZero) { if (!view.rules().enabled(fixAMMv1_3)) { @@ -805,7 +811,7 @@ AMMDeposit::singleDeposit( // factor in the adjusted tokens auto const [tokensAdj, amountDepositAdj] = adjustAssetInByTokens(view.rules(), amountBalance, amount, lptAMMBalance, tokens, tfee); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // LCOV_EXCL_LINE return deposit( view, @@ -839,7 +845,7 @@ AMMDeposit::singleDepositTokens( std::uint16_t tfee) { auto const tokensAdj = adjustLPTokensOut(view.rules(), lptAMMBalance, lpTokensDeposit); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // the adjusted tokens are factored in auto const amountDeposit = ammAssetIn(amountBalance, lptAMMBalance, tokensAdj, tfee); @@ -894,11 +900,11 @@ AMMDeposit::singleDepositEPrice( STAmount const& ePrice, std::uint16_t tfee) { - if (amount != beast::kZERO) + if (amount != beast::kZero) { auto const tokens = adjustLPTokensOut( view.rules(), lptAMMBalance, lpTokensOut(amountBalance, amount, lptAMMBalance, tfee)); - if (tokens <= beast::kZERO) + if (tokens <= beast::kZero) { if (!view.rules().enabled(fixAMMv1_3)) { @@ -910,7 +916,7 @@ AMMDeposit::singleDepositEPrice( // factor in the adjusted tokens auto const [tokensAdj, amountDepositAdj] = adjustAssetInByTokens(view.rules(), amountBalance, amount, lptAMMBalance, tokens, tfee); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // LCOV_EXCL_LINE auto const ep = Number{amountDepositAdj} / tokensAdj; if (ep <= ePrice) @@ -958,7 +964,7 @@ AMMDeposit::singleDepositEPrice( auto amtProdCb = [&] { return f1 * solveQuadraticEq(a1, b1, c1); }; auto const amountDeposit = getRoundedAsset(view.rules(), amtNoRoundCb, amountBalance, amtProdCb, IsDeposit::Yes); - if (amountDeposit <= beast::kZERO) + if (amountDeposit <= beast::kZero) return {tecAMM_FAILED, STAmount{}}; auto tokNoRoundCb = [&] { return amountDeposit / ePrice; }; auto tokProdCb = [&] { return amountDeposit / ePrice; }; @@ -967,7 +973,7 @@ AMMDeposit::singleDepositEPrice( // factor in the adjusted tokens auto const [tokensAdj, amountDepositAdj] = adjustAssetInByTokens( view.rules(), amountBalance, amountDeposit, lptAMMBalance, tokens, tfee); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // LCOV_EXCL_LINE return deposit( @@ -1013,11 +1019,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..391f7e1ecc 100644 --- a/src/libxrpl/tx/transactors/dex/AMMVote.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMVote.cpp @@ -47,7 +47,7 @@ AMMVote::preflight(PreflightContext const& ctx) return res; } - if (ctx.tx[sfTradingFee] > kTRADING_FEE_THRESHOLD) + if (ctx.tx[sfTradingFee] > kTradingFeeThreshold) { JLOG(ctx.j.debug()) << "AMM Vote: invalid trading fee."; return temBAD_FEE; @@ -65,12 +65,12 @@ AMMVote::preclaim(PreclaimContext const& ctx) JLOG(ctx.j.debug()) << "AMM Vote: Invalid asset pair."; return terNO_AMM; } - if (ammSle->getFieldAmount(sfLPTokenBalance) == beast::kZERO) + if (ammSle->getFieldAmount(sfLPTokenBalance) == beast::kZero) { return tecAMM_EMPTY; } if (auto const lpTokensNew = ammLPHolds(ctx.view, *ammSle, ctx.tx[sfAccount], ctx.j); - lpTokensNew == beast::kZERO) + lpTokensNew == beast::kZero) { JLOG(ctx.j.debug()) << "AMM Vote: account is not LP."; return tecAMM_INVALID_TOKENS; @@ -80,14 +80,14 @@ AMMVote::preclaim(PreclaimContext const& ctx) } static std::pair -applyVote(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journal j) +applyVote(ApplyContext& ctx, Sandbox& sb, AccountID const& accountID, beast::Journal j) { auto const feeNew = ctx.tx[sfTradingFee]; auto ammSle = sb.peek(keylet::amm(ctx.tx[sfAsset], ctx.tx[sfAsset2])); if (!ammSle) return {tecINTERNAL, false}; STAmount const lptAMMBalance = (*ammSle)[sfLPTokenBalance]; - auto const lpTokensNew = ammLPHolds(sb, *ammSle, account, ctx.journal); + auto const lpTokensNew = ammLPHolds(sb, *ammSle, accountID, ctx.journal); std::optional minTokens; std::size_t minPos{0}; AccountID minAccount{0}; @@ -106,15 +106,15 @@ applyVote(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journ { auto const entryAccount = entry[sfAccount]; auto lpTokens = ammLPHolds(sb, *ammSle, entryAccount, ctx.journal); - if (lpTokens == beast::kZERO) + if (lpTokens == beast::kZero) { - JLOG(j.debug()) << "AMMVote::applyVote, account " << entryAccount << " is not LP"; + JLOG(j.debug()) << "AMMVote::applyVote, accountID " << entryAccount << " is not LP"; continue; } auto feeVal = entry[sfTradingFee]; STObject newEntry = STObject::makeInnerObject(sfVoteEntry); // The account already has the vote entry. - if (entryAccount == account) + if (entryAccount == accountID) { lpTokens = lpTokensNew; feeVal = feeNew; @@ -128,8 +128,7 @@ applyVote(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journ newEntry.setFieldU16(sfTradingFee, feeVal); newEntry.setFieldU32( sfVoteWeight, - static_cast( - Number(lpTokens) * kVOTE_WEIGHT_SCALE_FACTOR / lptAMMBalance)); + static_cast(Number(lpTokens) * kVoteWeightScaleFactor / lptAMMBalance)); // Find an entry with the least tokens/fee. Make the order deterministic // if the tokens/fees are equal. @@ -156,8 +155,8 @@ applyVote(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journ newEntry.setFieldU32( sfVoteWeight, static_cast( - Number(lpTokensNew) * kVOTE_WEIGHT_SCALE_FACTOR / lptAMMBalance)); - newEntry.setAccountID(sfAccount, account); + Number(lpTokensNew) * kVoteWeightScaleFactor / lptAMMBalance)); + newEntry.setAccountID(sfAccount, accountID); num += feeNew * lpTokensNew; den += lpTokensNew; if (minPos) @@ -171,7 +170,7 @@ applyVote(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journ }; // Add new entry if the number of the vote entries // is less than Max. - if (updatedVoteSlots.size() < kVOTE_MAX_SLOTS) + if (updatedVoteSlots.size() < kVoteMaxSlots) { update(); // Add the entry if the account has more tokens than @@ -209,7 +208,7 @@ applyVote(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Journ if (ammSle->isFieldPresent(sfAuctionSlot)) { auto& auctionSlot = ammSle->peekFieldObject(sfAuctionSlot); - if (auto const discountedFee = fee / kAUCTION_SLOT_DISCOUNTED_FEE_FRACTION) + if (auto const discountedFee = fee / kAuctionSlotDiscountedFeeFraction) { auctionSlot.setFieldU16(sfDiscountedFee, discountedFee); } @@ -242,7 +241,7 @@ AMMVote::doApply() // as we go on processing transactions. Sandbox sb(&ctx_.view()); - auto const result = applyVote(ctx_, sb, account_, j_); + auto const result = applyVote(ctx_, sb, accountID_, j_); if (result.second) sb.apply(ctx_.rawView()); @@ -255,11 +254,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 bae9d098a3..352f637f2f 100644 --- a/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp +++ b/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp @@ -7,7 +7,6 @@ #include #include #include -#include #include #include #include @@ -26,7 +25,6 @@ #include #include #include -#include #include #include @@ -83,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; @@ -134,7 +132,7 @@ AMMWithdraw::preflight(PreflightContext const& ctx) return temBAD_AMM_TOKENS; } - if (lpTokens && *lpTokens <= beast::kZERO) + if (lpTokens && *lpTokens <= beast::kZero) { JLOG(ctx.j.debug()) << "AMM Withdraw: invalid tokens."; return temBAD_AMM_TOKENS; @@ -211,10 +209,10 @@ AMMWithdraw::preclaim(PreclaimContext const& ctx) if (!expected) return expected.error(); auto const [amountBalance, amount2Balance, lptAMMBalance] = *expected; - if (lptAMMBalance == beast::kZERO) + if (lptAMMBalance == beast::kZero) return tecAMM_EMPTY; - if (amountBalance <= beast::kZERO || amount2Balance <= beast::kZERO || - lptAMMBalance < beast::kZERO) + if (amountBalance <= beast::kZero || amount2Balance <= beast::kZero || + lptAMMBalance < beast::kZero) { // LCOV_EXCL_START JLOG(ctx.j.debug()) << "AMM Withdraw: reserves or tokens balance is zero."; @@ -242,24 +240,21 @@ AMMWithdraw::preclaim(PreclaimContext const& ctx) return ter; } // AMM account or currency frozen - if (isFrozen(ctx.view, ammAccountID, amount->asset())) + if (auto const ter = checkFrozen(ctx.view, ammAccountID, amount->asset()); + !isTesSuccess(ter)) { - JLOG(ctx.j.debug()) - << "AMM Withdraw: AMM account or currency is frozen, " << to_string(accountID); - return tecFROZEN; + JLOG(ctx.j.debug()) << "AMM Withdraw: AMM account or currency is frozen or locked, " + << to_string(accountID); + return ter; } // Account frozen - if (isIndividualFrozen(ctx.view, accountID, amount->asset())) - { - JLOG(ctx.j.debug()) << "AMM Withdraw: account is frozen, " << to_string(accountID) - << " " << to_string(amount->asset()); - return tecFROZEN; - } - - if (auto const ter = - checkMPTTxAllowed(ctx.view, ttAMM_WITHDRAW, amount->asset(), accountID); + if (auto const ter = checkIndividualFrozen(ctx.view, accountID, amount->asset()); !isTesSuccess(ter)) + { + JLOG(ctx.j.debug()) << "AMM Withdraw: account is frozen or locked, " + << to_string(accountID) << " " << to_string(amount->asset()); return ter; + } } return tesSUCCESS; }; @@ -273,7 +268,7 @@ AMMWithdraw::preclaim(PreclaimContext const& ctx) auto const lpTokens = ammLPHolds(ctx.view, *ammSle, ctx.tx[sfAccount], ctx.j); auto const lpTokensWithdraw = tokensWithdraw(lpTokens, ctx.tx[~sfLPTokenIn], ctx.tx.getFlags()); - if (lpTokens <= beast::kZERO) + if (lpTokens <= beast::kZero) { JLOG(ctx.j.debug()) << "AMM Withdraw: tokens balance is zero."; return tecAMM_BALANCE; @@ -329,11 +324,11 @@ AMMWithdraw::applyGuts(Sandbox& sb) // might not match the LP's trustline balance if (sb.rules().enabled(fixAMMv1_1)) { - if (auto const res = verifyAndAdjustLPTokenBalance(sb, lpTokens, ammSle, account_); !res) + if (auto const res = verifyAndAdjustLPTokenBalance(sb, lpTokens, ammSle, accountID_); !res) return {res.error(), false}; } - auto const tfee = getTradingFee(ctx_.view(), *ammSle, account_); + auto const tfee = getTradingFee(ctx_.view(), *ammSle, accountID_); auto const expected = ammHolds( sb, @@ -458,7 +453,7 @@ AMMWithdraw::withdraw( view, ammSle, ammAccount, - account_, + accountID_, amountBalance, amountWithdraw, amount2Withdraw, @@ -517,7 +512,7 @@ AMMWithdraw::withdraw( return std::make_tuple(amountWithdraw, amount2Withdraw, lpTokensWithdraw); }(); - if (lpTokensWithdrawActual <= beast::kZERO || lpTokensWithdrawActual > lpTokens) + if (lpTokensWithdrawActual <= beast::kZero || lpTokensWithdrawActual > lpTokens) { JLOG(journal.debug()) << "AMM Withdraw: failed to withdraw, invalid LP tokens: " << lpTokensWithdrawActual << " " << lpTokens << " " @@ -576,10 +571,10 @@ AMMWithdraw::withdraw( // or all balances are non-zero. if (view.rules().enabled(featureMPTokensV2)) { - bool const newBalanceZero = (curBalance - amountWithdrawActual) == beast::kZERO; + bool const newBalanceZero = (curBalance - amountWithdrawActual) == beast::kZero; bool const newBalance2Zero = - (curBalance2 - amount2WithdrawActual.value_or(curBalance2.asset())) == beast::kZERO; - bool const newLPTokensZero = (lpTokensAMMBalance - lpTokensWithdrawActual) == beast::kZERO; + (curBalance2 - amount2WithdrawActual.value_or(curBalance2.asset())) == beast::kZero; + bool const newLPTokensZero = (lpTokensAMMBalance - lpTokensWithdrawActual) == beast::kZero; // newBalance2Zero can be zero if that side of the pool is frozen. // ignore newBalance2Zero if one-sided withdrawal. bool const valid = [&]() { @@ -629,16 +624,12 @@ AMMWithdraw::withdraw( // See also TrustSet::doApply() and MPTokenAuthorize::authorize() XRPAmount const reserve( - (ownerCount < 2) ? XRPAmount(beast::kZERO) + (ownerCount < 2) ? XRPAmount(beast::kZero) : view.fees().accountReserve(ownerCount + 1)); auto const balanceAdj = isIssue ? std::max(priorBalance, balance.xrp()) : priorBalance; if (balanceAdj < reserve) return tecINSUFFICIENT_RESERVE; - - // Update owner count. - if (!isIssue) - adjustOwnerCount(view, sleAccount, 1, journal); } return tesSUCCESS; }; @@ -748,7 +739,7 @@ AMMWithdraw::equalWithdrawTokens( std::tie(ter, newLPTokenBalance, std::ignore, std::ignore) = equalWithdrawTokens( view, ammSle, - account_, + accountID_, ammAccount, amountBalance, amount2Balance, @@ -775,7 +766,7 @@ AMMWithdraw::deleteAMMAccountIfEmpty( { TER ter; bool updateBalance = true; - if (lpTokenBalance == beast::kZERO) + if (lpTokenBalance == beast::kZero) { ter = deleteAMMAccount(sb, asset1, asset2, journal); if (!isTesSuccess(ter) && ter != tecINCOMPLETE) @@ -838,7 +829,7 @@ AMMWithdraw::equalWithdrawTokens( auto const tokensAdj = adjustLPTokensIn(view.rules(), lptAMMBalance, lpTokensWithdraw, withdrawAll); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}, STAmount{}, std::nullopt}; // the adjusted tokens are factored in auto const frac = divide(tokensAdj, lptAMMBalance, noIssue()); @@ -850,7 +841,7 @@ AMMWithdraw::equalWithdrawTokens( // of LP tokens is likely too small and results in one-sided pool // withdrawal due to round off. Fail so the user withdraws // more tokens. - if (amountWithdraw == beast::kZERO || amount2Withdraw == beast::kZERO) + if (amountWithdraw == beast::kZero || amount2Withdraw == beast::kZero) return {tecAMM_FAILED, STAmount{}, STAmount{}, STAmount{}}; return withdraw( @@ -918,7 +909,7 @@ AMMWithdraw::equalWithdrawLimit( { auto frac = Number{amount} / amountBalance; auto tokensAdj = getRoundedLPTokens(view.rules(), lptAMMBalance, frac, IsDeposit::No); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // factor in the adjusted tokens frac = adjustFracByTokens(view.rules(), lptAMMBalance, tokensAdj, frac); @@ -940,7 +931,7 @@ AMMWithdraw::equalWithdrawLimit( frac = Number{amount2} / amount2Balance; auto amountWithdraw = getRoundedAsset(view.rules(), amountBalance, frac, IsDeposit::No); tokensAdj = getRoundedLPTokens(view.rules(), lptAMMBalance, frac, IsDeposit::No); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // LCOV_EXCL_LINE // factor in the adjusted tokens frac = adjustFracByTokens(view.rules(), lptAMMBalance, tokensAdj, frac); @@ -989,7 +980,7 @@ AMMWithdraw::singleWithdraw( lptAMMBalance, lpTokensIn(amountBalance, amount, lptAMMBalance, tfee), isWithdrawAll(ctx_.tx)); - if (tokens == beast::kZERO) + if (tokens == beast::kZero) { if (!view.rules().enabled(fixAMMv1_3)) { @@ -1001,7 +992,7 @@ AMMWithdraw::singleWithdraw( // factor in the adjusted tokens auto const [tokensAdj, amountWithdrawAdj] = adjustAssetOutByTokens(view.rules(), amountBalance, amount, lptAMMBalance, tokens, tfee); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // LCOV_EXCL_LINE return withdraw( view, @@ -1038,11 +1029,11 @@ AMMWithdraw::singleWithdrawTokens( { auto const tokensAdj = adjustLPTokensIn(view.rules(), lptAMMBalance, lpTokensWithdraw, isWithdrawAll(ctx_.tx)); - if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZERO) + if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero) return {tecAMM_INVALID_TOKENS, STAmount{}}; // the adjusted tokens are factored in auto const amountWithdraw = ammAssetOut(amountBalance, lptAMMBalance, tokensAdj, tfee); - if (amount == beast::kZERO || amountWithdraw >= amount) + if (amount == beast::kZero || amountWithdraw >= amount) { return withdraw( view, @@ -1107,7 +1098,7 @@ AMMWithdraw::singleWithdrawEPrice( auto tokProdCb = [&] { return (lptAMMBalance + ae * (f - 2)) / (lptAMMBalance * f - ae); }; auto const tokensAdj = getRoundedLPTokens(view.rules(), tokNoRoundCb, lptAMMBalance, tokProdCb, IsDeposit::No); - if (tokensAdj <= beast::kZERO) + if (tokensAdj <= beast::kZero) { if (!view.rules().enabled(fixAMMv1_3)) { @@ -1121,7 +1112,7 @@ AMMWithdraw::singleWithdrawEPrice( // the adjusted tokens are factored in auto const amountWithdraw = getRoundedAsset(view.rules(), amtNoRoundCb, amount, amtProdCb, IsDeposit::No); - if (amount == beast::kZERO || amountWithdraw >= amount) + if (amount == beast::kZero || amountWithdraw >= amount) { return withdraw( view, @@ -1151,11 +1142,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..42692b59cc 100644 --- a/src/libxrpl/tx/transactors/dex/OfferCancel.cpp +++ b/src/libxrpl/tx/transactors/dex/OfferCancel.cpp @@ -55,11 +55,11 @@ OfferCancel::doApply() { auto const offerSequence = ctx_.tx[sfOfferSequence]; - auto const sle = view().read(keylet::account(account_)); + auto const sle = view().read(keylet::account(accountID_)); if (!sle) return tefINTERNAL; // LCOV_EXCL_LINE - if (auto sleOffer = view().peek(keylet::offer(account_, offerSequence))) + if (auto sleOffer = view().peek(keylet::offer(accountID_, offerSequence))) { JLOG(j_.debug()) << "Trying to cancel offer #" << offerSequence; return offerDelete(view(), sleOffer, ctx_.registry.get().getJournal("View")); @@ -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 b69ed766c5..8bf69d25c0 100644 --- a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp +++ b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp @@ -57,7 +57,7 @@ OfferCreate::makeTxConsequences(PreflightContext const& ctx) { auto calculateMaxXRPSpend = [](STTx const& tx) -> XRPAmount { auto const& amount{tx[sfTakerGets]}; - return amount.native() ? amount.xrp() : beast::kZERO; + return amount.native() ? amount.xrp() : beast::kZero; }; return TxConsequences{ctx.tx, calculateMaxXRPSpend(ctx.tx)}; @@ -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) { @@ -130,7 +128,7 @@ OfferCreate::preflight(PreflightContext const& ctx) JLOG(j.debug()) << "Malformed offer: redundant (XRP for XRP)"; return temBAD_OFFER; } - if (saTakerPays <= beast::kZERO || saTakerGets <= beast::kZERO) + if (saTakerPays <= beast::kZero || saTakerGets <= beast::kZero) { JLOG(j.debug()) << "Malformed offer: bad amount"; return temBAD_OFFER; @@ -183,11 +181,15 @@ OfferCreate::preclaim(PreclaimContext const& ctx) auto viewJ = ctx.registry.get().getJournal("View"); - if (isGlobalFrozen(ctx.view, saTakerPays.asset()) || - isGlobalFrozen(ctx.view, saTakerGets.asset())) + if (auto const ter = checkGlobalFrozen(ctx.view, saTakerPays.asset()); !isTesSuccess(ter)) { - JLOG(ctx.j.debug()) << "Offer involves frozen asset"; - return tecFROZEN; + JLOG(ctx.j.debug()) << "Offer involves frozen or locked asset"; + return ter; + } + if (auto const ter = checkGlobalFrozen(ctx.view, saTakerGets.asset()); !isTesSuccess(ter)) + { + JLOG(ctx.j.debug()) << "Offer involves frozen or locked asset"; + return ter; } // Allow unfunded MPT for issuer (OutstandingAmount >= MaximumAmount) @@ -198,7 +200,7 @@ OfferCreate::preclaim(PreclaimContext const& ctx) saTakerGets, FreezeHandling::ZeroIfFrozen, AuthHandling::ZeroIfUnauthorized, - viewJ) <= beast::kZERO) + viewJ) <= beast::kZero) { JLOG(ctx.j.debug()) << "delay: Offers must be at least partially funded."; return tecUNFUNDED_OFFER; @@ -274,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)); @@ -289,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) { @@ -323,7 +324,13 @@ OfferCreate::checkAcceptAsset( [&](MPTIssue const& issue) -> TER { // WeakAuth - don't check if MPToken exists since it's created // if needed. - return requireAuth(view, issue, id, AuthType::WeakAuth); + if (auto const ter = requireAuth(view, issue, id, AuthType::WeakAuth); + !isTesSuccess(ter)) + { + return ter; + } + + return checkFrozen(view, id, issue); }); } @@ -344,15 +351,15 @@ OfferCreate::flowCross( // below the reserve) so we check this case again. STAmount const inStartBalance = accountFunds( psb, - account_, + accountID_, takerAmount.in, FreezeHandling::ZeroIfFrozen, AuthHandling::ZeroIfUnauthorized, j_); // Allow unfunded MPT issuer auto const disallowUnfunded = - !inStartBalance.holds() || inStartBalance.getIssuer() != account_; - if (disallowUnfunded && inStartBalance <= beast::kZERO) + !inStartBalance.holds() || inStartBalance.getIssuer() != accountID_; + if (disallowUnfunded && inStartBalance <= beast::kZero) { // The account balance can't cover even part of the offer. JLOG(j_.debug()) << "Not crossing: taker is unfunded."; @@ -364,7 +371,7 @@ OfferCreate::flowCross( // offer taker. Set sendMax to allow for the gateway's cut. Rate gatewayXferRate{QUALITY_ONE}; STAmount sendMax = takerAmount.in; - if (!sendMax.native() && (account_ != sendMax.getIssuer())) + if (!sendMax.native() && (accountID_ != sendMax.getIssuer())) { gatewayXferRate = transferRate(psb, sendMax); if (gatewayXferRate.value != QUALITY_ONE) @@ -380,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. @@ -403,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 @@ -413,7 +419,7 @@ OfferCreate::flowCross( [&](Issue const& issue) { if (issue.native()) { - deliver = STAmount{STAmount::kMAX_NATIVE}; + deliver = STAmount{STAmount::kMaxNative}; } // We can't use the maximum possible currency here because // there might be a gateway transfer rate to account for. @@ -422,24 +428,22 @@ OfferCreate::flowCross( else { deliver = - STAmount{deliverAsset, STAmount::kMAX_VALUE / 2, STAmount::kMAX_OFFSET}; + STAmount{deliverAsset, STAmount::kMaxValue / 2, STAmount::kMaxOffset}; } }, - [&](MPTIssue const&) { - deliver = STAmount{deliverAsset, kMAX_MP_TOKEN_AMOUNT / 2}; - }); + [&](MPTIssue const&) { deliver = STAmount{deliverAsset, kMaxMpTokenAmount / 2}; }); } // Call the payment engine's flow() to do the actual work. auto const result = flow( psb, deliver, - account_, - account_, + accountID_, + accountID_, 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, @@ -461,13 +465,13 @@ OfferCreate::flowCross( { STAmount const takerInBalance = accountFunds( psb, - account_, + accountID_, takerAmount.in, FreezeHandling::ZeroIfFrozen, AuthHandling::ZeroIfUnauthorized, j_); - if (disallowUnfunded && takerInBalance <= beast::kZERO) + if (disallowUnfunded && takerInBalance <= beast::kZero) { // If offer crossing exhausted the account's funds don't // create the offer. @@ -478,7 +482,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 @@ -498,8 +502,8 @@ OfferCreate::flowCross( afterCross.in -= nonGatewayAmountIn; // It's possible that the divRound will cause our subtract - // to go slightly negative. So limit afterCross.in to beast::kZERO. - if (afterCross.in < beast::kZERO) + // to go slightly negative. So limit afterCross.in to beast::kZero. + if (afterCross.in < beast::kZero) { // We should verify that the difference *is* small, but // what is a good threshold to check? @@ -516,9 +520,9 @@ OfferCreate::flowCross( // Quality. afterCross.out -= result.actualAmountOut; XRPL_ASSERT( - afterCross.out >= beast::kZERO, + afterCross.out >= beast::kZero, "xrpl::OfferCreate::flowCross : minimum offer"); - if (afterCross.out < beast::kZERO) + if (afterCross.out < beast::kZero) afterCross.out.clear(); afterCross.in = mulRound(afterCross.out, rate, takerAmount.in.asset(), true); } @@ -553,6 +557,7 @@ OfferCreate::applyHybrid( Keylet const& offerKey, STAmount const& saTakerPays, STAmount const& saTakerGets, + std::uint64_t openRate, std::function)> const& setDir) { if (!sleOffer->isFieldPresent(sfDomainID)) @@ -564,7 +569,7 @@ OfferCreate::applyHybrid( // if offer is hybrid, need to also place into open offer dir Book const book{saTakerPays.asset(), saTakerGets.asset(), std::nullopt}; - auto dir = keylet::quality(keylet::kBOOK(book), getRate(saTakerGets, saTakerPays)); + auto dir = keylet::quality(keylet::kBook(book), openRate); bool const bookExists = sb.exists(dir); auto const bookNode = sb.dirAppend(dir, offerKey, [&](SLE::ref sle) { @@ -595,15 +600,13 @@ OfferCreate::applyHybrid( std::pair OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) { - using beast::kZERO; + 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]; @@ -627,7 +630,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) // Process a cancellation request that's passed along with an offer. if (cancelSequence) { - auto const sleCancel = sb.peek(keylet::offer(account_, *cancelSequence)); + auto const sleCancel = sb.peek(keylet::offer(accountID_, *cancelSequence)); // It's not an error to not find the offer to cancel: it might have // been consumed or removed. If it is found, however, it's an error @@ -656,7 +659,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) auto const& uPaysIssuerID = saTakerPays.getIssuer(); auto const& uGetsIssuerID = saTakerGets.getIssuer(); - std::uint8_t uTickSize = Quality::kMAX_TICK_SIZE; + std::uint8_t uTickSize = Quality::kMaxTickSize; // Not XRP or MPT if (!saTakerPays.integral()) { @@ -671,7 +674,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) if (sle && sle->isFieldPresent(sfTickSize)) uTickSize = std::min(uTickSize, (*sle)[sfTickSize]); } - if (uTickSize < Quality::kMAX_TICK_SIZE) + if (uTickSize < Quality::kMaxTickSize) { auto const rate = Quality{saTakerGets, saTakerPays}.round(uTickSize).rate(); @@ -757,7 +760,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) // The offer that we need to place after offer crossing should // never be negative. If it is, something went very very wrong. - if (placeOffer.in < kZERO || placeOffer.out < kZERO) + if (placeOffer.in < kZero || placeOffer.out < kZero) { JLOG(j_.fatal()) << "Cross left offer negative!" << " in: " << formatAmount(placeOffer.in) @@ -765,7 +768,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) return {tefINTERNAL, true}; } - if (placeOffer.in == kZERO || placeOffer.out == kZERO) + if (placeOffer.in == kZero || placeOffer.out == kZero) { JLOG(j_.debug()) << "Offer fully crossed!"; return {result, true}; @@ -779,7 +782,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) } XRPL_ASSERT( - saTakerPays > beast::kZERO && saTakerGets > beast::kZERO, + saTakerPays > beast::kZero && saTakerGets > beast::kZero, "xrpl::OfferCreate::applyGuts : taker pays and gets positive"); if (!isTesSuccess(result)) @@ -818,7 +821,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) return {tesSUCCESS, true}; } - auto const sleCreator = sb.peek(keylet::account(account_)); + auto const sleCreator = sb.peek(keylet::account(accountID_)); if (!sleCreator) return {tefINTERNAL, false}; @@ -844,11 +847,11 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) } // We need to place the remainder of the offer into its order book. - auto const offerIndex = keylet::offer(account_, offerSequence); + auto const offerIndex = keylet::offer(accountID_, offerSequence); // Add offer to owner's directory. auto const ownerNode = - sb.dirInsert(keylet::ownerDir(account_), offerIndex, describeOwnerDir(account_)); + sb.dirInsert(keylet::ownerDir(accountID_), offerIndex, describeOwnerDir(accountID_)); if (!ownerNode) { @@ -878,7 +881,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) // Hybrid domain offer - BookDirectory points to domain directory, // and AdditionalBooks field stores one entry that points to the open // directory - auto dir = keylet::quality(keylet::kBOOK(book), uRate); + auto dir = keylet::quality(keylet::kBook(book), uRate); bool const bookExisted = static_cast(sb.peek(dir)); auto setBookDir = [&](SLE::ref sle, std::optional const& maybeDomain) { @@ -913,7 +916,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) } auto sleOffer = std::make_shared(offerIndex); - sleOffer->setAccountID(sfAccount, account_); + sleOffer->setAccountID(sfAccount, accountID_); sleOffer->setFieldU32(sfSequence, offerSequence); sleOffer->setFieldH256(sfBookDirectory, dir.key); sleOffer->setFieldAmount(sfTakerPays, saTakerPays); @@ -932,8 +935,16 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel) // if it's a hybrid offer, set hybrid flag, and create an open dir if (bHybrid) { + // Pre-fixCleanup3_2_0: the open-book directory quality was computed + // from post-crossing amounts, which may differ from the original rate + // due to rounding in rate preservation. Post-fixCleanup3_2_0: use the + // original placement rate so the open-book directory quality matches + // the domain-book directory. + auto const openRate = ctx_.view().rules().enabled(fixCleanup3_2_0) + ? uRate + : getRate(saTakerGets, saTakerPays); auto const res = - applyHybrid(sb, sleOffer, offerIndex, saTakerPays, saTakerGets, setBookDir); + applyHybrid(sb, sleOffer, offerIndex, saTakerPays, saTakerGets, openRate, setBookDir); if (!isTesSuccess(res)) return {res, true}; // LCOV_EXCL_LINE } @@ -978,11 +989,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..4b4fb47169 100644 --- a/src/libxrpl/tx/transactors/did/DIDDelete.cpp +++ b/src/libxrpl/tx/transactors/did/DIDDelete.cpp @@ -67,7 +67,7 @@ DIDDelete::deleteSLE( TER DIDDelete::doApply() { - return deleteSLE(ctx_, keylet::did(account_), account_); + return deleteSLE(ctx_, keylet::did(accountID_), accountID_); } void @@ -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..a930c3c754 100644 --- a/src/libxrpl/tx/transactors/did/DIDSet.cpp +++ b/src/libxrpl/tx/transactors/did/DIDSet.cpp @@ -55,9 +55,8 @@ DIDSet::preflight(PreflightContext const& ctx) return false; }; - if (isTooLong(sfURI, kMAX_DIDURI_LENGTH) || - isTooLong(sfDIDDocument, kMAX_DID_DOCUMENT_LENGTH) || - isTooLong(sfData, kMAX_DID_DATA_LENGTH)) + if (isTooLong(sfURI, kMaxDidUriLength) || isTooLong(sfDIDDocument, kMaxDidDocumentLength) || + isTooLong(sfData, kMaxDidDataLength)) return temMALFORMED; return tesSUCCESS; @@ -100,7 +99,7 @@ TER DIDSet::doApply() { // Edit ledger object if it already exists - Keylet const didKeylet = keylet::did(account_); + Keylet const didKeylet = keylet::did(accountID_); if (auto const sleDID = ctx_.view().peek(didKeylet)) { auto update = [&](auto const& sField) { @@ -131,7 +130,7 @@ DIDSet::doApply() // Create new ledger object otherwise auto const sleDID = std::make_shared(didKeylet); - (*sleDID)[sfAccount] = account_; + (*sleDID)[sfAccount] = accountID_; auto set = [&](auto const& sField) { if (auto const field = ctx_.tx[~sField]; field && !field->empty()) @@ -147,7 +146,7 @@ DIDSet::doApply() return tecEMPTY_DID; } - return addSLE(ctx_, sleDID, account_); + return addSLE(ctx_, sleDID, accountID_); } void @@ -156,11 +155,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..123f83a1a6 100644 --- a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp +++ b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp @@ -178,13 +178,13 @@ EscrowCancel::doApply() return temDISABLED; // LCOV_EXCL_LINE auto const issuer = amount.getIssuer(); - bool const createAsset = account == account_; + bool const createAsset = account == accountID_; if (auto const ret = std::visit( [&](T const&) { return escrowUnlockApplyHelper( ctx_.view(), - kPARITY_RATE, - slep, + kParityRate, + ctx_.view().rules().enabled(fixCleanup3_2_0) ? sle : slep, preFeeBalance_, amount, issuer, @@ -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..4de302db3e 100644 --- a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp +++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp @@ -78,7 +78,17 @@ TxConsequences EscrowCreate::makeTxConsequences(PreflightContext const& ctx) { auto const amount = ctx.tx[sfAmount]; - return TxConsequences{ctx.tx, isXRP(amount) ? amount.xrp() : beast::kZERO}; + return TxConsequences{ctx.tx, isXRP(amount) ? amount.xrp() : beast::kZero}; +} + +bool +EscrowCreate::checkExtraFeatures(PreflightContext const& ctx) +{ + // Only require featureMPTokensV1 when the escrow amount is an MPT and + // fixCleanup3_2_0 is active; XRP/IOU escrows are unaffected by this gate. + if (ctx.rules.enabled(fixCleanup3_2_0) && ctx.tx[sfAmount].holds()) + return ctx.rules.enabled(featureMPTokensV1); + return true; } template @@ -90,7 +100,7 @@ NotTEC escrowCreatePreflightHelper(PreflightContext const& ctx) { STAmount const amount = ctx.tx[sfAmount]; - if (amount.native() || amount <= beast::kZERO) + if (amount.native() || amount <= beast::kZero) return temBAD_AMOUNT; if (badCurrency() == amount.get().currency) @@ -103,11 +113,11 @@ template <> NotTEC escrowCreatePreflightHelper(PreflightContext const& ctx) { - if (!ctx.rules.enabled(featureMPTokensV1)) + if (!ctx.rules.enabled(fixCleanup3_2_0) && !ctx.rules.enabled(featureMPTokensV1)) return temDISABLED; auto const amount = ctx.tx[sfAmount]; - if (amount.native() || amount.mpt() > MPTAmount{kMAX_MP_TOKEN_AMOUNT} || amount <= beast::kZERO) + if (amount.native() || amount.mpt() > MPTAmount{kMaxMpTokenAmount} || amount <= beast::kZero) return temBAD_AMOUNT; return tesSUCCESS; @@ -130,7 +140,7 @@ EscrowCreate::preflight(PreflightContext const& ctx) } else { - if (amount <= beast::kZERO) + if (amount <= beast::kZero) return temBAD_AMOUNT; } @@ -205,11 +215,11 @@ escrowCreatePreclaimHelper( STAmount const balance = (*sleRippleState)[sfBalance]; // If balance is positive, issuer must have higher address than account - if (balance > beast::kZERO && issuer < account) + if (balance > beast::kZero && issuer < account) return tecNO_PERMISSION; // LCOV_EXCL_LINE // If balance is negative, issuer must have lower address than account - if (balance < beast::kZERO && issuer > account) + if (balance < beast::kZero && issuer > account) return tecNO_PERMISSION; // LCOV_EXCL_LINE // If the issuer has requireAuth set, check if the account is authorized @@ -232,7 +242,7 @@ escrowCreatePreclaimHelper( ctx.view, account, issue.currency, issuer, FreezeHandling::IgnoreFreeze, ctx.j); // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS - if (spendableAmount <= beast::kZERO) + if (spendableAmount <= beast::kZero) return tecINSUFFICIENT_FUNDS; // If the spendable amount is less than the amount, return @@ -313,7 +323,7 @@ escrowCreatePreclaimHelper( ctx.j); // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS - if (spendableAmount <= beast::kZERO) + if (spendableAmount <= beast::kZero) return tecINSUFFICIENT_FUNDS; // If the spendable amount is less than the amount, return @@ -417,7 +427,7 @@ EscrowCreate::doApply() if (ctx_.tx[~sfFinishAfter] && after(closeTime, ctx_.tx[sfFinishAfter])) return tecNO_PERMISSION; - auto const sle = ctx_.view().peek(keylet::account(account_)); + auto const sle = ctx_.view().peek(keylet::account(accountID_)); if (!sle) return tefINTERNAL; // LCOV_EXCL_LINE @@ -442,16 +452,16 @@ 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; } // Create escrow in ledger. Note that we use the value from the // sequence or ticket. For more explanation see comments in SeqProxy.h. - Keylet const escrowKeylet = keylet::escrow(account_, ctx_.tx.getSeqValue()); + Keylet const escrowKeylet = keylet::escrow(accountID_, ctx_.tx.getSeqValue()); auto const slep = std::make_shared(escrowKeylet); (*slep)[sfAmount] = amount; - (*slep)[sfAccount] = account_; + (*slep)[sfAccount] = accountID_; (*slep)[~sfCondition] = ctx_.tx[~sfCondition]; (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag]; (*slep)[sfDestination] = ctx_.tx[sfDestination]; @@ -467,7 +477,7 @@ EscrowCreate::doApply() if (ctx_.view().rules().enabled(featureTokenEscrow) && !isXRP(amount)) { auto const xferRate = transferRate(ctx_.view(), amount); - if (xferRate != kPARITY_RATE) + if (xferRate != kParityRate) (*slep)[sfTransferRate] = xferRate.value; } @@ -476,7 +486,7 @@ EscrowCreate::doApply() // Add escrow to sender's owner directory { auto page = ctx_.view().dirInsert( - keylet::ownerDir(account_), escrowKeylet, describeOwnerDir(account_)); + keylet::ownerDir(accountID_), escrowKeylet, describeOwnerDir(accountID_)); if (!page) return tecDIR_FULL; // LCOV_EXCL_LINE (*slep)[sfOwnerNode] = *page; @@ -484,7 +494,7 @@ EscrowCreate::doApply() // If it's not a self-send, add escrow to recipient's owner directory. AccountID const dest = ctx_.tx[sfDestination]; - if (dest != account_) + if (dest != accountID_) { auto page = ctx_.view().dirInsert(keylet::ownerDir(dest), escrowKeylet, describeOwnerDir(dest)); @@ -497,7 +507,7 @@ EscrowCreate::doApply() // track the total locked balance. For MPT, this isn't necessary because the // locked balance is already stored directly in the MPTokenIssuance object. AccountID const issuer = amount.getIssuer(); - if (!isXRP(amount) && issuer != account_ && issuer != dest && !amount.holds()) + if (!isXRP(amount) && issuer != accountID_ && issuer != dest && !amount.holds()) { auto page = ctx_.view().dirInsert(keylet::ownerDir(issuer), escrowKeylet, describeOwnerDir(issuer)); @@ -515,7 +525,7 @@ EscrowCreate::doApply() { if (auto const ret = std::visit( [&](T const&) { - return escrowLockApplyHelper(ctx_.view(), issuer, account_, amount, j_); + return escrowLockApplyHelper(ctx_.view(), issuer, accountID_, amount, j_); }, amount.asset().value()); !isTesSuccess(ret)) @@ -536,6 +546,7 @@ EscrowCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -546,6 +557,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..13bd4b1682 100644 --- a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp +++ b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp @@ -39,8 +39,8 @@ namespace xrpl { // During an EscrowFinish, the transaction must specify both // a condition and a fulfillment. We track whether that // fulfillment matches and validates the condition. -constexpr HashRouterFlags kSF_CF_INVALID = HashRouterFlags::PRIVATE5; -constexpr HashRouterFlags kSF_CF_VALID = HashRouterFlags::PRIVATE6; +constexpr HashRouterFlags kSfCfInvalid = HashRouterFlags::PRIVATE5; +constexpr HashRouterFlags kSfCfValid = HashRouterFlags::PRIVATE6; //------------------------------------------------------------------------------ @@ -98,15 +98,15 @@ EscrowFinish::preflightSigValidated(PreflightContext const& ctx) // If we haven't checked the condition, check it // now. Whether it passes or not isn't important // in preflight. - if (!any(flags & (kSF_CF_INVALID | kSF_CF_VALID))) + if (!any(flags & (kSfCfInvalid | kSfCfValid))) { if (checkCondition(*fb, *cb)) { - router.setFlags(id, kSF_CF_VALID); + router.setFlags(id, kSfCfValid); } else { - router.setFlags(id, kSF_CF_INVALID); + router.setFlags(id, kSfCfInvalid); } } } @@ -261,7 +261,7 @@ EscrowFinish::doApply() // It's unlikely that the results of the check will // expire from the hash router, but if it happens, // simply re-run the check. - if (cb && !any(flags & (kSF_CF_INVALID | kSF_CF_VALID))) + if (cb && !any(flags & (kSfCfInvalid | kSfCfValid))) { // LCOV_EXCL_START auto const fb = ctx_.tx[~sfFulfillment]; @@ -271,11 +271,11 @@ EscrowFinish::doApply() if (checkCondition(*fb, *cb)) { - flags = kSF_CF_VALID; + flags = kSfCfValid; } else { - flags = kSF_CF_INVALID; + flags = kSfCfInvalid; } ctx_.registry.get().getHashRouter().setFlags(id, flags); @@ -284,7 +284,7 @@ EscrowFinish::doApply() // If the check failed, then simply return an error // and don't look at anything else. - if (any(flags & kSF_CF_INVALID)) + if (any(flags & kSfCfInvalid)) return tecCRYPTOCONDITION_ERROR; // Check against condition in the ledger entry: @@ -310,7 +310,8 @@ EscrowFinish::doApply() if (!sled) return tecNO_DST; - if (auto err = verifyDepositPreauth(ctx_.tx, ctx_.view(), account_, destID, sled, ctx_.journal); + if (auto err = + verifyDepositPreauth(ctx_.tx, ctx_.view(), accountID_, destID, sled, ctx_.journal); !isTesSuccess(err)) return err; @@ -353,9 +354,9 @@ EscrowFinish::doApply() Rate lockedRate = slep->isFieldPresent(sfTransferRate) ? xrpl::Rate(slep->getFieldU32(sfTransferRate)) - : kPARITY_RATE; + : kParityRate; auto const issuer = amount.getIssuer(); - bool const createAsset = destID == account_; + bool const createAsset = destID == accountID_; if (auto const ret = std::visit( [&](T const&) { return escrowUnlockApplyHelper( @@ -405,6 +406,7 @@ EscrowFinish::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -415,6 +417,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..11095fdebe 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -48,7 +49,7 @@ LoanBrokerCoverClawback::preflight(PreflightContext const& ctx) if (!brokerID && !amount) return temINVALID; - if (brokerID && *brokerID == beast::kZERO) + if (brokerID && *brokerID == beast::kZero) return temINVALID; if (amount) @@ -58,7 +59,7 @@ LoanBrokerCoverClawback::preflight(PreflightContext const& ctx) return temBAD_AMOUNT; // Zero is OK, and indicates "take it all" (down to the minimum cover) - if (*amount < beast::kZERO) + if (*amount < beast::kZero) return temBAD_AMOUNT; // This should be redundant @@ -75,7 +76,7 @@ LoanBrokerCoverClawback::preflight(PreflightContext const& ctx) // broker's pseudo-account, but we don't know yet whether it is, so // use a generic placeholder name. auto const holder = amount->getIssuer(); - if (holder == account || holder == beast::kZERO) + if (holder == account || holder == beast::kZero) return temINVALID; } } @@ -160,24 +161,34 @@ Expected determineClawAmount( SLE const& sleBroker, Asset const& vaultAsset, - std::optional const& amount) + std::optional const& amount, + SLE::const_ref vaultSle, + Rules const& rules) { auto const maxClawAmount = [&]() { - // Always round the minimum required up - NumberRoundModeGuard const mg1(Number::RoundingMode::Upward); - auto const minRequiredCover = - tenthBipsOfValue(sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum])); + auto const minRequiredCover = [&]() { + if (rules.enabled(fixCleanup3_2_0)) + { + return minimumBrokerCover( + sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum]), vaultSle); + } + + // Always round the minimum required up + NumberRoundModeGuard const mg(Number::RoundingMode::Upward); + return tenthBipsOfValue( + sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum])); + }(); // The subtraction probably won't round, but round down if it does. - NumberRoundModeGuard const mg2(Number::RoundingMode::Downward); + NumberRoundModeGuard const mg(Number::RoundingMode::Downward); return sleBroker[sfCoverAvailable] - minRequiredCover; }(); - if (maxClawAmount <= beast::kZERO) + if (maxClawAmount <= beast::kZero) return Unexpected(tecINSUFFICIENT_FUNDS); // Use the vaultAsset here, because it will be the right type in all // circumstances. The amount may be an IOU indicating the pseudo-account's // asset, which is correct, but not what is needed here. - if (!amount || *amount == beast::kZERO) + if (!amount || *amount == beast::kZero) return STAmount{vaultAsset, maxClawAmount}; Number const magnitude{*amount}; if (magnitude > maxClawAmount) @@ -283,7 +294,8 @@ LoanBrokerCoverClawback::preclaim(PreclaimContext const& ctx) } } - auto const findClawAmount = determineClawAmount(*sleBroker, vaultAsset, amount); + auto const findClawAmount = + determineClawAmount(*sleBroker, vaultAsset, amount, vault, ctx.view.rules()); if (!findClawAmount) { JLOG(ctx.j.warn()) << "LoanBroker cover is already at minimum."; @@ -291,6 +303,10 @@ LoanBrokerCoverClawback::preclaim(PreclaimContext const& ctx) } STAmount const& clawAmount = *findClawAmount; + if (auto const ret = canApplyToBrokerCover( + ctx.view, sleBroker, vaultAsset, clawAmount, ctx.j, "LoanBrokerCoverClawback")) + return ret; + // Explicitly check the balance of the trust line / MPT to make sure the // balance is actually there. It should always match `sfCoverAvailable`, so // if there isn't, this is an internal error. @@ -341,7 +357,8 @@ LoanBrokerCoverClawback::doApply() auto const vaultAsset = vault->at(sfAsset); - auto const findClawAmount = determineClawAmount(*sleBroker, vaultAsset, amount); + auto const findClawAmount = + determineClawAmount(*sleBroker, vaultAsset, amount, vault, view().rules()); if (!findClawAmount) return tecINTERNAL; // LCOV_EXCL_LINE STAmount const& clawAmount = *findClawAmount; @@ -365,6 +382,7 @@ LoanBrokerCoverClawback::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -375,6 +393,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..e84f277f5b 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp @@ -1,9 +1,11 @@ #include #include +#include #include #include #include +#include #include #include #include @@ -27,11 +29,11 @@ LoanBrokerCoverDeposit::checkExtraFeatures(PreflightContext const& ctx) NotTEC LoanBrokerCoverDeposit::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfLoanBrokerID] == beast::kZERO) + if (ctx.tx[sfLoanBrokerID] == beast::kZero) return temINVALID; auto const dstAmount = ctx.tx[sfAmount]; - if (dstAmount <= beast::kZERO) + if (dstAmount <= beast::kZero) return temBAD_AMOUNT; if (!isLegalNet(dstAmount)) @@ -87,6 +89,29 @@ LoanBrokerCoverDeposit::preclaim(PreclaimContext const& ctx) if (auto const ret = requireAuth(ctx.view, vaultAsset, account, AuthType::StrongAuth)) return ret; + // Deposit must round the amount Downward to cover scale and then reuse that rounded + // value for the actual transfer in doApply — otherwise implicit round-to-nearest during + // `sfCoverAvailable +=` could credit the broker more than the depositor paid Computing it + // here in preclaim lets us reject sub-cover-scale dust early with tecPRECISION_LOSS instead of + // failing only in doApply. + bool const fix320Enabled = ctx.view.rules().enabled(fixCleanup3_2_0); + auto const roundedAmount = [&]() -> STAmount { + if (!fix320Enabled) + return tx[sfAmount]; + + return roundToScale( + tx[sfAmount], + scale(sleBroker->at(sfCoverAvailable), vaultAsset), + Number::RoundingMode::Downward); + }(); + + if (fix320Enabled && roundedAmount == beast::kZero) + { + JLOG(ctx.j.warn()) << "LoanBrokerCoverDeposit: deposit amount: " << tx[sfAmount] + << " is zero at loan broker scale"; + return tecPRECISION_LOSS; + } + if (accountHolds( ctx.view, account, @@ -94,7 +119,7 @@ LoanBrokerCoverDeposit::preclaim(PreclaimContext const& ctx) FreezeHandling::ZeroIfFrozen, AuthHandling::ZeroIfUnauthorized, ctx.j, - SpendableHandling::FullBalance) < amount) + SpendableHandling::FullBalance) < roundedAmount) return tecINSUFFICIENT_FUNDS; return tesSUCCESS; @@ -106,8 +131,6 @@ LoanBrokerCoverDeposit::doApply() auto const& tx = ctx_.tx; auto const brokerID = tx[sfLoanBrokerID]; - auto const amount = tx[sfAmount]; - auto broker = view().peek(keylet::loanbroker(brokerID)); if (!broker) return tecINTERNAL; // LCOV_EXCL_LINE @@ -117,11 +140,35 @@ LoanBrokerCoverDeposit::doApply() return tecINTERNAL; // LCOV_EXCL_LINE auto const vaultAsset = vault->at(sfAsset); - auto const brokerPseudoID = broker->at(sfAccount); + // Re-round here (matches preclaim) so the same cover-scale-quantized + // value drives both the trustline transfer and the cover increment; + // see the rationale comment in preclaim. + bool const fix320Enabled = view().rules().enabled(fixCleanup3_2_0); + auto const amount = [&]() -> STAmount { + if (!fix320Enabled) + return tx[sfAmount]; + + return roundToScale( + tx[sfAmount], + scale(broker->at(sfCoverAvailable), vaultAsset), + Number::RoundingMode::Downward); + }(); + + // We validated zero-amount in preclaim, if we ended up with zero now, fail hard. + if (amount == beast::kZero) + { + // LCOV_EXCL_START + JLOG(j_.error()) << "LoanBrokerCoverDeposit: deposit amount: " << tx[sfAmount] + << " is zero"; + return tecINTERNAL; + // LCOV_EXCL_STOP + } + // Transfer assets from depositor to pseudo-account. - if (auto ter = accountSend(view(), account_, brokerPseudoID, amount, j_, WaiveTransferFee::Yes)) + if (auto ter = + accountSend(view(), accountID_, brokerPseudoID, amount, j_, WaiveTransferFee::Yes)) return ter; // Increase the LoanBroker's CoverAvailable by Amount @@ -139,6 +186,7 @@ LoanBrokerCoverDeposit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -149,6 +197,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..f4c95541f6 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -32,11 +33,11 @@ LoanBrokerCoverWithdraw::checkExtraFeatures(PreflightContext const& ctx) NotTEC LoanBrokerCoverWithdraw::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfLoanBrokerID] == beast::kZERO) + if (ctx.tx[sfLoanBrokerID] == beast::kZero) return temINVALID; auto const dstAmount = ctx.tx[sfAmount]; - if (dstAmount <= beast::kZERO) + if (dstAmount <= beast::kZero) return temBAD_AMOUNT; if (!isLegalNet(dstAmount)) @@ -44,7 +45,7 @@ LoanBrokerCoverWithdraw::preflight(PreflightContext const& ctx) if (auto const destination = ctx.tx[~sfDestination]) { - if (*destination == beast::kZERO) + if (*destination == beast::kZero) { return temMALFORMED; } @@ -93,10 +94,20 @@ LoanBrokerCoverWithdraw::preclaim(PreclaimContext const& ctx) if (amount.asset() != vaultAsset) return tecWRONG_ASSET; + // Helper handles both IOU and MPT correctly without explicit branching. + if (auto const ret = canApplyToBrokerCover( + ctx.view, sleBroker, vaultAsset, amount, ctx.j, "LoanBrokerCoverWithdraw")) + return ret; + // The broker's pseudo-account is the source of funds. auto const pseudoAccountID = sleBroker->at(sfAccount); - // Cannot transfer a non-transferable Asset - if (auto const ret = canTransfer(ctx.view, vaultAsset, pseudoAccountID, dstAcct)) + // Post-fixCleanup3_2_0: cover withdraw is a recovery path that bypasses + // the lsfMPTCanTransfer flag check, so an issuer cannot trap a broker's + // first-loss capital. Other transferability checks (IOU NoRipple, freeze, + // requireAuth) still apply. + auto const waive = ctx.view.rules().enabled(fixCleanup3_2_0) ? WaiveMPTCanTransfer::Yes + : WaiveMPTCanTransfer::No; + if (auto const ret = canTransfer(ctx.view, vaultAsset, pseudoAccountID, dstAcct, waive)) return ret; // Withdrawal to a 3rd party destination account is essentially a transfer. @@ -131,6 +142,12 @@ LoanBrokerCoverWithdraw::preclaim(PreclaimContext const& ctx) // Cover Rate is in 1/10 bips units auto const currentDebtTotal = sleBroker->at(sfDebtTotal); auto const minimumCover = [&]() { + if (ctx.view.rules().enabled(fixCleanup3_2_0)) + { + return minimumBrokerCover( + currentDebtTotal, TenthBips32{sleBroker->at(sfCoverRateMinimum)}, vault); + } + // Always round the minimum required up. // Applies to `tenthBipsOfValue` as well as `roundToAsset`. NumberRoundModeGuard const mg(Number::RoundingMode::Upward); @@ -163,7 +180,7 @@ LoanBrokerCoverWithdraw::doApply() auto const brokerID = tx[sfLoanBrokerID]; auto const amount = tx[sfAmount]; - auto const dstAcct = tx[~sfDestination].value_or(account_); + auto const dstAcct = tx[~sfDestination].value_or(accountID_); auto broker = view().peek(keylet::loanbroker(brokerID)); if (!broker) @@ -183,7 +200,7 @@ LoanBrokerCoverWithdraw::doApply() associateAsset(*broker, vaultAsset); - return doWithdraw(view(), tx, account_, dstAcct, brokerPseudoID, preFeeBalance_, amount, j_); + return doWithdraw(view(), tx, accountID_, dstAcct, brokerPseudoID, preFeeBalance_, amount, j_); } void @@ -192,6 +209,7 @@ LoanBrokerCoverWithdraw::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -202,6 +220,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..6b77914370 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -30,7 +31,7 @@ LoanBrokerDelete::checkExtraFeatures(PreflightContext const& ctx) NotTEC LoanBrokerDelete::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfLoanBrokerID] == beast::kZERO) + if (ctx.tx[sfLoanBrokerID] == beast::kZero) return temINVALID; return tesSUCCESS; @@ -75,7 +76,7 @@ LoanBrokerDelete::preclaim(PreclaimContext const& ctx) Asset const asset = vault->at(sfAsset); - if (auto const debtTotal = sleBroker->at(sfDebtTotal); debtTotal != beast::kZERO) + if (auto const debtTotal = sleBroker->at(sfDebtTotal); debtTotal != beast::kZero) { // Any remaining debt should have been wiped out by the last Loan // Delete. This check is purely defensive. @@ -84,7 +85,7 @@ LoanBrokerDelete::preclaim(PreclaimContext const& ctx) auto const rounded = roundToAsset(asset, debtTotal, scale, Number::RoundingMode::TowardsZero); - if (rounded != beast::kZERO) + if (rounded != beast::kZero) { // LCOV_EXCL_START JLOG(ctx.j.warn()) << "LoanBrokerDelete: Debt total is " << debtTotal @@ -97,7 +98,7 @@ LoanBrokerDelete::preclaim(PreclaimContext const& ctx) auto const coverAvailable = STAmount{asset, sleBroker->at(sfCoverAvailable)}; // If there are assets in the cover, broker will receive them on deletion. // So we need to check if the broker owner is deep frozen for that asset. - if (coverAvailable > beast::kZERO) + if (coverAvailable > beast::kZero) { if (auto const ret = checkDeepFrozen(ctx.view, brokerOwner, asset)) { @@ -106,6 +107,19 @@ LoanBrokerDelete::preclaim(PreclaimContext const& ctx) } } + if (ctx.view.rules().enabled(fixCleanup3_2_0)) + { + if (coverAvailable > beast::kZero) + { + auto const brokerPseudo = sleBroker->at(sfAccount); + if (auto const ret = checkFrozen(ctx.view, brokerPseudo, asset)) + { + JLOG(ctx.j.warn()) << "Broker pseudo-account is frozen/locked."; + return ret; + } + } + } + return tesSUCCESS; } @@ -130,7 +144,7 @@ LoanBrokerDelete::doApply() auto const brokerPseudoID = broker->at(sfAccount); if (!view().dirRemove( - keylet::ownerDir(account_), broker->at(sfOwnerNode), broker->key(), false)) + keylet::ownerDir(accountID_), broker->at(sfOwnerNode), broker->key(), false)) { return tefBAD_LEDGER; // LCOV_EXCL_LINE } @@ -143,7 +157,7 @@ LoanBrokerDelete::doApply() { auto const coverAvailable = STAmount{vaultAsset, broker->at(sfCoverAvailable)}; if (auto const ter = accountSend( - view(), brokerPseudoID, account_, coverAvailable, j_, WaiveTransferFee::Yes)) + view(), brokerPseudoID, accountID_, coverAvailable, j_, WaiveTransferFee::Yes)) return ter; } @@ -177,7 +191,7 @@ LoanBrokerDelete::doApply() view().erase(broker); { - auto owner = view().peek(keylet::account(account_)); + auto owner = view().peek(keylet::account(accountID_)); if (!owner) return tefBAD_LEDGER; // LCOV_EXCL_LINE @@ -197,6 +211,7 @@ LoanBrokerDelete::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -207,6 +222,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..6e3d2ad0a8 100644 --- a/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp @@ -38,15 +38,15 @@ LoanBrokerSet::preflight(PreflightContext const& ctx) auto const& tx = ctx.tx; if (auto const data = tx[~sfData]; - data && !data->empty() && !validDataLength(tx[~sfData], kMAX_DATA_PAYLOAD_LENGTH)) + data && !data->empty() && !validDataLength(tx[~sfData], kMaxDataPayloadLength)) return temINVALID; - if (!validNumericRange(tx[~sfManagementFeeRate], kMAX_MANAGEMENT_FEE_RATE)) + if (!validNumericRange(tx[~sfManagementFeeRate], kMaxManagementFeeRate)) return temINVALID; - if (!validNumericRange(tx[~sfCoverRateMinimum], kMAX_COVER_RATE)) + if (!validNumericRange(tx[~sfCoverRateMinimum], kMaxCoverRate)) return temINVALID; - if (!validNumericRange(tx[~sfCoverRateLiquidation], kMAX_COVER_RATE)) + if (!validNumericRange(tx[~sfCoverRateLiquidation], kMaxCoverRate)) return temINVALID; - if (!validNumericRange(tx[~sfDebtMaximum], Number(kMAX_MP_TOKEN_AMOUNT), Number(0))) + if (!validNumericRange(tx[~sfDebtMaximum], Number(kMaxMpTokenAmount), Number(0))) return temINVALID; if (tx.isFieldPresent(sfLoanBrokerID)) @@ -57,13 +57,13 @@ LoanBrokerSet::preflight(PreflightContext const& ctx) tx.isFieldPresent(sfCoverRateLiquidation)) return temINVALID; - if (tx[sfLoanBrokerID] == beast::kZERO) + if (tx[sfLoanBrokerID] == beast::kZero) return temINVALID; } if (auto const vaultID = tx.at(~sfVaultID)) { - if (*vaultID == beast::kZERO) + if (*vaultID == beast::kZero) return temINVALID; } @@ -83,9 +83,9 @@ LoanBrokerSet::preflight(PreflightContext const& ctx) std::vector> const& LoanBrokerSet::getValueFields() { - static std::vector> const kVALUE_FIELDS{~sfDebtMaximum}; + static std::vector> const kValueFields{~sfDebtMaximum}; - return kVALUE_FIELDS; + return kValueFields; } TER @@ -220,7 +220,7 @@ LoanBrokerSet::doApply() auto const vaultAsset = sleVault->at(sfAsset); auto const sequence = tx.getSeqValue(); - auto owner = view.peek(keylet::account(account_)); + auto owner = view.peek(keylet::account(accountID_)); if (!owner) { // This should be impossible @@ -229,9 +229,9 @@ LoanBrokerSet::doApply() return tefBAD_LEDGER; // LCOV_EXCL_STOP } - auto broker = std::make_shared(keylet::loanbroker(account_, sequence)); + auto broker = std::make_shared(keylet::loanbroker(accountID_, sequence)); - if (auto const ter = dirLink(view, account_, broker)) + if (auto const ter = dirLink(view, accountID_, broker)) return ter; // LCOV_EXCL_LINE if (auto const ter = dirLink(view, vaultPseudoID, broker, sfVaultNode)) return ter; // LCOV_EXCL_LINE @@ -255,7 +255,7 @@ LoanBrokerSet::doApply() // Initialize data fields: broker->at(sfSequence) = sequence; broker->at(sfVaultID) = vaultID; - broker->at(sfOwner) = account_; + broker->at(sfOwner) = accountID_; broker->at(sfAccount) = pseudoId; // The LoanSequence indexes loans created by this broker, starting at 1 broker->at(sfLoanSequence) = 1; @@ -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..813700bd7a 100644 --- a/src/libxrpl/tx/transactors/lending/LoanDelete.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp @@ -29,7 +29,7 @@ LoanDelete::checkExtraFeatures(PreflightContext const& ctx) NotTEC LoanDelete::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfLoanID] == beast::kZERO) + if (ctx.tx[sfLoanID] == beast::kZero) return temINVALID; return tesSUCCESS; @@ -117,14 +117,14 @@ LoanDelete::doApply() if (brokerSle->at(sfOwnerCount) == 0) { auto debtTotalProxy = brokerSle->at(sfDebtTotal); - if (*debtTotalProxy != beast::kZERO) + if (*debtTotalProxy != beast::kZero) { XRPL_ASSERT_PARTS( roundToAsset( vaultSle->at(sfAsset), debtTotalProxy, getAssetsTotalScale(vaultSle), - Number::RoundingMode::TowardsZero) == beast::kZERO, + Number::RoundingMode::TowardsZero) == beast::kZero, "xrpl::LoanDelete::doApply", "last loan, remaining debt rounds to zero"); debtTotalProxy = 0; @@ -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..d3165006b5 100644 --- a/src/libxrpl/tx/transactors/lending/LoanManage.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanManage.cpp @@ -45,7 +45,7 @@ LoanManage::getFlagsMask(PreflightContext const& ctx) NotTEC LoanManage::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfLoanID] == beast::kZERO) + if (ctx.tx[sfLoanID] == beast::kZero) return temINVALID; // Flags are mutually exclusive @@ -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..65220573de 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 { @@ -48,10 +49,10 @@ LoanPay::getFlagsMask(PreflightContext const& ctx) NotTEC LoanPay::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfLoanID] == beast::kZERO) + if (ctx.tx[sfLoanID] == beast::kZero) return temINVALID; - if (ctx.tx[sfAmount] <= beast::kZERO) + if (ctx.tx[sfAmount] <= beast::kZero) return temBAD_AMOUNT; // The loan payment flags are all mutually exclusive. If more than one is @@ -96,9 +97,9 @@ LoanPay::calculateBaseFee(ReadView const& view, STTx const& tx) return normalCost; } - if (loanSle->at(sfPaymentRemaining) <= kLOAN_PAYMENTS_PER_FEE_INCREMENT) + if (loanSle->at(sfPaymentRemaining) <= kLoanPaymentsPerFeeIncrement) { - // If there are fewer than loanPaymentsPerFeeIncrement payments left to + // If there are fewer than kLoanPaymentsPerFeeIncrement payments left to // pay, we can skip the computations. return normalCost; } @@ -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(kLoanMaximumPaymentsPerTransaction % kLoanPaymentsPerFeeIncrement == 0); + static constexpr std::int64_t kMaxFeeIncrements = + kLoanMaximumPaymentsPerTransaction / kLoanPaymentsPerFeeIncrement; + + if (view.rules().enabled(fixCleanup3_1_3) && + amount >= regularPayment * kLoanMaximumPaymentsPerTransaction) + { + // 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 kMaxFeeIncrements * 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)); + static_cast(numPaymentEstimate / kLoanPaymentsPerFeeIncrement)); + XRPL_ASSERT( + !view.rules().enabled(fixCleanup3_1_3) || feeIncrements <= kMaxFeeIncrements, + "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); @@ -288,6 +311,8 @@ LoanPay::doApply() TenthBips32 const coverRateMinimum{brokerSle->at(sfCoverRateMinimum)}; auto debtTotalProxy = brokerSle->at(sfDebtTotal); + auto const vaultScale = getAssetsTotalScale(vaultSle); + // Send the broker fee to the owner if they have sufficient cover available, // _and_ if the owner can receive funds // _and_ if the broker is authorized to hold funds. If not, so as not to @@ -297,14 +322,22 @@ LoanPay::doApply() // Normally freeze status is checked in preclaim, but we do it here to // avoid duplicating the check. It'll claim a fee either way. bool const sendBrokerFeeToOwner = [&]() { - // Round the minimum required cover up to be conservative. This ensures - // CoverAvailable never drops below the theoretical minimum, protecting - // the broker's solvency. - NumberRoundModeGuard const mg(Number::RoundingMode::Upward); - return coverAvailableProxy >= - roundToAsset( - asset, tenthBipsOfValue(debtTotalProxy.value(), coverRateMinimum), loanScale) && - !isDeepFrozen(view, brokerOwner, asset) && + // In the fixCleanup3_2_0 path, vault-related values (for example, + // DebtTotal) use vaultScale. The legacy path below intentionally retains + // its pre-amendment loanScale behavior. + auto const minCover = [&]() { + if (view.rules().enabled(fixCleanup3_2_0)) + { + return minimumBrokerCover(debtTotalProxy.value(), coverRateMinimum, vaultSle); + } + // Round the minimum required cover up to be conservative. This ensures + // CoverAvailable never drops below the theoretical minimum, protecting + // the broker's solvency. + NumberRoundModeGuard const mg(Number::RoundingMode::Upward); + return roundToAsset( + asset, tenthBipsOfValue(debtTotalProxy.value(), coverRateMinimum), loanScale); + }(); + return coverAvailableProxy >= minCover && !isDeepFrozen(view, brokerOwner, asset) && !requireAuth(view, asset, brokerOwner, AuthType::StrongAuth); }(); @@ -400,10 +433,6 @@ LoanPay::doApply() auto assetsAvailableProxy = vaultSle->at(sfAssetsAvailable); auto assetsTotalProxy = vaultSle->at(sfAssetsTotal); - // The vault may be at a different scale than the loan. Reduce rounding - // errors during the payment by rounding some of the values to that scale. - auto const vaultScale = getAssetsTotalScale(vaultSle); - auto const totalPaidToVaultRaw = paymentParts->principalPaid + paymentParts->interestPaid; auto const totalPaidToVaultRounded = roundToAsset(asset, totalPaidToVaultRaw, vaultScale, Number::RoundingMode::Downward); @@ -442,9 +471,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 +498,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,21 +523,77 @@ 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_, + accountID_, asset, FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, j_, SpendableHandling::FullBalance); - auto const vaultBalanceBefore = account_ == vaultPseudoAccount + auto const vaultBalanceBefore = accountID_ == vaultPseudoAccount ? STAmount{asset, 0} : accountHolds( view, @@ -527,26 +603,26 @@ LoanPay::doApply() AuthHandling::IgnoreAuth, j_, SpendableHandling::FullBalance); - auto const brokerBalanceBefore = account_ == brokerPayee ? STAmount{asset, 0} - : accountHolds( - view, - brokerPayee, - asset, - FreezeHandling::IgnoreFreeze, - AuthHandling::IgnoreAuth, - j_, - SpendableHandling::FullBalance); -#endif + auto const brokerBalanceBefore = accountID_ == brokerPayee + ? STAmount{asset, 0} + : accountHolds( + view, + brokerPayee, + asset, + FreezeHandling::IgnoreFreeze, + AuthHandling::IgnoreAuth, + j_, + SpendableHandling::FullBalance); - if (totalPaidToVaultRounded != beast::kZERO) + if (totalPaidToVaultRounded != beast::kZero) { if (auto const ter = requireAuth(view, asset, vaultPseudoAccount, AuthType::StrongAuth)) return ter; } - if (totalPaidToBroker != beast::kZERO) + if (totalPaidToBroker != beast::kZero) { - if (brokerPayee == account_) + if (brokerPayee == accountID_) { // The broker may have deleted their holding. Recreate it if needed if (auto const ter = addEmptyHolding( @@ -564,7 +640,7 @@ LoanPay::doApply() if (auto const ter = accountSendMulti( view, - account_, + accountID_, asset, {{vaultPseudoAccount, totalPaidToVaultRounded}, {brokerPayee, totalPaidToBroker}}, j_, @@ -572,28 +648,31 @@ 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_, + accountID_, asset, FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, j_, SpendableHandling::FullBalance); - auto const vaultBalanceAfter = account_ == vaultPseudoAccount + auto const vaultBalanceAfter = accountID_ == vaultPseudoAccount ? STAmount{asset, 0} : accountHolds( view, @@ -603,29 +682,136 @@ LoanPay::doApply() AuthHandling::IgnoreAuth, j_, SpendableHandling::FullBalance); - auto const brokerBalanceAfter = account_ == brokerPayee ? STAmount{asset, 0} - : accountHolds( - view, - brokerPayee, - asset, - FreezeHandling::IgnoreFreeze, - AuthHandling::IgnoreAuth, - j_, - SpendableHandling::FullBalance); + auto const brokerBalanceAfter = accountID_ == brokerPayee ? STAmount{asset, 0} + : accountHolds( + view, + brokerPayee, + asset, + FreezeHandling::IgnoreFreeze, + 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::kMaxOffset, 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::kMaxOffset); + }(); + + // No object changes are made below this point + XRPL_ASSERT_PARTS( + Number::getround() == Number::RoundingMode::ToNearest, + "xrpl::LoanPay::doApply", + "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( + goodRounding, "xrpl::LoanPay::doApply", "funds are conserved (with rounding)"); XRPL_ASSERT_PARTS( - accountBalanceBefore + vaultBalanceBefore + brokerBalanceBefore == - accountBalanceAfter + vaultBalanceAfter + brokerBalanceAfter, - "xrpl::LoanPay::doApply", - "funds are conserved (with rounding)"); - XRPL_ASSERT_PARTS( - accountBalanceAfter >= beast::kZERO, "xrpl::LoanPay::doApply", "positive account balance"); - XRPL_ASSERT_PARTS( - accountBalanceAfter < accountBalanceBefore || account_ == asset.getIssuer(), + accountBalanceAfter < accountBalanceBefore || accountID_ == asset.getIssuer(), "xrpl::LoanPay::doApply", "account balance decreased"); XRPL_ASSERT_PARTS( - vaultBalanceAfter >= beast::kZERO && brokerBalanceAfter >= beast::kZERO, + vaultBalanceAfter >= beast::kZero && brokerBalanceAfter >= beast::kZero, "xrpl::LoanPay::doApply", "positive vault and broker balances"); XRPL_ASSERT_PARTS( @@ -640,7 +826,6 @@ LoanPay::doApply() vaultBalanceAfter > vaultBalanceBefore || brokerBalanceAfter > brokerBalanceBefore, "xrpl::LoanPay::doApply", "vault and/or broker balance increased"); -#endif return tesSUCCESS; } @@ -651,11 +836,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..561ab6b2aa 100644 --- a/src/libxrpl/tx/transactors/lending/LoanSet.cpp +++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp @@ -85,7 +85,7 @@ LoanSet::preflight(PreflightContext const& ctx) } if (auto const data = tx[~sfData]; - data && !data->empty() && !validDataLength(tx[~sfData], kMAX_DATA_PAYLOAD_LENGTH)) + data && !data->empty() && !validDataLength(tx[~sfData], kMaxDataPayloadLength)) return temINVALID; for (auto const& field : {&sfLoanServiceFee, &sfLatePaymentFee, &sfClosePaymentFee}) { @@ -98,27 +98,27 @@ LoanSet::preflight(PreflightContext const& ctx) return temINVALID; if (!validNumericRange(tx[~sfLoanOriginationFee], p)) return temINVALID; - if (!validNumericRange(tx[~sfInterestRate], kMAX_INTEREST_RATE)) + if (!validNumericRange(tx[~sfInterestRate], kMaxInterestRate)) return temINVALID; - if (!validNumericRange(tx[~sfOverpaymentFee], kMAX_OVERPAYMENT_FEE)) + if (!validNumericRange(tx[~sfOverpaymentFee], kMaxOverpaymentFee)) return temINVALID; - if (!validNumericRange(tx[~sfLateInterestRate], kMAX_LATE_INTEREST_RATE)) + if (!validNumericRange(tx[~sfLateInterestRate], kMaxLateInterestRate)) return temINVALID; - if (!validNumericRange(tx[~sfCloseInterestRate], kMAX_CLOSE_INTEREST_RATE)) + if (!validNumericRange(tx[~sfCloseInterestRate], kMaxCloseInterestRate)) return temINVALID; - if (!validNumericRange(tx[~sfOverpaymentInterestRate], kMAX_OVERPAYMENT_INTEREST_RATE)) + if (!validNumericRange(tx[~sfOverpaymentInterestRate], kMaxOverpaymentInterestRate)) return temINVALID; if (auto const paymentTotal = tx[~sfPaymentTotal]; paymentTotal && *paymentTotal <= 0) return temINVALID; auto const paymentInterval = tx[~sfPaymentInterval]; - if (!validNumericMinimum(paymentInterval, LoanSet::kMIN_PAYMENT_INTERVAL)) + if (!validNumericMinimum(paymentInterval, LoanSet::kMinPaymentInterval)) return temINVALID; // Grace period is between min default value and payment interval if (auto const gracePeriod = tx[~sfGracePeriod]; !validNumericRange( gracePeriod, - paymentInterval.value_or(LoanSet::kDEFAULT_PAYMENT_INTERVAL), - kDEFAULT_GRACE_PERIOD)) + paymentInterval.value_or(LoanSet::kDefaultPaymentInterval), + kDefaultGracePeriod)) { return temINVALID; } @@ -131,7 +131,7 @@ LoanSet::preflight(PreflightContext const& ctx) return *ret; } - if (auto const brokerID = ctx.tx[~sfLoanBrokerID]; brokerID && *brokerID == beast::kZERO) + if (auto const brokerID = ctx.tx[~sfLoanBrokerID]; brokerID && *brokerID == beast::kZero) return temINVALID; return tesSUCCESS; @@ -195,7 +195,7 @@ LoanSet::calculateBaseFee(ReadView const& view, STTx const& tx) std::vector> const& LoanSet::getValueFields() { - static std::vector> const kVALUE_FIELDS{ + static std::vector> const kValueFields{ ~sfPrincipalRequested, ~sfLoanOriginationFee, ~sfLoanServiceFee, @@ -204,7 +204,7 @@ LoanSet::getValueFields() // Overpayment fee is really a rate. Don't check it here. }; - return kVALUE_FIELDS; + return kValueFields; } static std::uint32_t @@ -226,14 +226,14 @@ LoanSet::preclaim(PreclaimContext const& ctx) // overflows, and we kill the transaction. using timeType = decltype(sfNextPaymentDueDate)::type::value_type; static_assert(std::is_same_v); - timeType constexpr kMAX_TIME = std::numeric_limits::max(); - static_assert(kMAX_TIME == 4'294'967'295); + constexpr timeType kMaxTime = std::numeric_limits::max(); + static_assert(kMaxTime == 4'294'967'295); - auto const timeAvailable = kMAX_TIME - getStartDate(ctx.view); + auto const timeAvailable = kMaxTime - getStartDate(ctx.view); - auto const interval = ctx.tx.at(~sfPaymentInterval).value_or(kDEFAULT_PAYMENT_INTERVAL); - auto const total = ctx.tx.at(~sfPaymentTotal).value_or(kDEFAULT_PAYMENT_TOTAL); - auto const grace = ctx.tx.at(~sfGracePeriod).value_or(kDEFAULT_GRACE_PERIOD); + auto const interval = ctx.tx.at(~sfPaymentInterval).value_or(kDefaultPaymentInterval); + auto const total = ctx.tx.at(~sfPaymentTotal).value_or(kDefaultPaymentTotal); + auto const grace = ctx.tx.at(~sfGracePeriod).value_or(kDefaultGracePeriod); // The grace period can't be larger than the interval. Check it first, // mostly so that unit tests can test that specific case. @@ -388,7 +388,7 @@ LoanSet::doApply() Asset const vaultAsset = vaultSle->at(sfAsset); auto const counterparty = tx[~sfCounterparty].value_or(brokerOwner); - auto const borrower = counterparty == brokerOwner ? account_ : counterparty; + auto const borrower = counterparty == brokerOwner ? accountID_ : counterparty; auto const borrowerSle = view.peek(keylet::account(borrower)); if (!borrowerSle) { @@ -414,10 +414,11 @@ LoanSet::doApply() TenthBips32 const interestRate{tx[~sfInterestRate].value_or(0)}; - auto const paymentInterval = tx[~sfPaymentInterval].value_or(kDEFAULT_PAYMENT_INTERVAL); - auto const paymentTotal = tx[~sfPaymentTotal].value_or(kDEFAULT_PAYMENT_TOTAL); + auto const paymentInterval = tx[~sfPaymentInterval].value_or(kDefaultPaymentInterval); + auto const paymentTotal = tx[~sfPaymentTotal].value_or(kDefaultPaymentTotal); auto const properties = computeLoanProperties( + view.rules(), vaultAsset, principalRequested, interestRate, @@ -459,7 +460,7 @@ LoanSet::doApply() if (auto const ret = checkLoanGuards( vaultAsset, principalRequested, - interestRate != beast::kZERO, + interestRate != beast::kZero, paymentTotal, properties, j_)) @@ -492,11 +493,19 @@ LoanSet::doApply() } TenthBips32 const coverRateMinimum{brokerSle->at(sfCoverRateMinimum)}; { - // Round the minimum required cover up to be conservative. This ensures - // CoverAvailable never drops below the theoretical minimum, protecting - // the broker's solvency. - NumberRoundModeGuard const mg(Number::RoundingMode::Upward); - if (brokerSle->at(sfCoverAvailable) < tenthBipsOfValue(newDebtTotal, coverRateMinimum)) + auto const minCover = [&]() { + if (ctx_.view().rules().enabled(fixCleanup3_2_0)) + { + return minimumBrokerCover(newDebtTotal, coverRateMinimum, vaultSle); + } + + // Round the minimum required cover up to be conservative. This ensures + // CoverAvailable never drops below the theoretical minimum, protecting + // the broker's solvency. + NumberRoundModeGuard const mg(Number::RoundingMode::Upward); + return tenthBipsOfValue(newDebtTotal, coverRateMinimum); + }(); + if (brokerSle->at(sfCoverAvailable) < minCover) { JLOG(j_.warn()) << "Insufficient first-loss capital to cover the loan."; return tecINSUFFICIENT_FUNDS; @@ -507,7 +516,7 @@ LoanSet::doApply() { auto const ownerCount = borrowerSle->at(sfOwnerCount); auto const balance = - account_ == borrower ? preFeeBalance_ : borrowerSle->at(sfBalance).value().xrp(); + accountID_ == borrower ? preFeeBalance_ : borrowerSle->at(sfBalance).value().xrp(); if (balance < view.fees().accountReserve(ownerCount)) return tecINSUFFICIENT_RESERVE; } @@ -519,7 +528,7 @@ LoanSet::doApply() // Create a holding for the borrower if one does not already exist. XRPL_ASSERT_PARTS( - borrower == account_ || borrower == counterparty, + borrower == accountID_ || borrower == counterparty, "xrpl::LoanSet::doApply", "borrower signed transaction"); if (auto const ter = addEmptyHolding( @@ -536,12 +545,12 @@ LoanSet::doApply() // 2. Transfer originationFee, if any, from vault pseudo-account to // LoanBroker owner. - if (originationFee != beast::kZERO) + if (originationFee != beast::kZero) { // Create the holding if it doesn't already exist (necessary for MPTs). // The owner may have deleted their MPT / line at some point. XRPL_ASSERT_PARTS( - brokerOwner == account_ || brokerOwner == counterparty, + brokerOwner == accountID_ || brokerOwner == counterparty, "xrpl::LoanSet::doApply", "broker owner signed transaction"); @@ -600,7 +609,7 @@ LoanSet::doApply() setLoanField(~sfLateInterestRate); setLoanField(~sfCloseInterestRate); setLoanField(~sfOverpaymentInterestRate); - setLoanField(~sfGracePeriod, kDEFAULT_GRACE_PERIOD); + setLoanField(~sfGracePeriod, kDefaultGracePeriod); // Set dynamic / computed fields to their initial values loan->at(sfPrincipalOutstanding) = principalRequested; loan->at(sfPeriodicPayment) = properties.periodicPayment; @@ -652,11 +661,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..b80d282d70 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp @@ -44,7 +44,7 @@ NFTokenAcceptOffer::preflight(PreflightContext const& ctx) if (!bo || !so) return temMALFORMED; - if (*bf <= beast::kZERO) + if (*bf <= beast::kZero) return temMALFORMED; } @@ -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: @@ -306,7 +306,7 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx) // give the NFToken issuer an undesired trust line. // Issuer doesn't need a trust line to accept their own currency. if (ctx.view.rules().enabled(fixEnforceNFTokenTrustline) && - (nft::getFlags(tokenID) & nft::kFLAG_CREATE_TRUST_LINES) == 0 && + (nft::getFlags(tokenID) & nft::kFlagCreateTrustLines) == 0 && nftMinter != amount.getIssuer() && !ctx.view.read(keylet::line(nftMinter, amount.get()))) return tecNO_LINE; @@ -333,7 +333,7 @@ TER NFTokenAcceptOffer::pay(AccountID const& from, AccountID const& to, STAmount const& amount) { // This should never happen, but it's easy and quick to check. - if (amount < beast::kZERO) + if (amount < beast::kZero) return tecINTERNAL; // LCOV_EXCL_LINE auto const result = accountSend(view(), from, to, amount, j_); @@ -407,12 +407,12 @@ NFTokenAcceptOffer::acceptOffer(std::shared_ptr const& offer) { bool const isSell = offer->isFlag(lsfSellNFToken); AccountID const owner = (*offer)[sfOwner]; - AccountID const& seller = isSell ? owner : account_; - AccountID const& buyer = isSell ? account_ : owner; + AccountID const& seller = isSell ? owner : accountID_; + AccountID const& buyer = isSell ? accountID_ : owner; auto const nftokenID = (*offer)[sfNFTokenID]; - if (auto amount = offer->getFieldAmount(sfAmount); amount != beast::kZERO) + if (auto amount = offer->getFieldAmount(sfAmount); amount != beast::kZero) { // Calculate the issuer's cut from this sale, if any: if (auto const fee = nft::getTransferFee(nftokenID); fee != 0) @@ -420,7 +420,7 @@ NFTokenAcceptOffer::acceptOffer(std::shared_ptr const& offer) auto const cut = multiply(amount, nft::transferFeeAsRate(fee)); if (auto const issuer = nft::getIssuer(nftokenID); - cut != beast::kZERO && seller != issuer && buyer != issuer) + cut != beast::kZero && seller != issuer && buyer != issuer) { if (auto const r = pay(buyer, issuer, cut); !isTesSuccess(r)) return r; @@ -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; @@ -526,16 +526,16 @@ NFTokenAcceptOffer::doApply() // being paid out than the seller authorized. That would be bad! // Send the broker the amount they requested. - if (auto const cut = ctx_.tx[~sfNFTokenBrokerFee]; cut && cut.value() != beast::kZERO) + if (auto const cut = ctx_.tx[~sfNFTokenBrokerFee]; cut && cut.value() != beast::kZero) { - if (auto const r = pay(buyer, account_, cut.value()); !isTesSuccess(r)) + if (auto const r = pay(buyer, accountID_, cut.value()); !isTesSuccess(r)) return r; amount -= cut.value(); } // Calculate the issuer's cut, if any. - if (auto const fee = nft::getTransferFee(nftokenID); amount != beast::kZERO && fee != 0) + if (auto const fee = nft::getTransferFee(nftokenID); amount != beast::kZero && fee != 0) { auto cut = multiply(amount, nft::transferFeeAsRate(fee)); @@ -549,7 +549,7 @@ NFTokenAcceptOffer::doApply() } // And send whatever remains to the seller. - if (amount > beast::kZERO) + if (amount > beast::kZero) { if (auto const r = pay(buyer, seller, amount); !isTesSuccess(r)) return r; @@ -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..871a8e706a 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp @@ -40,7 +40,7 @@ NFTokenBurn::preclaim(PreclaimContext const& ctx) // do so if the token is marked as burnable. if (auto const account = ctx.tx[sfAccount]; owner != account) { - if ((nft::getFlags(ctx.tx[sfNFTokenID]) & nft::kFLAG_BURNABLE) == 0) + if ((nft::getFlags(ctx.tx[sfNFTokenID]) & nft::kFlagBurnable) == 0) return tecNO_PERMISSION; if (auto const issuer = nft::getIssuer(ctx.tx[sfNFTokenID]); issuer != account) @@ -81,14 +81,14 @@ NFTokenBurn::doApply() // the number of buy offers, we prioritize the deletion of sell // offers in order to clean up sell offer directory std::size_t const deletedSellOffers = nft::removeTokenOffersWithLimit( - view(), keylet::nftSells(ctx_.tx[sfNFTokenID]), kMAX_DELETABLE_TOKEN_OFFER_ENTRIES); + view(), keylet::nftSells(ctx_.tx[sfNFTokenID]), kMaxDeletableTokenOfferEntries); - if (kMAX_DELETABLE_TOKEN_OFFER_ENTRIES > deletedSellOffers) + if (kMaxDeletableTokenOfferEntries > deletedSellOffers) { nft::removeTokenOffersWithLimit( view(), keylet::nftBuys(ctx_.tx[sfNFTokenID]), - kMAX_DELETABLE_TOKEN_OFFER_ENTRIES - deletedSellOffers); + kMaxDeletableTokenOfferEntries - deletedSellOffers); } return tesSUCCESS; @@ -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..924dc49269 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp @@ -24,7 +24,7 @@ NotTEC NFTokenCancelOffer::preflight(PreflightContext const& ctx) { if (auto const& ids = ctx.tx[sfNFTokenOffers]; - ids.empty() || (ids.size() > kMAX_TOKEN_OFFER_CANCEL_COUNT)) + ids.empty() || (ids.size() > kMaxTokenOfferCancelCount)) return temMALFORMED; // In order to prevent unnecessarily overlarge transactions, we @@ -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..e7faa30df8 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp @@ -86,7 +86,7 @@ NFTokenMint::preflight(PreflightContext const& ctx) { if (auto const f = ctx.tx[~sfTransferFee]) { - if (f > kMAX_TRANSFER_FEE) + if (f > kMaxTransferFee) return temBAD_NFTOKEN_TRANSFER_FEE; // If a non-zero TransferFee is set then the tfTransferable flag @@ -101,7 +101,7 @@ NFTokenMint::preflight(PreflightContext const& ctx) if (auto uri = ctx.tx[~sfURI]) { - if (uri->empty() || uri->length() > kMAX_TOKEN_URI_LENGTH) + if (uri->empty() || uri->length() > kMaxTokenUriLength) return temMALFORMED; } @@ -222,7 +222,7 @@ NFTokenMint::preclaim(PreclaimContext const& ctx) TER NFTokenMint::doApply() { - auto const issuer = ctx_.tx[~sfIssuer].value_or(account_); + auto const issuer = ctx_.tx[~sfIssuer].value_or(accountID_); auto const tokenSeq = [this, &issuer]() -> Expected { auto const root = view().peek(keylet::account(issuer)); @@ -279,7 +279,7 @@ NFTokenMint::doApply() return (tokenSeq.error()); std::uint32_t const ownerCountBefore = - view().read(keylet::account(account_))->getFieldU32(sfOwnerCount); + view().read(keylet::account(accountID_))->getFieldU32(sfOwnerCount); // Assemble the new NFToken. SOTemplate const* nfTokenTemplate = @@ -305,7 +305,7 @@ NFTokenMint::doApply() object.setFieldVL(sfURI, *uri); }); - if (TER const ret = nft::insertToken(ctx_.view(), account_, std::move(newToken)); + if (TER const ret = nft::insertToken(ctx_.view(), accountID_, std::move(newToken)); !isTesSuccess(ret)) return ret; @@ -333,7 +333,7 @@ NFTokenMint::doApply() // requiring the reserve to be met each time. The reserve is // only managed when a new NFT page or sell offer is added. if (auto const ownerCountAfter = - view().read(keylet::account(account_))->getFieldU32(sfOwnerCount); + view().read(keylet::account(accountID_))->getFieldU32(sfOwnerCount); ownerCountAfter > ownerCountBefore) { if (auto const reserve = view().fees().accountReserve(ownerCountAfter); @@ -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..7e3eeeefee 100644 --- a/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp +++ b/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp @@ -26,7 +26,7 @@ NFTokenModify::preflight(PreflightContext const& ctx) if (auto uri = ctx.tx[~sfURI]) { - if (uri->empty() || uri->length() > kMAX_TOKEN_URI_LENGTH) + if (uri->empty() || uri->length() > kMaxTokenUriLength) return temMALFORMED; } @@ -43,7 +43,7 @@ NFTokenModify::preclaim(PreclaimContext const& ctx) return tecNO_ENTRY; // Check if the NFT is mutable - if ((nft::getFlags(ctx.tx[sfNFTokenID]) & nft::kFLAG_MUTABLE) == 0) + if ((nft::getFlags(ctx.tx[sfNFTokenID]) & nft::kFlagMutable) == 0) return tecNO_PERMISSION; // Verify permissions for the issuer @@ -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..839b2b4e24 100644 --- a/src/libxrpl/tx/transactors/oracle/OracleDelete.cpp +++ b/src/libxrpl/tx/transactors/oracle/OracleDelete.cpp @@ -82,8 +82,8 @@ OracleDelete::deleteOracle( TER OracleDelete::doApply() { - if (auto sle = ctx_.view().peek(keylet::oracle(account_, ctx_.tx[sfOracleDocumentID]))) - return deleteOracle(ctx_.view(), sle, account_, j_); + if (auto sle = ctx_.view().peek(keylet::oracle(accountID_, ctx_.tx[sfOracleDocumentID]))) + return deleteOracle(ctx_.view(), sle, accountID_, j_); return tecINTERNAL; // LCOV_EXCL_LINE } @@ -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..66ce95f46c 100644 --- a/src/libxrpl/tx/transactors/oracle/OracleSet.cpp +++ b/src/libxrpl/tx/transactors/oracle/OracleSet.cpp @@ -43,7 +43,7 @@ OracleSet::preflight(PreflightContext const& ctx) auto const& dataSeries = ctx.tx.getFieldArray(sfPriceDataSeries); if (dataSeries.empty()) return temARRAY_EMPTY; - if (dataSeries.size() > kMAX_ORACLE_DATA_SERIES) + if (dataSeries.size() > kMaxOracleDataSeries) return temARRAY_TOO_LARGE; auto isInvalidLength = [&](auto const& sField, std::size_t length) { @@ -51,9 +51,8 @@ OracleSet::preflight(PreflightContext const& ctx) (ctx.tx[sField].length() == 0 || ctx.tx[sField].length() > length); }; - if (isInvalidLength(sfProvider, kMAX_ORACLE_PROVIDER) || - isInvalidLength(sfURI, kMAX_ORACLE_URI) || - isInvalidLength(sfAssetClass, kMAX_ORACLE_SYMBOL_CLASS)) + if (isInvalidLength(sfProvider, kMaxOracleProvider) || isInvalidLength(sfURI, kMaxOracleUri) || + isInvalidLength(sfAssetClass, kMaxOracleSymbolClass)) return temMALFORMED; return tesSUCCESS; @@ -72,13 +71,13 @@ OracleSet::preclaim(PreclaimContext const& ctx) std::size_t const closeTime = duration_cast(ctx.view.header().closeTime.time_since_epoch()).count(); std::size_t const lastUpdateTime = ctx.tx[sfLastUpdateTime]; - if (lastUpdateTime < kEPOCH_OFFSET.count()) + if (lastUpdateTime < kEpochOffset.count()) return tecINVALID_UPDATE_TIME; - std::size_t const lastUpdateTimeEpoch = lastUpdateTime - kEPOCH_OFFSET.count(); - if (closeTime < kMAX_LAST_UPDATE_TIME_DELTA) + std::size_t const lastUpdateTimeEpoch = lastUpdateTime - kEpochOffset.count(); + if (closeTime < kMaxLastUpdateTimeDelta) return tecINTERNAL; // LCOV_EXCL_LINE - if (lastUpdateTimeEpoch < (closeTime - kMAX_LAST_UPDATE_TIME_DELTA) || - lastUpdateTimeEpoch > (closeTime + kMAX_LAST_UPDATE_TIME_DELTA)) + if (lastUpdateTimeEpoch < (closeTime - kMaxLastUpdateTimeDelta) || + lastUpdateTimeEpoch > (closeTime + kMaxLastUpdateTimeDelta)) return tecINVALID_UPDATE_TIME; auto const sle = @@ -96,7 +95,7 @@ OracleSet::preclaim(PreclaimContext const& ctx) auto const key = tokenPairKey(entry); if (pairs.contains(key) || pairsDel.contains(key)) return temMALFORMED; - if (entry[~sfScale] > kMAX_PRICE_SCALE) + if (entry[~sfScale] > kMaxPriceScale) return temMALFORMED; if (entry.isFieldPresent(sfAssetPrice)) { @@ -166,7 +165,7 @@ OracleSet::preclaim(PreclaimContext const& ctx) if (pairs.empty()) return tecARRAY_EMPTY; - if (pairs.size() > kMAX_ORACLE_DATA_SERIES) + if (pairs.size() > kMaxOracleDataSeries) return tecARRAY_TOO_LARGE; auto const reserve = @@ -202,7 +201,7 @@ setPriceDataInnerObjTemplate(STObject& obj) TER OracleSet::doApply() { - auto const oracleID = keylet::oracle(account_, ctx_.tx[sfOracleDocumentID]); + auto const oracleID = keylet::oracle(accountID_, ctx_.tx[sfOracleDocumentID]); auto populatePriceData = [](STObject& priceData, STObject const& entry) { setPriceDataInnerObjTemplate(priceData); @@ -312,7 +311,7 @@ OracleSet::doApply() sle->setFieldU32(sfLastUpdateTime, ctx_.tx[sfLastUpdateTime]); auto page = ctx_.view().dirInsert( - keylet::ownerDir(account_), sle->key(), describeOwnerDir(account_)); + keylet::ownerDir(accountID_), sle->key(), describeOwnerDir(accountID_)); if (!page) return tecDIR_FULL; // LCOV_EXCL_LINE @@ -334,11 +333,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..8b4ad2f025 100644 --- a/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp +++ b/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp @@ -84,7 +84,7 @@ DepositPreauth::preflight(PreflightContext const& ctx) if (auto err = credentials::checkArray( ctx.tx.getFieldArray( authArrPresent ? sfAuthorizeCredentials : sfUnauthorizeCredentials), - kMAX_CREDENTIALS_ARRAY_SIZE, + kMaxCredentialsArraySize, ctx.j); !isTesSuccess(err)) return err; @@ -153,7 +153,7 @@ DepositPreauth::doApply() { if (ctx_.tx.isFieldPresent(sfAuthorize)) { - auto const sleOwner = view().peek(keylet::account(account_)); + auto const sleOwner = view().peek(keylet::account(accountID_)); if (!sleOwner) return {tefINTERNAL}; @@ -171,15 +171,15 @@ DepositPreauth::doApply() // Preclaim already verified that the Preauth entry does not yet exist. // Create and populate the Preauth entry. AccountID const auth{ctx_.tx[sfAuthorize]}; - Keylet const preauthKeylet = keylet::depositPreauth(account_, auth); + Keylet const preauthKeylet = keylet::depositPreauth(accountID_, auth); auto slePreauth = std::make_shared(preauthKeylet); - slePreauth->setAccountID(sfAccount, account_); + slePreauth->setAccountID(sfAccount, accountID_); slePreauth->setAccountID(sfAuthorize, auth); view().insert(slePreauth); - auto const page = - view().dirInsert(keylet::ownerDir(account_), preauthKeylet, describeOwnerDir(account_)); + auto const page = view().dirInsert( + keylet::ownerDir(accountID_), preauthKeylet, describeOwnerDir(accountID_)); JLOG(j_.trace()) << "Adding DepositPreauth to owner directory " << to_string(preauthKeylet.key) << ": " << (page ? "success" : "failure"); @@ -194,13 +194,13 @@ DepositPreauth::doApply() } else if (ctx_.tx.isFieldPresent(sfUnauthorize)) { - auto const preauth = keylet::depositPreauth(account_, ctx_.tx[sfUnauthorize]); + auto const preauth = keylet::depositPreauth(accountID_, ctx_.tx[sfUnauthorize]); return DepositPreauth::removeFromLedger(view(), preauth.key, j_); } else if (ctx_.tx.isFieldPresent(sfAuthorizeCredentials)) { - auto const sleOwner = view().peek(keylet::account(account_)); + auto const sleOwner = view().peek(keylet::account(accountID_)); if (!sleOwner) return tefINTERNAL; // LCOV_EXCL_LINE @@ -229,18 +229,18 @@ DepositPreauth::doApply() sortedLE.pushBack(std::move(cred)); } - Keylet const preauthKey = keylet::depositPreauth(account_, sortedTX); + Keylet const preauthKey = keylet::depositPreauth(accountID_, sortedTX); auto slePreauth = std::make_shared(preauthKey); if (!slePreauth) return tefINTERNAL; // LCOV_EXCL_LINE - slePreauth->setAccountID(sfAccount, account_); + slePreauth->setAccountID(sfAccount, accountID_); slePreauth->peekFieldArray(sfAuthorizeCredentials) = std::move(sortedLE); view().insert(slePreauth); - auto const page = - view().dirInsert(keylet::ownerDir(account_), preauthKey, describeOwnerDir(account_)); + auto const page = view().dirInsert( + keylet::ownerDir(accountID_), preauthKey, describeOwnerDir(accountID_)); JLOG(j_.trace()) << "Adding DepositPreauth to owner directory " << to_string(preauthKey.key) << ": " << (page ? "success" : "failure"); @@ -256,7 +256,7 @@ DepositPreauth::doApply() else if (ctx_.tx.isFieldPresent(sfUnauthorizeCredentials)) { auto const preauthKey = keylet::depositPreauth( - account_, credentials::makeSorted(ctx_.tx.getFieldArray(sfUnauthorizeCredentials))); + accountID_, credentials::makeSorted(ctx_.tx.getFieldArray(sfUnauthorizeCredentials))); return DepositPreauth::removeFromLedger(view(), preauthKey.key, j_); } @@ -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..1848d34786 100644 --- a/src/libxrpl/tx/transactors/payment/Payment.cpp +++ b/src/libxrpl/tx/transactors/payment/Payment.cpp @@ -53,7 +53,7 @@ Payment::makeTxConsequences(PreflightContext const& ctx) // If there's no sfSendMax in XRP, and the sfAmount isn't // in XRP, then the transaction does not spend XRP. - return maxAmount.native() ? maxAmount.xrp() : beast::kZERO; + return maxAmount.native() ? maxAmount.xrp() : beast::kZero; }; return TxConsequences{ctx.tx, calculateMaxXRPSpend(ctx.tx)}; @@ -78,7 +78,7 @@ getMaxSourceAmount( Issue{issue.currency, account}, dstAmount.mantissa(), dstAmount.exponent(), - dstAmount < beast::kZERO); + dstAmount < beast::kZero); }); } @@ -102,9 +102,9 @@ Payment::getFlagsMask(PreflightContext const& ctx) bool const isDstMPT = dstAmount.holds(); bool const mpTokensV2 = ctx.rules.enabled(featureMPTokensV2); - constexpr std::uint32_t kTF_MPT_PAYMENT_MASK_V1 = ~(tfUniversal | tfPartialPayment); + static constexpr std::uint32_t kTfMptPaymentMaskV1 = ~(tfUniversal | tfPartialPayment); std::uint32_t const paymentMask = - (isDstMPT && !mpTokensV2) ? kTF_MPT_PAYMENT_MASK_V1 : tfPaymentMask; + (isDstMPT && !mpTokensV2) ? kTfMptPaymentMaskV1 : tfPaymentMask; return paymentMask; } @@ -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); @@ -164,13 +162,13 @@ Payment::preflight(PreflightContext const& ctx) << "Payment destination account not specified."; return temDST_NEEDED; } - if (hasMax && maxSourceAmount <= beast::kZERO) + if (hasMax && maxSourceAmount <= beast::kZero) { JLOG(j.trace()) << "Malformed transaction: bad max amount: " << maxSourceAmount.getFullText(); return temBAD_AMOUNT; } - if (dstAmount <= beast::kZERO) + if (dstAmount <= beast::kZero) { JLOG(j.trace()) << "Malformed transaction: bad dst amount: " << dstAmount.getFullText(); return temBAD_AMOUNT; @@ -241,7 +239,7 @@ Payment::preflight(PreflightContext const& ctx) } auto const dMin = *deliverMin; - if (!isLegalNet(dMin) || dMin <= beast::kZERO) + if (!isLegalNet(dMin) || dMin <= beast::kZero) { JLOG(j.trace()) << "Malformed transaction: Invalid " << jss::DeliverMin.cStr() << " amount. " << dMin.getFullText(); @@ -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. @@ -376,8 +371,8 @@ Payment::preclaim(PreclaimContext const& ctx) { STPathSet const& paths = ctx.tx.getFieldPathSet(sfPaths); - if (paths.size() > kMAX_PATH_SIZE || std::ranges::any_of(paths, [](STPath const& path) { - return path.size() > kMAX_PATH_LENGTH; + if (paths.size() > kMaxPathSize || std::ranges::any_of(paths, [](STPath const& path) { + return path.size() > kMaxPathLength; })) { return telBAD_PATH_COUNT; @@ -406,17 +401,16 @@ 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]; AccountID const dstAccountID(ctx_.tx.getAccountID(sfDestination)); STAmount const dstAmount(ctx_.tx.getFieldAmount(sfAmount)); bool const isDstMPT = dstAmount.holds(); - STAmount const maxSourceAmount = getMaxSourceAmount(account_, dstAmount, sendMax); + STAmount const maxSourceAmount = getMaxSourceAmount(accountID_, dstAmount, sendMax); JLOG(j_.trace()) << "maxSourceAmount=" << maxSourceAmount.getFullText() << " dstAmount=" << dstAmount.getFullText(); @@ -431,7 +425,7 @@ Payment::doApply() sleDst = std::make_shared(k); sleDst->setAccountID(sfAccount, dstAccountID); sleDst->setFieldU32(sfSequence, view().seq()); - sleDst->setFieldAmount(sfBalance, XRPAmount(beast::kZERO)); + sleDst->setFieldAmount(sfBalance, XRPAmount(beast::kZero)); view().insert(sleDst); } @@ -459,7 +453,7 @@ Payment::doApply() // 2. If Account is deposit preauthorized by destination. if (auto err = verifyDepositPreauth( - ctx_.tx, ctx_.view(), account_, dstAccountID, sleDst, ctx_.journal); + ctx_.tx, ctx_.view(), accountID_, dstAccountID, sleDst, ctx_.journal); !isTesSuccess(err)) return err; @@ -478,7 +472,7 @@ Payment::doApply() maxSourceAmount, dstAmount, dstAccountID, - account_, + accountID_, ctx_.tx.getFieldPathSet(sfPaths), ctx_.tx[~sfDomainID], ctx_.registry, @@ -518,18 +512,18 @@ Payment::doApply() JLOG(j_.trace()) << " dstAmount=" << dstAmount.getFullText(); auto const& mptIssue = dstAmount.get(); - if (auto const ter = requireAuth(view(), mptIssue, account_); !isTesSuccess(ter)) + if (auto const ter = requireAuth(view(), mptIssue, accountID_); !isTesSuccess(ter)) return ter; if (auto const ter = requireAuth(view(), mptIssue, dstAccountID); !isTesSuccess(ter)) return ter; - if (auto const ter = canTransfer(view(), mptIssue, account_, dstAccountID); + if (auto const ter = canTransfer(view(), mptIssue, accountID_, dstAccountID); !isTesSuccess(ter)) return ter; if (auto err = verifyDepositPreauth( - ctx_.tx, ctx_.view(), account_, dstAccountID, sleDst, ctx_.journal); + ctx_.tx, ctx_.view(), accountID_, dstAccountID, sleDst, ctx_.journal); !isTesSuccess(err)) return err; @@ -538,13 +532,13 @@ Payment::doApply() // Transfer rate Rate rate{QUALITY_ONE}; // Payment between the holders - if (account_ != issuer && dstAccountID != issuer) + if (accountID_ != issuer && dstAccountID != issuer) { // If globally/individually locked then // - can't send between holders // - holder can send back to issuer // - issuer can send to holder - if (isAnyFrozen(view(), {account_, dstAccountID}, mptIssue)) + if (isAnyFrozen(view(), {accountID_, dstAccountID}, mptIssue)) return tecLOCKED; // Get the rate for a payment between the holders. @@ -572,7 +566,7 @@ Payment::doApply() return tecPATH_PARTIAL; PaymentSandbox pv(&view()); - auto res = accountSend(pv, account_, dstAccountID, amountDeliver, ctx_.journal); + auto res = accountSend(pv, accountID_, dstAccountID, amountDeliver, ctx_.journal); if (isTesSuccess(res)) { pv.apply(ctx_.rawView()); @@ -595,7 +589,7 @@ Payment::doApply() // Direct XRP payment. - auto const sleSrc = view().peek(keylet::account(account_)); + auto const sleSrc = view().peek(keylet::account(accountID_)); if (!sleSrc) return tefINTERNAL; // LCOV_EXCL_LINE @@ -607,10 +601,10 @@ Payment::doApply() auto const reserve = view().fees().accountReserve(ownerCount); // In a delegated payment, the fee payer is the delegated account, - // not the source account (account_). - bool const accountIsPayer = (ctx_.tx.getFeePayer() == account_); + // not the source account (accountID_). + bool const accountIsPayer = (ctx_.tx.getFeePayer() == accountID_); - // preFeeBalance_ is the balance on the source account (account_) BEFORE the fees + // preFeeBalance_ is the balance on the source account (accountID_) BEFORE the fees // were charged. If source account is the fee payer, it must also cover the fee. // The final spend may use the reserve to cover fees. auto const minRequiredFunds = @@ -662,7 +656,7 @@ Payment::doApply() if (dstAmount > dstReserve || sleDst->getFieldAmount(sfBalance) > dstReserve) { if (auto err = verifyDepositPreauth( - ctx_.tx, ctx_.view(), account_, dstAccountID, sleDst, ctx_.journal); + ctx_.tx, ctx_.view(), accountID_, dstAccountID, sleDst, ctx_.journal); !isTesSuccess(err)) return err; } @@ -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..cc99b8f62d 100644 --- a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelClaim.cpp +++ b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelClaim.cpp @@ -44,20 +44,18 @@ NotTEC PaymentChannelClaim::preflight(PreflightContext const& ctx) { auto const bal = ctx.tx[~sfBalance]; - if (bal && (!isXRP(*bal) || *bal <= beast::kZERO)) + if (bal && (!isXRP(*bal) || *bal <= beast::kZero)) return temBAD_AMOUNT; auto const amt = ctx.tx[~sfAmount]; - if (amt && (!isXRP(*amt) || *amt <= beast::kZERO)) + if (amt && (!isXRP(*amt) || *amt <= beast::kZero)) return temBAD_AMOUNT; if (bal && amt && *bal > *amt) 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; } @@ -167,13 +165,13 @@ PaymentChannelClaim::doApply() (*slep)[sfBalance] = ctx_.tx[sfBalance]; XRPAmount const reqDelta = reqBalance - chanBalance; XRPL_ASSERT( - reqDelta >= beast::kZERO, "xrpl::PaymentChannelClaim::doApply : minimum balance delta"); + reqDelta >= beast::kZero, "xrpl::PaymentChannelClaim::doApply : minimum balance delta"); (*sled)[sfBalance] = (*sled)[sfBalance] + reqDelta; ctx_.view().update(sled); 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..7ce25b6d15 100644 --- a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelCreate.cpp +++ b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelCreate.cpp @@ -56,7 +56,7 @@ PaymentChannelCreate::makeTxConsequences(PreflightContext const& ctx) NotTEC PaymentChannelCreate::preflight(PreflightContext const& ctx) { - if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::kZERO)) + if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::kZero)) return temBAD_AMOUNT; if (ctx.tx[sfAccount] == ctx.tx[sfDestination]) @@ -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..41906aa3da 100644 --- a/src/libxrpl/tx/transactors/payment_channel/PaymentChannelFund.cpp +++ b/src/libxrpl/tx/transactors/payment_channel/PaymentChannelFund.cpp @@ -31,7 +31,7 @@ PaymentChannelFund::makeTxConsequences(PreflightContext const& ctx) NotTEC PaymentChannelFund::preflight(PreflightContext const& ctx) { - if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::kZERO)) + if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::kZero)) return temBAD_AMOUNT; return tesSUCCESS; @@ -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..e36a0eb584 100644 --- a/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp +++ b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp @@ -20,7 +20,7 @@ NotTEC PermissionedDomainDelete::preflight(PreflightContext const& ctx) { auto const domain = ctx.tx.getFieldH256(sfDomainID); - if (domain == beast::kZERO) + if (domain == beast::kZero) return temMALFORMED; return tesSUCCESS; @@ -55,7 +55,7 @@ PermissionedDomainDelete::doApply() auto const slePd = view().peek(keylet::permissionedDomain(ctx_.tx.at(sfDomainID))); auto const page = (*slePd)[sfOwnerNode]; - if (!view().dirRemove(keylet::ownerDir(account_), page, slePd->key(), true)) + if (!view().dirRemove(keylet::ownerDir(accountID_), page, slePd->key(), true)) { // LCOV_EXCL_START JLOG(j_.fatal()) << "Unable to delete permissioned domain directory entry."; @@ -63,7 +63,7 @@ PermissionedDomainDelete::doApply() // LCOV_EXCL_STOP } - auto const ownerSle = view().peek(keylet::account(account_)); + auto const ownerSle = view().peek(keylet::account(accountID_)); XRPL_ASSERT( ownerSle && ownerSle->getFieldU32(sfOwnerCount) > 0, "xrpl::PermissionedDomainDelete::doApply : nonzero owner count"); @@ -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..ff4019ec59 100644 --- a/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp +++ b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp @@ -33,13 +33,13 @@ PermissionedDomainSet::preflight(PreflightContext const& ctx) { if (auto err = credentials::checkArray( ctx.tx.getFieldArray(sfAcceptedCredentials), - kMAX_PERMISSIONED_DOMAIN_CREDENTIALS_ARRAY_SIZE, + kMaxPermissionedDomainCredentialsArraySize, ctx.j); !isTesSuccess(err)) return err; auto const domain = ctx.tx.at(~sfDomainID); - if (domain && *domain == beast::kZERO) + if (domain && *domain == beast::kZero) return temMALFORMED; return tesSUCCESS; @@ -77,7 +77,7 @@ PermissionedDomainSet::preclaim(PreclaimContext const& ctx) TER PermissionedDomainSet::doApply() { - auto const ownerSle = view().peek(keylet::account(account_)); + auto const ownerSle = view().peek(keylet::account(accountID_)); if (!ownerSle) return tefINTERNAL; // LCOV_EXCL_LINE @@ -110,15 +110,16 @@ 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(accountID_, seq); auto slePd = std::make_shared(pdKeylet); - slePd->setAccountID(sfOwner, account_); - slePd->setFieldU32(sfSequence, ctx_.tx.getFieldU32(sfSequence)); + slePd->setAccountID(sfOwner, accountID_); + slePd->setFieldU32(sfSequence, seq); slePd->peekFieldArray(sfAcceptedCredentials) = std::move(sortedLE); auto const page = - view().dirInsert(keylet::ownerDir(account_), pdKeylet, describeOwnerDir(account_)); + view().dirInsert(keylet::ownerDir(accountID_), pdKeylet, describeOwnerDir(accountID_)); if (!page) return tecDIR_FULL; // LCOV_EXCL_LINE @@ -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..b9440e3273 100644 --- a/src/libxrpl/tx/transactors/system/Batch.cpp +++ b/src/libxrpl/tx/transactors/system/Batch.cpp @@ -62,7 +62,7 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx) if (baseFee > maxAmount - view.fees().base) { JLOG(debugLog().error()) << "BatchTrace: Base fee overflow detected."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } // LCOV_EXCL_STOP @@ -75,10 +75,10 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx) auto const& txns = tx.getFieldArray(sfRawTransactions); // LCOV_EXCL_START - if (txns.size() > kMAX_BATCH_TX_COUNT) + if (txns.size() > kMaxBatchTxCount) { JLOG(debugLog().error()) << "BatchTrace: Raw Transactions array exceeds max entries."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } // LCOV_EXCL_STOP @@ -90,7 +90,7 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx) if (stx.getTxnType() == ttBATCH) { JLOG(debugLog().error()) << "BatchTrace: Inner Batch transaction found."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } // LCOV_EXCL_STOP @@ -100,7 +100,7 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx) { JLOG(debugLog().error()) << "BatchTrace: XRPAmount overflow in txnFees calculation."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } // LCOV_EXCL_STOP txnFees += fee; @@ -114,10 +114,10 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx) auto const& signers = tx.getFieldArray(sfBatchSigners); // LCOV_EXCL_START - if (signers.size() > kMAX_BATCH_TX_COUNT) + if (signers.size() > kMaxBatchTxCount) { JLOG(debugLog().error()) << "BatchTrace: Batch Signers array exceeds max entries."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } // LCOV_EXCL_STOP @@ -138,7 +138,7 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx) if (signerCount > 0 && view.fees().base > maxAmount / signerCount) { JLOG(debugLog().error()) << "BatchTrace: XRPAmount overflow in signerCount calculation."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } // LCOV_EXCL_STOP @@ -148,12 +148,12 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx) if (signerFees > maxAmount - txnFees) { JLOG(debugLog().error()) << "BatchTrace: XRPAmount overflow in signerFees calculation."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } if (txnFees + signerFees > maxAmount - batchBase) { JLOG(debugLog().error()) << "BatchTrace: XRPAmount overflow in total fee calculation."; - return XRPAmount{kINITIAL_XRP}; + return XRPAmount{kInitialXrp}; } // LCOV_EXCL_STOP @@ -221,7 +221,7 @@ Batch::preflight(PreflightContext const& ctx) return temARRAY_EMPTY; } - if (rawTxns.size() > kMAX_BATCH_TX_COUNT) + if (rawTxns.size() > kMaxBatchTxCount) { JLOG(ctx.j.debug()) << "BatchTrace[" << parentBatchId << "]:" << "txns array exceeds 8 entries."; @@ -282,12 +282,12 @@ Batch::preflight(PreflightContext const& ctx) } if (std::ranges::any_of( - kDISABLED_TX_TYPES, [txType](auto const& disabled) { return txType == disabled; })) + kDisabledTxTypes, [txType](auto const& disabled) { return txType == disabled; })) { 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. " @@ -311,7 +311,7 @@ Batch::preflight(PreflightContext const& ctx) } // Check that the Fee is native asset (XRP) and zero - if (auto const fee = stx.getFieldAmount(sfFee); !fee.native() || fee.xrp() != beast::kZERO) + if (auto const fee = stx.getFieldAmount(sfFee); !fee.native() || fee.xrp() != beast::kZero) { JLOG(ctx.j.debug()) << "BatchTrace[" << parentBatchId << "]: " << "inner txn must have a fee of 0. " @@ -413,7 +413,7 @@ Batch::preflightSigValidated(PreflightContext const& ctx) STArray const& signers = ctx.tx.getFieldArray(sfBatchSigners); // Check that the batch signers array is not too large. - if (signers.size() > kMAX_BATCH_TX_COUNT) + if (signers.size() > kMaxBatchTxCount) { JLOG(ctx.j.debug()) << "BatchTrace[" << parentBatchId << "]: " << "signers array exceeds 8 entries."; @@ -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..92a06fd807 100644 --- a/src/libxrpl/tx/transactors/system/Change.cpp +++ b/src/libxrpl/tx/transactors/system/Change.cpp @@ -42,7 +42,7 @@ Transactor::invokePreflight(PreflightContext const& ctx) return ret; auto account = ctx.tx.getAccountID(sfAccount); - if (account != beast::kZERO) + if (account != beast::kZero) { JLOG(ctx.j.warn()) << "Change: Bad source id"; return temBAD_SRC_ACCOUNT; @@ -50,7 +50,7 @@ Transactor::invokePreflight(PreflightContext const& ctx) // No point in going any further if the transaction fee is malformed. auto const fee = ctx.tx.getFieldAmount(sfFee); - if (!fee.native() || fee != beast::kZERO) + if (!fee.native() || fee != beast::kZero) { JLOG(ctx.j.warn()) << "Change: invalid fee"; return temBAD_FEE; @@ -154,7 +154,7 @@ Change::doApply() void Change::preCompute() { - XRPL_ASSERT(account_ == beast::kZERO, "xrpl::Change::preCompute : zero account"); + XRPL_ASSERT(accountID_ == beast::kZero, "xrpl::Change::preCompute : zero account"); } TER @@ -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..222e5dce7a 100644 --- a/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp +++ b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp @@ -4,7 +4,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -12,24 +14,72 @@ #include #include +#include +#include #include +#include namespace xrpl { +namespace { + +using FixType = LedgerStateFix::FixType; + +std::array, 2> const kLedgerFixFields = {{ + {FixType::NfTokenPageLink, &sfOwner}, + {FixType::BookExchangeRate, &sfBookDirectory}, +}}; + +[[nodiscard]] SField const* +fixField(FixType const fixType) +{ + auto const iter = std::ranges::find_if( + kLedgerFixFields, [fixType](auto const& entry) { return entry.first == fixType; }); + + if (iter == kLedgerFixFields.end()) + return nullptr; // LCOV_EXCL_LINE + + return iter->second; +} + +[[nodiscard]] bool +hasUnexpectedFixField(STTx const& tx, SField const& expected) +{ + return std::ranges::any_of(kLedgerFixFields, [&tx, &expected](auto const& entry) { + auto const field = entry.second; + return field != &expected && tx.isFieldPresent(*field); + }); +} + +} // namespace + NotTEC LedgerStateFix::preflight(PreflightContext const& ctx) { - switch (static_cast(ctx.tx[sfLedgerFixType])) + auto const fixType = static_cast(ctx.tx[sfLedgerFixType]); + + switch (fixType) { case FixType::NfTokenPageLink: - if (!ctx.tx.isFieldPresent(sfOwner)) - return temINVALID; + break; + + case FixType::BookExchangeRate: + if (!ctx.rules.enabled(fixCleanup3_2_0)) + return temDISABLED; break; default: return tefINVALID_LEDGER_FIX_TYPE; } + auto const expectedField = fixField(fixType); + if (expectedField == nullptr) + return tefINVALID_LEDGER_FIX_TYPE; // LCOV_EXCL_LINE + + // Each fix type allows exactly one fix-specific field. + if (!ctx.tx.isFieldPresent(*expectedField) || hasUnexpectedFixField(ctx.tx, *expectedField)) + return temINVALID; + return tesSUCCESS; } @@ -53,6 +103,24 @@ LedgerStateFix::preclaim(PreclaimContext const& ctx) return tesSUCCESS; } + if (static_cast(ctx.tx[sfLedgerFixType]) == FixType::BookExchangeRate) + { + auto const dirKey = ctx.tx.getFieldH256(sfBookDirectory); + auto const sle = ctx.view.read(Keylet(ltDIR_NODE, dirKey)); + if (!sle) + return tecOBJECT_NOT_FOUND; + + // Must be the first page of a book directory (has sfExchangeRate). + if (!sle->isFieldPresent(sfExchangeRate)) + return tecNO_PERMISSION; + + // ExchangeRate is already correct, nothing to fix. + if (getQuality(sle->key()) == sle->getFieldU64(sfExchangeRate)) + return tecNO_PERMISSION; + + return tesSUCCESS; + } + // preflight is supposed to verify that only valid FixTypes get to preclaim. return tecINTERNAL; // LCOV_EXCL_LINE } @@ -68,6 +136,18 @@ LedgerStateFix::doApply() return tesSUCCESS; } + if (static_cast(ctx_.tx[sfLedgerFixType]) == FixType::BookExchangeRate) + { + auto const dirKey = ctx_.tx.getFieldH256(sfBookDirectory); + auto sle = view().peek(Keylet(ltDIR_NODE, dirKey)); + if (!sle) + return tecINTERNAL; // LCOV_EXCL_LINE + + sle->setFieldU64(sfExchangeRate, getQuality(sle->key())); + view().update(sle); + return tesSUCCESS; + } + // preflight is supposed to verify that only valid FixTypes get to doApply. return tecINTERNAL; // LCOV_EXCL_LINE } @@ -78,6 +158,7 @@ LedgerStateFix::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -88,6 +169,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..f442ac223b 100644 --- a/src/libxrpl/tx/transactors/system/TicketCreate.cpp +++ b/src/libxrpl/tx/transactors/system/TicketCreate.cpp @@ -32,7 +32,7 @@ NotTEC TicketCreate::preflight(PreflightContext const& ctx) { if (std::uint32_t const count = ctx.tx[sfTicketCount]; - count < kMIN_VALID_COUNT || count > kMAX_VALID_COUNT) + count < kMinValidCount || count > kMaxValidCount) return temINVALID_COUNT; return tesSUCCESS; @@ -58,7 +58,7 @@ TicketCreate::preclaim(PreclaimContext const& ctx) // o consumedTickets <= 1 // So in the worst case addedTickets == consumedTickets and the // computation yields curTicketCount. - if (curTicketCount + addedTickets - consumedTickets > kMAX_TICKET_THRESHOLD) + if (curTicketCount + addedTickets - consumedTickets > kMaxTicketThreshold) return tecDIR_FULL; return tesSUCCESS; @@ -67,7 +67,7 @@ TicketCreate::preclaim(PreclaimContext const& ctx) TER TicketCreate::doApply() { - SLE::pointer const sleAccountRoot = view().peek(keylet::account(account_)); + SLE::pointer const sleAccountRoot = view().peek(keylet::account(accountID_)); if (!sleAccountRoot) return tefINTERNAL; // LCOV_EXCL_LINE @@ -100,15 +100,15 @@ TicketCreate::doApply() for (std::uint32_t i = 0; i < ticketCount; ++i) { std::uint32_t const curTicketSeq = firstTicketSeq + i; - Keylet const ticketKeylet = keylet::kTICKET(account_, curTicketSeq); + Keylet const ticketKeylet = keylet::kTicket(accountID_, curTicketSeq); SLE::pointer const sleTicket = std::make_shared(ticketKeylet); - sleTicket->setAccountID(sfAccount, account_); + sleTicket->setAccountID(sfAccount, accountID_); sleTicket->setFieldU32(sfTicketSequence, curTicketSeq); view().insert(sleTicket); - auto const page = - view().dirInsert(keylet::ownerDir(account_), ticketKeylet, describeOwnerDir(account_)); + auto const page = view().dirInsert( + keylet::ownerDir(accountID_), ticketKeylet, describeOwnerDir(accountID_)); JLOG(j_.trace()) << "Creating ticket " << to_string(ticketKeylet.key) << ": " << (page ? "success" : "failure"); @@ -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..8532f97995 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 @@ -46,7 +45,7 @@ preflightHelper(PreflightContext const& ctx) // The issuer field is used for the token holder instead AccountID const& holder = clawAmount.getIssuer(); - if (issuer == holder || isXRP(clawAmount) || clawAmount <= beast::kZERO) + if (issuer == holder || isXRP(clawAmount) || clawAmount <= beast::kZero) return temBAD_AMOUNT; return tesSUCCESS; @@ -69,7 +68,7 @@ preflightHelper(PreflightContext const& ctx) if (ctx.tx[sfAccount] == *mptHolder) return temMALFORMED; - if (clawAmount.mpt() > MPTAmount{kMAX_MP_TOKEN_AMOUNT} || clawAmount <= beast::kZERO) + if (clawAmount.mpt() > MPTAmount{kMaxMpTokenAmount} || clawAmount <= beast::kZero) return temBAD_AMOUNT; return tesSUCCESS; @@ -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 = @@ -121,11 +117,11 @@ preclaimHelper( STAmount const balance = (*sleRippleState)[sfBalance]; // If balance is positive, issuer must have higher address than holder - if (balance > beast::kZERO && issuer < holder) + if (balance > beast::kZero && issuer < holder) return tecNO_PERMISSION; // If balance is negative, issuer must have lower address than holder - if (balance < beast::kZERO && issuer > holder) + if (balance < beast::kZero && issuer > holder) return tecNO_PERMISSION; // At this point, we know that issuer and holder accounts @@ -143,7 +139,7 @@ preclaimHelper( clawAmount.get().currency, issuer, FreezeHandling::IgnoreFreeze, - ctx.j) <= beast::kZERO) + ctx.j) <= beast::kZero) return tecINSUFFICIENT_FUNDS; return tesSUCCESS; @@ -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) @@ -178,7 +174,7 @@ preclaimHelper( clawAmount.get(), FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, - ctx.j) <= beast::kZERO) + ctx.j) <= beast::kZero) return tecINSUFFICIENT_FUNDS; return tesSUCCESS; @@ -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..9b0c8d2b56 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. @@ -135,8 +133,9 @@ MPTokenAuthorize::preclaim(PreclaimContext const& ctx) // Can't unauthorize the pseudo-accounts because they are implicitly // always authorized. No need to amendment gate since Vault and LoanBroker - // can only be created if the Vault amendment is enabled. - if (isPseudoAccount(ctx.view, *holderID, {&sfVaultID, &sfLoanBrokerID})) + // can only be created if the Vault amendment is enabled; AMM with MPToken asset + // can only be created if MPTokensV2 is enabled. + if (isPseudoAccount(ctx.view, *holderID, {&sfVaultID, &sfLoanBrokerID, &sfAMMID})) return tecNO_PERMISSION; return tesSUCCESS; @@ -150,7 +149,7 @@ MPTokenAuthorize::doApply() ctx_.view(), preFeeBalance_, tx[sfMPTokenIssuanceID], - account_, + accountID_, ctx_.journal, tx.getFlags(), tx[~sfHolder]); @@ -162,6 +161,7 @@ MPTokenAuthorize::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -172,6 +172,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..64d0b01f5e 100644 --- a/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp +++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -49,6 +50,11 @@ MPTokenIssuanceCreate::getFlagsMask(PreflightContext const& ctx) NotTEC MPTokenIssuanceCreate::preflight(PreflightContext const& ctx) { + // sfReferenceHolding is set only internally by VaultCreate. Reject + // any user-submitted MPTokenIssuanceCreate that attempts to carry it. + if (ctx.rules.enabled(fixCleanup3_2_0) && ctx.tx.isFieldPresent(sfReferenceHolding)) + return temMALFORMED; + // If the mutable flags field is included, at least one flag must be // specified. if (auto const mutableFlags = ctx.tx[~sfMutableFlags]; mutableFlags && @@ -57,7 +63,7 @@ MPTokenIssuanceCreate::preflight(PreflightContext const& ctx) if (auto const fee = ctx.tx[~sfTransferFee]) { - if (fee > kMAX_TRANSFER_FEE) + if (fee > kMaxTransferFee) return temBAD_TRANSFER_FEE; // If a non-zero TransferFee is set then the tfTransferable flag @@ -68,17 +74,17 @@ MPTokenIssuanceCreate::preflight(PreflightContext const& ctx) if (auto const domain = ctx.tx[~sfDomainID]) { - if (*domain == beast::kZERO) + if (*domain == beast::kZero) return temMALFORMED; // Domain present implies that MPTokenIssuance is not public - if ((ctx.tx.getFlags() & tfMPTRequireAuth) == 0) + if (!ctx.tx.isFlag(tfMPTRequireAuth)) return temMALFORMED; } if (auto const metadata = ctx.tx[~sfMPTokenMetadata]) { - if (metadata->empty() || metadata->length() > kMAX_MP_TOKEN_METADATA_LENGTH) + if (metadata->empty() || metadata->length() > kMaxMpTokenMetadataLength) return temMALFORMED; } @@ -88,7 +94,7 @@ MPTokenIssuanceCreate::preflight(PreflightContext const& ctx) if (maxAmt == 0) return temMALFORMED; - if (maxAmt > kMAX_MP_TOKEN_AMOUNT) + if (maxAmt > kMaxMpTokenAmount) return temMALFORMED; } return tesSUCCESS; @@ -141,6 +147,22 @@ MPTokenIssuanceCreate::create(ApplyView& view, beast::Journal journal, MPTCreate if (args.mutableFlags) (*mptIssuance)[sfMutableFlags] = *args.mutableFlags; + if (args.referenceHolding) + { + // Defensive: the holding must already exist and be of an + // expected type. Callers (currently only VaultCreate) + // populate this after the pseudo-account's MPToken / + // RippleState has been installed. A missing holding here + // would dangle the pointer and is a programmer error. + auto const sleHolding = view.read(keylet::unchecked(*args.referenceHolding)); + if (!sleHolding) + return Unexpected(tecINTERNAL); // LCOV_EXCL_LINE + auto const type = sleHolding->getType(); + if (type != ltMPTOKEN && type != ltRIPPLE_STATE) + return Unexpected(tecINTERNAL); // LCOV_EXCL_LINE + (*mptIssuance)[sfReferenceHolding] = *args.referenceHolding; + } + view.insert(mptIssuance); } @@ -159,7 +181,7 @@ MPTokenIssuanceCreate::doApply() j_, { .priorBalance = preFeeBalance_, - .account = account_, + .account = accountID_, .sequence = tx.getSeqValue(), .flags = tx.getFlags(), .maxAmount = tx[~sfMaximumAmount], @@ -178,6 +200,7 @@ MPTokenIssuanceCreate::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -188,6 +211,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..46811508b7 100644 --- a/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp +++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp @@ -45,15 +45,15 @@ TER MPTokenIssuanceDestroy::doApply() { auto const mpt = view().peek(keylet::mptIssuance(ctx_.tx[sfMPTokenIssuanceID])); - if (account_ != mpt->getAccountID(sfIssuer)) + if (accountID_ != mpt->getAccountID(sfIssuer)) return tecINTERNAL; // LCOV_EXCL_LINE - if (!view().dirRemove(keylet::ownerDir(account_), (*mpt)[sfOwnerNode], mpt->key(), false)) + if (!view().dirRemove(keylet::ownerDir(accountID_), (*mpt)[sfOwnerNode], mpt->key(), false)) return tefBAD_LEDGER; // LCOV_EXCL_LINE view().erase(mpt); - adjustOwnerCount(view(), view().peek(keylet::account(account_)), -1, j_); + adjustOwnerCount(view(), view().peek(keylet::account(accountID_)), -1, j_); return tesSUCCESS; } @@ -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..d8b62acf3f 100644 --- a/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp +++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp @@ -52,7 +52,7 @@ struct MPTMutabilityFlags std::uint32_t canMutateFlag; }; -static constexpr std::array kMPT_MUTABILITY_FLAGS = { +static constexpr std::array kMptMutabilityFlags = { {{.setFlag = tmfMPTSetCanLock, .clearFlag = tmfMPTClearCanLock, .canMutateFlag = lsmfMPTCanMutateCanLock}, @@ -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,13 +109,13 @@ 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) + if (transferFee && *transferFee > kMaxTransferFee) return temBAD_TRANSFER_FEE; - if (metadata && metadata->length() > kMAX_MP_TOKEN_METADATA_LENGTH) + if (metadata && metadata->length() > kMaxMpTokenMetadataLength) return temMALFORMED; if (mutableFlags) @@ -126,7 +124,7 @@ MPTokenIssuanceSet::preflight(PreflightContext const& ctx) return temINVALID_FLAG; // Can not set and clear the same flag - if (std::ranges::any_of(kMPT_MUTABILITY_FLAGS, [mutableFlags](auto const& f) { + if (std::ranges::any_of(kMptMutabilityFlags, [mutableFlags](auto const& f) { return (*mutableFlags & f.setFlag) && (*mutableFlags & f.clearFlag); })) return temINVALID_FLAG; @@ -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; @@ -218,7 +214,7 @@ MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx) if (not sleMptIssuance->isFlag(lsfMPTRequireAuth)) return tecNO_PERMISSION; - if (*domain != beast::kZERO) + if (*domain != beast::kZero) { auto const sleDomain = ctx.view.read(keylet::permissionedDomain(*domain)); if (!sleDomain) @@ -236,11 +232,10 @@ MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx) if (auto const mutableFlags = ctx.tx[~sfMutableFlags]) { - if (std::ranges::any_of( - kMPT_MUTABILITY_FLAGS, [mutableFlags, &isMutableFlag](auto const& f) { - return !isMutableFlag(f.canMutateFlag) && - ((*mutableFlags & (f.setFlag | f.clearFlag))); - })) + if (std::ranges::any_of(kMptMutabilityFlags, [mutableFlags, &isMutableFlag](auto const& f) { + return !isMutableFlag(f.canMutateFlag) && + ((*mutableFlags & (f.setFlag | f.clearFlag))); + })) return tecNO_PERMISSION; // Clearing lsfMPTRequireAuth is invalid when the issuance already has @@ -273,7 +268,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,18 +287,18 @@ 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; } if (auto const mutableFlags = ctx_.tx[~sfMutableFlags].value_or(0)) { - for (auto const& f : kMPT_MUTABILITY_FLAGS) + for (auto const& f : kMptMutabilityFlags) { if ((mutableFlags & f.setFlag) != 0u) { @@ -362,7 +356,7 @@ MPTokenIssuanceSet::doApply() sle->getType() == ltMPTOKEN_ISSUANCE, "MPTokenIssuanceSet::doApply : modifying MPTokenIssuance"); - if (*domainID != beast::kZERO) + if (*domainID != beast::kZero) { sle->setFieldH256(sfDomainID, *domainID); } @@ -384,6 +378,7 @@ MPTokenIssuanceSet::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -394,6 +389,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..a8ea786347 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; } @@ -108,7 +106,7 @@ TrustSet::preflight(PreflightContext const& ctx) return temBAD_CURRENCY; } - if (saLimitAmount < beast::kZERO) + if (saLimitAmount < beast::kZero) { JLOG(j.trace()) << "Malformed transaction: Negative credit limit."; return temBAD_LIMIT; @@ -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 @@ -258,7 +252,7 @@ TrustSet::preclaim(PreclaimContext const& ctx) else if (auto const ammSle = ctx.view.read({ltAMM, sleDst->getFieldH256(sfAMMID)})) { auto const lpTokens = ammSle->getFieldAmount(sfLPTokenBalance); - if (lpTokens == beast::kZERO) + if (lpTokens == beast::kZero) { return tecAMM_EMPTY; } @@ -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 @@ -342,9 +336,9 @@ TrustSet::doApply() AccountID const uDstAccountID(saLimitAmount.getIssuer()); // true, if current is high account. - bool const bHigh = account_ > uDstAccountID; + bool const bHigh = accountID_ > uDstAccountID; - auto const sle = view().peek(keylet::account(account_)); + auto const sle = view().peek(keylet::account(accountID_)); if (!sle) return tefINTERNAL; // LCOV_EXCL_LINE @@ -369,7 +363,7 @@ TrustSet::doApply() // could use the extra XRP for their own purposes. XRPAmount const reserveCreate( - (uOwnerCount < 2) ? XRPAmount(beast::kZERO) + (uOwnerCount < 2) ? XRPAmount(beast::kZero) : view().fees().accountReserve(uOwnerCount + 1)); std::uint32_t const uQualityIn(bQualityIn ? ctx_.tx.getFieldU32(sfQualityIn) : 0); @@ -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"); @@ -399,10 +391,10 @@ TrustSet::doApply() } STAmount saLimitAllow = saLimitAmount; - saLimitAllow.get().account = account_; + saLimitAllow.get().account = accountID_; SLE::pointer const sleRippleState = - view().peek(keylet::line(account_, uDstAccountID, currency)); + view().peek(keylet::line(accountID_, uDstAccountID, currency)); if (sleRippleState) { @@ -414,8 +406,8 @@ TrustSet::doApply() std::uint32_t uLowQualityOut = 0; std::uint32_t uHighQualityIn = 0; std::uint32_t uHighQualityOut = 0; - auto const& uLowAccountID = !bHigh ? account_ : uDstAccountID; - auto const& uHighAccountID = bHigh ? account_ : uDstAccountID; + auto const& uLowAccountID = !bHigh ? accountID_ : uDstAccountID; + auto const& uHighAccountID = bHigh ? accountID_ : uDstAccountID; SLE::ref sleLowAccount = !bHigh ? sle : sleDst; SLE::ref sleHighAccount = bHigh ? sle : sleDst; @@ -506,7 +498,7 @@ TrustSet::doApply() if (bSetNoRipple && !bClearNoRipple) { - if ((bHigh ? saHighBalance : saLowBalance) >= beast::kZERO) + if ((bHigh ? saHighBalance : saLowBalance) >= beast::kZero) { uFlagsOut |= (bHigh ? lsfHighNoRipple : lsfLowNoRipple); } @@ -538,23 +530,23 @@ 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 || - ((uFlagsOut & lsfLowFreeze) != 0u) || saLowLimit || saLowBalance > beast::kZERO; + ((uFlagsOut & lsfLowFreeze) != 0u) || saLowLimit || saLowBalance > beast::kZero; bool const bLowReserveClear = !bLowReserveSet; bool const bHighReserveSet = (uHighQualityIn != 0u) || (uHighQualityOut != 0u) || ((uFlagsOut & lsfHighNoRipple) == 0) != bHighDefRipple || - ((uFlagsOut & lsfHighFreeze) != 0u) || saHighLimit || saHighBalance > beast::kZERO; + ((uFlagsOut & lsfHighFreeze) != 0u) || saHighLimit || saHighBalance > beast::kZero; bool const bHighReserveClear = !bHighReserveSet; 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; @@ -650,7 +642,7 @@ TrustSet::doApply() // Zero balance in currency. STAmount const saBalance(Issue{currency, noAccount()}); - auto const k = keylet::line(account_, uDstAccountID, currency); + auto const k = keylet::line(accountID_, uDstAccountID, currency); JLOG(j_.trace()) << "doTrustSet: Creating ripple line: " << to_string(k.key); @@ -658,7 +650,7 @@ TrustSet::doApply() terResult = trustCreate( view(), bHigh, - account_, + accountID_, uDstAccountID, k.key, sle, @@ -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..b5b2c1f384 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 @@ -36,7 +35,7 @@ namespace xrpl { NotTEC VaultClawback::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfVaultID] == beast::kZERO) + if (ctx.tx[sfVaultID] == beast::kZero) { JLOG(ctx.j.debug()) << "VaultClawback: zero/empty vault ID."; return temMALFORMED; @@ -46,7 +45,7 @@ VaultClawback::preflight(PreflightContext const& ctx) if (amount) { // Note, zero amount is valid, it means "all". It is also the default. - if (*amount < beast::kZERO) + if (*amount < beast::kZero) { return temBAD_AMOUNT; } @@ -134,7 +133,7 @@ VaultClawback::preclaim(PreclaimContext const& ctx) } // If amount is non-zero, the VaultOwner must burn all shares - if (amount != beast::kZERO) + if (amount != beast::kZero) { Number const& sharesHeld = accountHolds( ctx.view, @@ -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_); @@ -263,7 +259,7 @@ VaultClawback::assetsToClawback( try { - if (clawbackAmount == beast::kZERO) + if (clawbackAmount == beast::kZero) { sharesDestroyed = accountHolds( view(), holder, share, FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, j_); @@ -353,7 +349,7 @@ VaultClawback::doApply() MPTIssue const share{mptIssuanceID}; Asset const vaultAsset = vault->at(sfAsset); - STAmount const amount = clawbackAmount(vault, tx[~sfAmount], account_); + STAmount const amount = clawbackAmount(vault, tx[~sfAmount], accountID_); auto assetsAvailable = vault->at(sfAssetsAvailable); auto assetsTotal = vault->at(sfAssetsTotal); @@ -368,7 +364,7 @@ VaultClawback::doApply() STAmount assetsRecovered = {vault->at(sfAsset)}; // The Owner is burning shares - if (account_ == vault->at(sfOwner) && amount.asset() == share) + if (accountID_ == vault->at(sfOwner) && amount.asset() == share) { sharesDestroyed = accountHolds( view(), holder, share, FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, j_); @@ -385,7 +381,7 @@ VaultClawback::doApply() sharesDestroyed = clawbackParts->second; } - if (sharesDestroyed == beast::kZERO) + if (sharesDestroyed == beast::kZero) return tecPRECISION_LOSS; assetsTotal -= assetsRecovered; @@ -426,11 +422,11 @@ VaultClawback::doApply() // else quietly ignore, holder balance is not zero } - if (assetsRecovered > beast::kZERO) + if (assetsRecovered > beast::kZero) { // Transfer assets from vault to issuer. if (auto const ter = accountSend( - view(), vaultAccount, account_, assetsRecovered, j_, WaiveTransferFee::Yes); + view(), vaultAccount, accountID_, assetsRecovered, j_, WaiveTransferFee::Yes); !isTesSuccess(ter)) return ter; @@ -441,7 +437,7 @@ VaultClawback::doApply() assetsRecovered.asset(), FreezeHandling::IgnoreFreeze, AuthHandling::IgnoreAuth, - j_) < beast::kZERO) + j_) < beast::kZero) { // LCOV_EXCL_START JLOG(j_.error()) << "VaultClawback: negative balance of vault assets."; @@ -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..7490f44619 100644 --- a/src/libxrpl/tx/transactors/vault/VaultCreate.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultCreate.cpp @@ -1,12 +1,14 @@ #include #include +#include #include #include #include #include #include #include +#include #include #include #include @@ -52,23 +54,23 @@ VaultCreate::getFlagsMask(PreflightContext const& ctx) NotTEC VaultCreate::preflight(PreflightContext const& ctx) { - if (!validDataLength(ctx.tx[~sfData], kMAX_DATA_PAYLOAD_LENGTH)) + if (!validDataLength(ctx.tx[~sfData], kMaxDataPayloadLength)) return temMALFORMED; if (auto const withdrawalPolicy = ctx.tx[~sfWithdrawalPolicy]) { // Enforce valid withdrawal policy - if (*withdrawalPolicy != kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE) + if (*withdrawalPolicy != kVaultStrategyFirstComeFirstServe) return temMALFORMED; } if (auto const domain = ctx.tx[~sfDomainID]) { - if (*domain == beast::kZERO) + if (*domain == beast::kZero) { return temMALFORMED; } - if ((ctx.tx.getFlags() & tfVaultPrivate) == 0) + if (!ctx.tx.isFlag(tfVaultPrivate)) { return temMALFORMED; // DomainID only allowed on private vaults } @@ -76,13 +78,13 @@ VaultCreate::preflight(PreflightContext const& ctx) if (auto const assetMax = ctx.tx[~sfAssetsMaximum]) { - if (*assetMax < beast::kZERO) + if (*assetMax < beast::kZero) return temMALFORMED; } if (auto const metadata = ctx.tx[~sfMPTokenMetadata]) { - if (metadata->empty() || metadata->length() > kMAX_MP_TOKEN_METADATA_LENGTH) + if (metadata->empty() || metadata->length() > kMaxMpTokenMetadataLength) return temMALFORMED; } @@ -92,7 +94,7 @@ VaultCreate::preflight(PreflightContext const& ctx) if (vaultAsset.holds() || vaultAsset.native()) return temMALFORMED; - if (scale > kVAULT_MAXIMUM_IOU_SCALE) + if (scale > kVaultMaximumIouScale) return temMALFORMED; } @@ -130,7 +132,7 @@ VaultCreate::preclaim(PreclaimContext const& ctx) auto const sequence = ctx.tx.getSeqValue(); if (auto const accountId = pseudoAccountAddress(ctx.view, keylet::vault(account, sequence).key); - accountId == beast::kZERO) + accountId == beast::kZero) return terADDRESS_COLLISION; return tesSUCCESS; @@ -145,13 +147,13 @@ VaultCreate::doApply() auto const& tx = ctx_.tx; auto const sequence = tx.getSeqValue(); - auto const owner = view().peek(keylet::account(account_)); + auto const owner = view().peek(keylet::account(accountID_)); if (owner == nullptr) return tefINTERNAL; // LCOV_EXCL_LINE - auto vault = std::make_shared(keylet::vault(account_, sequence)); + auto vault = std::make_shared(keylet::vault(accountID_, sequence)); - if (auto ter = dirLink(view(), account_, vault)) + if (auto ter = dirLink(view(), accountID_, vault)) return ter; // We will create Vault and PseudoAccount, hence increase OwnerCount by 2 adjustOwnerCount(view(), owner, 2, j_); @@ -162,34 +164,44 @@ VaultCreate::doApply() auto maybePseudo = createPseudoAccount(view(), vault->key(), sfVaultID); if (!maybePseudo) return maybePseudo.error(); // LCOV_EXCL_LINE - auto& pseudo = *maybePseudo; - auto pseudoId = pseudo->at(sfAccount); - auto asset = tx[sfAsset]; + auto const& pseudo = *maybePseudo; + AccountID const pseudoId = pseudo->at(sfAccount); + auto const asset = tx[sfAsset]; if (auto ter = addEmptyHolding(view(), pseudoId, preFeeBalance_, asset, j_); !isTesSuccess(ter)) return ter; std::uint8_t const scale = (asset.holds() || asset.native()) ? 0 - : ctx_.tx[~sfScale].value_or(kVAULT_DEFAULT_IOU_SCALE); + : ctx_.tx[~sfScale].value_or(kVaultDefaultIouScale); - 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 // the vault. That MPToken or TrustLine/RippleState is created above, in // addEmptyHolding. Here we are creating MPTokenIssuance for the shares - // in the vault - auto maybeShare = MPTokenIssuanceCreate::create( + // in the vault. + // + // Post-fixCleanup3_2_0: surface the vault pseudo's holding (MPToken + // for MPT, RippleState for IOU) on the share via sfReferenceHolding. + // XRP underlyings leave it unset. + auto const referenceHolding = [&]() -> std::optional { + if (!view().rules().enabled(fixCleanup3_2_0) || asset.native()) + return std::nullopt; + return asset.holds() + ? keylet::mptoken(asset.get().getMptID(), pseudoId).key + : keylet::line(pseudoId, asset.get()).key; + }(); + auto const maybeShare = MPTokenIssuanceCreate::create( view(), j_, { .priorBalance = std::nullopt, - .account = pseudoId->value(), + .account = pseudoId, .sequence = 1, .flags = mptFlags, .assetScale = scale, @@ -197,15 +209,16 @@ VaultCreate::doApply() .metadata = tx[~sfMPTokenMetadata], .domainId = tx[~sfDomainID], .mutableFlags = std::nullopt, + .referenceHolding = referenceHolding, }); if (!maybeShare) return maybeShare.error(); // LCOV_EXCL_LINE 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(sfOwner) = accountID_; vault->at(sfAccount) = pseudoId; vault->at(sfAssetsTotal) = Number(0); vault->at(sfAssetsAvailable) = Number(0); @@ -223,7 +236,7 @@ VaultCreate::doApply() } else { - vault->at(sfWithdrawalPolicy) = kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE; + vault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe; } if (scale != 0u) vault->at(sfScale) = scale; @@ -231,15 +244,15 @@ VaultCreate::doApply() // Explicitly create MPToken for the vault owner if (auto const err = - authorizeMPToken(view(), preFeeBalance_, mptIssuanceID, account_, ctx_.journal); + authorizeMPToken(view(), preFeeBalance_, mptIssuanceID, accountID_, ctx_.journal); !isTesSuccess(err)) 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_); + view(), preFeeBalance_, mptIssuanceID, pseudoId, ctx_.journal, {}, accountID_); !isTesSuccess(err)) return err; } @@ -255,11 +268,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..438896e7ed 100644 --- a/src/libxrpl/tx/transactors/vault/VaultDelete.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultDelete.cpp @@ -24,7 +24,7 @@ namespace xrpl { NotTEC VaultDelete::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfVaultID] == beast::kZERO) + if (ctx.tx[sfVaultID] == beast::kZero) { JLOG(ctx.j.debug()) << "VaultDelete: zero/empty vault ID."; return temMALFORMED; @@ -122,16 +122,16 @@ VaultDelete::doApply() } // Try to remove MPToken for vault shares for the vault owner if it exists. - if (auto const mptoken = view().peek(keylet::mptoken(shareMPTID, account_))) + if (auto const mptoken = view().peek(keylet::mptoken(shareMPTID, accountID_))) { - if (auto const ter = removeEmptyHolding(view(), account_, MPTIssue(shareMPTID), j_); + if (auto const ter = removeEmptyHolding(view(), accountID_, MPTIssue(shareMPTID), j_); !isTesSuccess(ter)) { // LCOV_EXCL_START JLOG(j_.error()) // << "VaultDelete: failed to remove vault owner's MPToken" - << " MPTID=" << to_string(shareMPTID) // - << " account=" << toBase58(account_) // + << " MPTID=" << to_string(shareMPTID) // + << " account=" << toBase58(accountID_) // << " with result: " << transToken(ter); return ter; // LCOV_EXCL_STOP @@ -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..aaaf3cced8 100644 --- a/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -28,13 +29,13 @@ namespace xrpl { NotTEC VaultDeposit::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfVaultID] == beast::kZERO) + if (ctx.tx[sfVaultID] == beast::kZero) { JLOG(ctx.j.debug()) << "VaultDeposit: zero/empty vault ID."; return temMALFORMED; } - if (ctx.tx[sfAmount] <= beast::kZERO) + if (ctx.tx[sfAmount] <= beast::kZero) return temBAD_AMOUNT; return tesSUCCESS; @@ -156,20 +157,20 @@ VaultDeposit::doApply() auto const& vaultAccount = vault->at(sfAccount); // Note, vault owner is always authorized - if (vault->isFlag(lsfVaultPrivate) && account_ != vault->at(sfOwner)) + if (vault->isFlag(lsfVaultPrivate) && accountID_ != vault->at(sfOwner)) { if (auto const err = enforceMPTokenAuthorization( - ctx_.view(), mptIssuanceID, account_, preFeeBalance_, j_); + ctx_.view(), mptIssuanceID, accountID_, preFeeBalance_, j_); !isTesSuccess(err)) return err; } - else // !vault->isFlag(lsfVaultPrivate) || account_ == vault->at(sfOwner) + else // !vault->isFlag(lsfVaultPrivate) || accountID_ == vault->at(sfOwner) { // No authorization needed, but must ensure there is MPToken - if (!view().exists(keylet::mptoken(mptIssuanceID, account_))) + if (!view().exists(keylet::mptoken(mptIssuanceID, accountID_))) { if (auto const err = authorizeMPToken( - view(), preFeeBalance_, mptIssuanceID->value(), account_, ctx_.journal); + view(), preFeeBalance_, mptIssuanceID->value(), accountID_, ctx_.journal); !isTesSuccess(err)) return err; } @@ -179,15 +180,15 @@ VaultDeposit::doApply() { // This follows from the reverse of the outer enclosing if condition XRPL_ASSERT( - account_ == vault->at(sfOwner), "xrpl::VaultDeposit::doApply : account is owner"); + accountID_ == vault->at(sfOwner), "xrpl::VaultDeposit::doApply : account is owner"); if (auto const err = authorizeMPToken( view(), preFeeBalance_, // priorBalance mptIssuanceID->value(), // mptIssuanceID sleIssuance->at(sfIssuer), // account ctx_.journal, - {}, // flags - account_ // holderID + {}, // flags + accountID_ // holderID ); !isTesSuccess(err)) return err; @@ -204,7 +205,7 @@ VaultDeposit::doApply() return tecINTERNAL; // LCOV_EXCL_LINE sharesCreated = *maybeShares; } - if (sharesCreated == beast::kZERO) + if (sharesCreated == beast::kZero) return tecPRECISION_LOSS; auto const maybeAssets = sharesToAssetsDeposit(vault, sleIssuance, sharesCreated); @@ -247,29 +248,36 @@ VaultDeposit::doApply() return tecLIMIT_EXCEEDED; // Transfer assets from depositor to vault. - if (auto const ter = - accountSend(view(), account_, vaultAccount, assetsDeposited, j_, WaiveTransferFee::Yes); + if (auto const ter = accountSend( + view(), accountID_, vaultAccount, assetsDeposited, j_, WaiveTransferFee::Yes); !isTesSuccess(ter)) return ter; - // Sanity check - if (accountHolds( - view(), - account_, - assetsDeposited.asset(), - FreezeHandling::IgnoreFreeze, - AuthHandling::IgnoreAuth, - j_) < beast::kZERO) + // This check is wrong. Disable it with fixCleanup3_2_0. + // For XRP and MPT the predicate is structurally unsatisfiable: xrpLiquid clamps at zero, and + // MPT balances are unsigned. For IOUs it only fires when the deposit drove the depositor's + // trust line into debt the exact case preclaim authorizes via SpendableHandling::FullBalance. + // The check thus converts a preclaim- authorized deposit into tefINTERNAL after the asset + // transfer. + if (!view().rules().enabled(fixCleanup3_2_0)) { - // LCOV_EXCL_START - JLOG(j_.error()) << "VaultDeposit: negative balance of account assets."; - return tefINTERNAL; - // LCOV_EXCL_STOP + // Sanity check + if (accountHolds( + view(), + accountID_, + assetsDeposited.asset(), + FreezeHandling::IgnoreFreeze, + AuthHandling::IgnoreAuth, + j_) < beast::kZero) + { + JLOG(j_.error()) << "VaultDeposit: negative balance of account assets."; + return tefINTERNAL; + } } // Transfer shares from vault to depositor. if (auto const ter = - accountSend(view(), vaultAccount, account_, sharesCreated, j_, WaiveTransferFee::Yes); + accountSend(view(), vaultAccount, accountID_, sharesCreated, j_, WaiveTransferFee::Yes); !isTesSuccess(ter)) return ter; @@ -284,6 +292,7 @@ VaultDeposit::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -294,6 +303,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..f384fd3fb1 100644 --- a/src/libxrpl/tx/transactors/vault/VaultSet.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultSet.cpp @@ -28,7 +28,7 @@ VaultSet::checkExtraFeatures(PreflightContext const& ctx) NotTEC VaultSet::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfVaultID] == beast::kZERO) + if (ctx.tx[sfVaultID] == beast::kZero) { JLOG(ctx.j.debug()) << "VaultSet: zero/empty vault ID."; return temMALFORMED; @@ -36,7 +36,7 @@ VaultSet::preflight(PreflightContext const& ctx) if (auto const data = ctx.tx[~sfData]) { - if (data->empty() || data->length() > kMAX_DATA_PAYLOAD_LENGTH) + if (data->empty() || data->length() > kMaxDataPayloadLength) { JLOG(ctx.j.debug()) << "VaultSet: invalid data payload size."; return temMALFORMED; @@ -45,7 +45,7 @@ VaultSet::preflight(PreflightContext const& ctx) if (auto const assetMax = ctx.tx[~sfAssetsMaximum]) { - if (*assetMax < beast::kZERO) + if (*assetMax < beast::kZero) { JLOG(ctx.j.debug()) << "VaultSet: invalid max assets."; return temMALFORMED; @@ -95,7 +95,7 @@ VaultSet::preclaim(PreclaimContext const& ctx) return tecNO_PERMISSION; } - if (*domain != beast::kZERO) + if (*domain != beast::kZero) { auto const sleDomain = ctx.view.read(keylet::permissionedDomain(*domain)); if (!sleDomain) @@ -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."; @@ -153,7 +153,7 @@ VaultSet::doApply() if (auto const domainId = tx[~sfDomainID]; domainId) { - if (*domainId != beast::kZERO) + if (*domainId != beast::kZero) { // In VaultSet::preclaim we enforce that lsfVaultPrivate must have // been set in the vault. We currently do not support making such a @@ -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..ced82f6735 100644 --- a/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp +++ b/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp @@ -29,18 +29,18 @@ namespace xrpl { NotTEC VaultWithdraw::preflight(PreflightContext const& ctx) { - if (ctx.tx[sfVaultID] == beast::kZERO) + if (ctx.tx[sfVaultID] == beast::kZero) { JLOG(ctx.j.debug()) << "VaultWithdraw: zero/empty vault ID."; return temMALFORMED; } - if (ctx.tx[sfAmount] <= beast::kZERO) + if (ctx.tx[sfAmount] <= beast::kZero) return temBAD_AMOUNT; if (auto const destination = ctx.tx[~sfDestination]) { - if (*destination == beast::kZERO) + if (*destination == beast::kZero) { return temMALFORMED; } @@ -65,14 +65,21 @@ VaultWithdraw::preclaim(PreclaimContext const& ctx) auto const& vaultAccount = vault->at(sfAccount); auto const& account = ctx.tx[sfAccount]; auto const& dstAcct = ctx.tx[~sfDestination].value_or(account); - if (auto ter = canTransfer(ctx.view, vaultAsset, vaultAccount, dstAcct); !isTesSuccess(ter)) + // Post-fixCleanup3_2_0: withdraw is a recovery path that bypasses the + // lsfMPTCanTransfer flag check, so an issuer cannot trap depositor funds. + // Other transferability checks (IOU NoRipple, freeze, requireAuth) still + // apply. + auto const waive = ctx.view.rules().enabled(fixCleanup3_2_0) ? WaiveMPTCanTransfer::Yes + : WaiveMPTCanTransfer::No; + if (auto ter = canTransfer(ctx.view, vaultAsset, vaultAccount, dstAcct, waive); + !isTesSuccess(ter)) { JLOG(ctx.j.debug()) << "VaultWithdraw: vault assets are non-transferable."; return ter; } // Enforce valid withdrawal policy - if (vault->at(sfWithdrawalPolicy) != kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE) + if (vault->at(sfWithdrawalPolicy) != kVaultStrategyFirstComeFirstServe) { // LCOV_EXCL_START JLOG(ctx.j.error()) << "VaultWithdraw: invalid withdrawal policy."; @@ -80,9 +87,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. @@ -187,7 +194,7 @@ VaultWithdraw::doApply() sharesRedeemed = *maybeShares; } - if (sharesRedeemed == beast::kZERO) + if (sharesRedeemed == beast::kZero) return tecPRECISION_LOSS; auto const maybeAssets = sharesToAssetsWithdraw(vault, sleIssuance, sharesRedeemed); if (!maybeAssets) @@ -222,7 +229,7 @@ VaultWithdraw::doApply() } if (accountHolds( - view(), account_, share, FreezeHandling::ZeroIfFrozen, AuthHandling::IgnoreAuth, j_) < + view(), accountID_, share, FreezeHandling::ZeroIfFrozen, AuthHandling::IgnoreAuth, j_) < sharesRedeemed) { JLOG(j_.debug()) << "VaultWithdraw: account doesn't hold enough shares"; @@ -251,23 +258,23 @@ VaultWithdraw::doApply() auto const& vaultAccount = vault->at(sfAccount); // Transfer shares from depositor to vault. - if (auto const ter = - accountSend(view(), account_, vaultAccount, sharesRedeemed, j_, WaiveTransferFee::Yes); + if (auto const ter = accountSend( + view(), accountID_, vaultAccount, sharesRedeemed, j_, WaiveTransferFee::Yes); !isTesSuccess(ter)) return ter; // Try to remove MPToken for shares, if the account balance is zero. Vault // pseudo-account will never set lsfMPTAuthorized, so we ignore flags. // Keep MPToken if holder is the vault owner. - if (account_ != vault->at(sfOwner)) + if (accountID_ != vault->at(sfOwner)) { - if (auto const ter = removeEmptyHolding(view(), account_, sharesRedeemed.asset(), j_); + if (auto const ter = removeEmptyHolding(view(), accountID_, sharesRedeemed.asset(), j_); isTesSuccess(ter)) { JLOG(j_.debug()) // << "VaultWithdraw: removed empty MPToken for vault shares" << " MPTID=" << to_string(mptIssuanceID) // - << " account=" << toBase58(account_); + << " account=" << toBase58(accountID_); } else if (ter != tecHAS_OBLIGATIONS) { @@ -275,7 +282,7 @@ VaultWithdraw::doApply() JLOG(j_.error()) // << "VaultWithdraw: failed to remove MPToken for vault shares" << " MPTID=" << to_string(mptIssuanceID) // - << " account=" << toBase58(account_) // + << " account=" << toBase58(accountID_) // << " with result: " << transToken(ter); return ter; // LCOV_EXCL_STOP @@ -283,12 +290,12 @@ VaultWithdraw::doApply() // else quietly ignore, account balance is not zero } - auto const dstAcct = ctx_.tx[~sfDestination].value_or(account_); + auto const dstAcct = ctx_.tx[~sfDestination].value_or(accountID_); associateAsset(*vault, vaultAsset); return doWithdraw( - view(), ctx_.tx, account_, dstAcct, vaultAccount, preFeeBalance_, assetsWithdrawn, j_); + view(), ctx_.tx, accountID_, dstAcct, vaultAccount, preFeeBalance_, assetsWithdrawn, j_); } void @@ -297,6 +304,7 @@ VaultWithdraw::visitInvariantEntry( std::shared_ptr const&, std::shared_ptr const&) { + // No transaction-specific invariants yet (future work). } bool @@ -307,6 +315,7 @@ VaultWithdraw::finalizeInvariants( ReadView const&, beast::Journal const&) { + // No transaction-specific invariants yet (future work). return true; } diff --git a/src/test/app/AMMClawbackMPT_test.cpp b/src/test/app/AMMClawbackMPT_test.cpp index 6f0fff0282..6facafde4a 100644 --- a/src/test/app/AMMClawbackMPT_test.cpp +++ b/src/test/app/AMMClawbackMPT_test.cpp @@ -52,7 +52,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); auto const usd = gw["USD"]; env.trust(usd(10000), alice); @@ -167,7 +167,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw2, .holders = {alice}, .pay = 40'000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM const amm(env, alice, btc(100), usd(100)); env.close(); @@ -197,7 +197,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM const amm(env, alice, btc(100), XRP(100)); env.close(); @@ -225,7 +225,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 10'000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM const amm(env, alice, XRP(1'000), btc(1'000)); @@ -272,7 +272,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw2, .holders = {alice}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM const amm(env, alice, btc(1000000000), usd(2000)); env.close(); @@ -334,7 +334,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(1000000000), XRP(2000)); env.close(); @@ -431,14 +431,14 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); MPT const eth = MPTTester( {.env = env, .issuer = gw2, .holders = {alice, bob}, .pay = 30'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(2'000'000000), eth(3'000'000000)); env.close(); @@ -535,7 +535,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw2, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(2000000000), usd(2000)); env.close(); @@ -589,7 +589,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(5000), XRP(10'000)); env.close(); @@ -646,14 +646,14 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); MPT const eth = MPTTester( {.env = env, .issuer = gw2, .holders = {alice, bob}, .pay = 30'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(20'000), eth(50'000)); env.close(); @@ -722,7 +722,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(1'000'000000), usd(2000)); env.close(); @@ -811,14 +811,14 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); MPT const eth = MPTTester( {.env = env, .issuer = gw, .holders = {alice, bob}, .pay = 30'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(2'000'000000), eth(3'000'000000)); env.close(); @@ -914,7 +914,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(2'000'000000), usd(8'000)); env.close(); @@ -969,14 +969,14 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); MPT const eth = MPTTester( {.env = env, .issuer = gw, .holders = {alice, bob}, .pay = 30'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, btc(20'000), eth(10'000)); env.close(); @@ -1048,7 +1048,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw2, .holders = {alice, gw}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, gw, usd(1000), btc(2000)); env.close(); @@ -1134,14 +1134,14 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {gw2, alice}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); MPT const eth = MPTTester( {.env = env, .issuer = gw2, .holders = {gw, alice}, .pay = 30'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, gw, btc(10'000), eth(50'000)); env.close(); @@ -1217,7 +1217,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 30'000, - .flags = tfMPTCanClawback | tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice, usd(10'000), btc(10'000)); BEAST_EXPECT(ammAlice.expectBalances(usd(10'000), btc(10'000), IOUAmount(10'000))); env.close(); @@ -1288,7 +1288,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 30'000, - .flags = tfMPTCanClawback | tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice, usd(10'000), btc(10'000)); BEAST_EXPECT(ammAlice.expectBalances(usd(10'000), btc(10'000), IOUAmount(10'000))); env.close(); @@ -1354,7 +1354,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); // gw creates AMM pool of BTC/XRP. AMM amm(env, gw, XRP(100), btc(400), Ter(tesSUCCESS)); @@ -1400,7 +1400,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); // gw creates AMM pool of BTC/USD. AMM amm(env, gw, usd(100), btc(400), Ter(tesSUCCESS)); @@ -1448,14 +1448,14 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); MPT const btc = MPTTester( {.env = env, .issuer = gw, .holders = {alice}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); // gw creates AMM pool of BTC/USD. AMM amm(env, gw, usd(100), btc(400), Ter(tesSUCCESS)); @@ -1517,7 +1517,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, usd(2), eur(1)); amm.deposit(alice, IOUAmount{1'576123487565916, -15}); @@ -1580,14 +1580,14 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); MPT const eur = MPTTester( {.env = env, .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, alice, usd(2), eur(1)); amm.deposit(alice, IOUAmount{1'576123487565916, -15}); @@ -1697,7 +1697,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); // Asset USD is not clawable without asfAllowTrustLineClawback. AMM const amm(env, alice, usd(200), btc(100)); @@ -1737,7 +1737,7 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite .issuer = gw2, .holders = {alice}, .pay = 40'000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); AMM const amm(env, alice, usd(200), btc(100)); diff --git a/src/test/app/AMMExtendedMPT_test.cpp b/src/test/app/AMMExtendedMPT_test.cpp index 6de39b73ec..e6dcc95733 100644 --- a/src/test/app/AMMExtendedMPT_test.cpp +++ b/src/test/app/AMMExtendedMPT_test.cpp @@ -85,14 +85,14 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 200'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const btc( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 2'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // Must be two offers at the same quality // "taker gets" must be XRP @@ -240,7 +240,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 100'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(150'000), btc(50'000'000)); @@ -272,7 +272,7 @@ private: env.close(); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(500'000'000))); AMM const ammAlice(env, alice_, XRP(150'000), btc(51'000'000)); @@ -297,7 +297,7 @@ private: env.require(Owners(bob_, 0)); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(1'000'000'000))); env.require(Owners(alice_, 1), Owners(bob_, 1)); @@ -330,7 +330,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 30'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(10'000'000'000))); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000'000'000)); @@ -368,7 +368,7 @@ private: env.fund(XRP(1'000), bob_); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(10'100'000'000))); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000'000)); @@ -392,7 +392,7 @@ private: env.fund(XRP(1'000), bob_); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(40'000'000'000))); AMM const ammAlice(env, alice_, XRP(10'100), btc(10'000'000'000)); @@ -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), @@ -470,11 +470,11 @@ private: env.close(); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags}); // Created only to increase one reserve count for alice MPTTester const eth( - {.env = env, .issuer = gw_, .holders = {alice_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_}, .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(1'200'000'000'000'000))); @@ -508,7 +508,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .transferFee = 500, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(1'000'000'000'000))); env(pay(gw_, alice_, btc(200'000'000'000'000))); @@ -539,7 +539,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(10'100))); AMM const ammAlice(env, alice_, XRP(9'900), btc(10'100)); @@ -569,7 +569,7 @@ private: env.close(); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(2'200'000'000))); AMM const ammBob(env, bob_, XRP(1'000), btc(2'200'000'000)); @@ -602,13 +602,13 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const xxx( {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice(env, alice_, xts(1'000'000'000'000'000), xxx(1'000'000'000'000'000)); @@ -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"); @@ -649,13 +649,13 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 15'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 15'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // The scenario: // o BTC/XRP AMM is created. @@ -688,13 +688,13 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 15'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 15'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // The scenario: // o BTC/XRP AMM is created. @@ -729,13 +729,13 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 15'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 15'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // The scenario: // o BTC/XRP offer is created. @@ -779,7 +779,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 20'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(20'000), btc(200'000'000)); // alice submits a tfSell | tfFillOrKill offer that does not cross. env(offer(alice_, btc(2'100'000), XRP(210), tfSell | tfFillOrKill), Ter(tecKILLED)); @@ -796,7 +796,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(20'000), btc(200'000'000'000'000)); // alice submits a tfSell | tfFillOrKill offer that crosses. // Even though tfSell is present it doesn't matter this time. @@ -818,7 +818,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(20'000), btc(200'000'000'000'000)); env(offer(alice_, btc(10'000'000'000'000), XRP(1'500), tfSell | tfFillOrKill)); @@ -843,7 +843,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 10'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(5000), btc(10'000'000)); env(offer(alice_, btc(1'000'000), XRP(501), tfSell | tfFillOrKill), Ter(tecKILLED)); @@ -872,7 +872,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 30'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(10'100'000))); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000)); @@ -898,7 +898,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 30'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(10'000'000))); AMM const ammAlice(env, alice_, XRP(10'100), btc(10'000'000)); @@ -924,14 +924,14 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 15'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 15'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // The scenario: // o BTC/XRP AMM is created. @@ -969,14 +969,14 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 15'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 15'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // The scenario: // o BTC/XRP AMM is created. @@ -1022,7 +1022,7 @@ private: env.close(); MPTTester const btc( - {.env = env, .issuer = bob_, .holders = {alice_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = bob_, .holders = {alice_}, .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(10'000), btc(10'100)); @@ -1058,10 +1058,10 @@ private: env.close(); MPTTester const aBux( - {.env = env, .issuer = ann, .holders = {bob, cam, carol}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = ann, .holders = {bob, cam, carol}, .flags = kMptDexFlags}); MPTTester const bBux( - {.env = env, .issuer = bob, .holders = {ann, cam, carol}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = bob, .holders = {ann, cam, carol}, .flags = kMptDexFlags}); env(pay(ann, cam, aBux(350'000'000'000'000))); env(pay(bob, cam, bBux(350'000'000'000'000))); @@ -1103,7 +1103,7 @@ private: {.env = env, .issuer = gw_, .holders = {alice_, bob_}, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS}); + .flags = tfMPTRequireAuth | kMptDexFlags}); // Authorize bob and alice btc.authorize({.holder = alice_}); @@ -1145,7 +1145,7 @@ private: {.env = env, .issuer = gw_, .holders = {alice_, bob_}, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS}); + .flags = tfMPTRequireAuth | kMptDexFlags}); // Alice doesn't have the funds { @@ -1225,7 +1225,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 100'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammCarol(env, carol_, XRP(100), eth(100'000'000'000'000)); @@ -1262,14 +1262,14 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .transferFee = 10'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const btc( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .transferFee = 10'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, carol_, eth(51))); env.close(); @@ -1300,7 +1300,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, charlie}, .pay = 11'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammCharlie(env, charlie, XRP(10), eth(11'000'000'000'000)); auto [st, sa, da] = findPaths(env, alice_, bob_, eth(-1), XRP(1).value()); @@ -1324,7 +1324,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, charlie}, .pay = 11'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammCharlie(env, charlie, XRP(11), eth(10'000'000'000'000)); env.close(); @@ -1363,16 +1363,16 @@ private: env.close(); MPTTester const xyzG1( - {.env = env, .issuer = g1, .holders = {a1, m1, a2}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = g1, .holders = {a1, m1, a2}, .flags = kMptDexFlags}); MPTTester const xyzG2( - {.env = env, .issuer = g2, .holders = {a2, m1, a1}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = g2, .holders = {a2, m1, a1}, .flags = kMptDexFlags}); MPTTester const abcG3( - {.env = env, .issuer = g3, .holders = {a1, a2, m1, a3}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = g3, .holders = {a1, a2, m1, a3}, .flags = kMptDexFlags}); MPTTester const abcA2( - {.env = env, .issuer = a2, .holders = {g3, a1}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = a2, .holders = {g3, a1}, .flags = kMptDexFlags}); env(pay(g1, a1, xyzG1(3'500'000'000))); env(pay(g3, a1, abcG3(1'200'000'000))); @@ -1444,7 +1444,7 @@ private: .issuer = g3, .holders = {a1, a2, m1}, .pay = 1'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammM1(env, m1, eth(1'000'000'000), XRP(10'010)); @@ -1483,14 +1483,14 @@ private: .issuer = g1, .holders = {a1, m1}, .pay = 5'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const hkdG2( {.env = env, .issuer = g2, .holders = {a2, m1}, .pay = 5'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammM1(env, m1, hkdG1(1'000'000'000), hkdG2(1'010'000'000)); @@ -1522,16 +1522,10 @@ private: env.close(); MPTTester const eth( - {.env = env, - .issuer = gw_, - .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .flags = kMptDexFlags}); MPTTester const btc( - {.env = env, - .issuer = gw_, - .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .flags = kMptDexFlags}); env(pay(gw_, alice_, eth(50'000))); env(pay(gw_, bob_, btc(150'000))); @@ -1610,14 +1604,14 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 100'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 150'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBobBtcXrp(env, bob_, btc(100'000), XRP(150)); AMM const ammBobXrpEth(env, bob_, XRP(100), eth(150'000)); @@ -1644,7 +1638,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 150'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(100), eth(150'000)); @@ -1667,7 +1661,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 100'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, eth(100'000), XRP(150)); @@ -1759,19 +1753,19 @@ private: {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester gbp( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(60'000'000))); env(pay(gw_, bob_, btc(100'000'000))); @@ -1918,7 +1912,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const btc( {.env = env, @@ -1926,7 +1920,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm(env, bob_, gbp(1'000'000'000'000'000), btc(1'000'000'000'000'000)); @@ -1960,7 +1954,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const btc( {.env = env, @@ -1968,7 +1962,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, @@ -1976,7 +1970,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(ed, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)), Txflags(tfPassive)); @@ -2021,7 +2015,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const btc( {.env = env, @@ -2029,7 +2023,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, @@ -2037,7 +2031,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm1(env, bob_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)); AMM const amm2(env, ed, eth(1'000'000'000'000'000), btc(1'000'000'000'000'000)); @@ -2076,7 +2070,7 @@ private: .holders = {alice_, bob_}, .transferFee = 25'000, .pay = 1'100'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, @@ -2084,7 +2078,7 @@ private: .holders = {alice_, bob_}, .transferFee = 25'000, .pay = 1'100'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm(env, bob_, btc(1'000'000), eth(1'100'000)); env(offer(alice_, eth(100'000), btc(100'000))); @@ -2109,7 +2103,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const gbp( {.env = env, @@ -2117,7 +2111,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm(env, bob_, gbp(1'000'000'000'000'000), btc(1'000'000'000'000'000)); @@ -2153,7 +2147,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'200'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const gbp( {.env = env, @@ -2161,7 +2155,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'200'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm(env, bob_, gbp(1'000'000'000'000'000), btc(1'200'000'000'000'000)); @@ -2199,7 +2193,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const gbp( {.env = env, @@ -2207,7 +2201,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, @@ -2215,7 +2209,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(ed, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)), Txflags(tfPassive)); @@ -2265,7 +2259,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const gbp( {.env = env, @@ -2273,7 +2267,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, @@ -2281,7 +2275,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm(env, bob_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)); @@ -2332,7 +2326,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const gbp( {.env = env, @@ -2340,7 +2334,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, @@ -2348,7 +2342,7 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm1(env, bob_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)); AMM const amm2(env, ed, eth(1'000'000'000'000'000), btc(1'400'000'000'000'000)); @@ -2391,7 +2385,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const gbp( {.env = env, @@ -2399,7 +2393,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, @@ -2407,7 +2401,7 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 1'400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm1(env, alice_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)); AMM const amm2(env, bob_, eth(1'000'000'000'000'000), btc(1'400'000'000'000'000)); @@ -2453,7 +2447,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 2'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(1'000), eth(1'050'000)); env(offer(bob_, XRP(100), eth(50'000))); @@ -2611,7 +2605,7 @@ private: env.fund(XRP(100'000'000), gw_, alice_, bob_, carol_, dan, ed); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMptDexFlags}); env(pay(gw_, ed, btc(11'000'000'000'000))); env(pay(gw_, bob_, btc(1'000'000'000'000))); @@ -2635,7 +2629,7 @@ private: // Carol offers to buy 1000 XRP for 1000e12 BTC. She removes Bob's // next 1000 offers as unfunded and hits the step limit. env(offer(carol_, btc(1'000'000'000'000'000), XRP(1'000))); - env.require(Balance(carol_, MPT(btc)(kNONE))); + env.require(Balance(carol_, MPT(btc)(kNone))); env.require(Owners(carol_, 1)); env.require(Balance(bob_, btc(0))); env.require(Owners(bob_, 1)); @@ -2657,7 +2651,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_, dan, ed}, .pay = 10000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env.trust(BTC(11'000'000'000'000), ed); env(pay(gw_, ed, BTC(11'000'000'000'000))); @@ -2702,7 +2696,7 @@ private: env.close(); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMptDexFlags}); env(pay(gw_, ed, btc(11'000'000'000'000))); env(pay(gw_, bob_, btc(1'000'000'000'000))); @@ -2732,13 +2726,13 @@ private: env.close(); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMptDexFlags}); MPTTester const usd( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_, dan, ed}, .pay = 10000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, ed, btc(11'000'000'000'000))); env(pay(gw_, bob_, btc(1'000'000'000'000))); @@ -2774,7 +2768,7 @@ private: {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(alice_, bob_, btc(10'000)), DeliverMin(btc(10'000)), Ter(temBAD_AMOUNT)); env(pay(alice_, bob_, btc(10'000)), @@ -2811,7 +2805,7 @@ private: fund(env, gw_, {alice_, bob_}, XRP(10'000)); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(1'100'000))); AMM const ammBob(env, bob_, XRP(1'000), btc(1'100'000)); @@ -2863,7 +2857,7 @@ private: fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000)); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {bob_, carol_}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {bob_, carol_}, .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(1'200'000))); AMM const ammBob(env, bob_, XRP(5'500), btc(1'200'000)); @@ -2932,10 +2926,7 @@ private: fund(env, gw_, {alice_, bob_, carol_, dan}, XRP(10'000)); MPTTester const btc( - {.env = env, - .issuer = gw_, - .holders = {bob_, carol_, dan}, - .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {bob_, carol_, dan}, .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(100'000'000))); env(pay(gw_, dan, btc(1'100'000'000))); @@ -2967,7 +2958,7 @@ private: fund(env, gw_, {alice_, becky}, XRP(5'000)); MPTTester const btc( - {.env = env, .issuer = gw_, .holders = {alice_, becky}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, becky}, .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(500'000))); env.close(); @@ -3005,10 +2996,7 @@ private: fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000)); MPTTester btc( - {.env = env, - .issuer = gw_, - .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .flags = kMptDexFlags}); env(pay(gw_, alice_, btc(150'000))); env(pay(gw_, carol_, btc(150'000))); @@ -3103,7 +3091,7 @@ private: {.env = env, .issuer = g1, .holders = {alice, bob}, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); env(pay(g1, bob, btc(10))); env(pay(g1, alice, btc(205))); @@ -3126,10 +3114,8 @@ private: btc.set({.holder = bob, .flags = tfMPTLock}); { - // different from IOU. The offer is created but not crossed. - env(offer(bob, btc(5), XRP(25))); + env(offer(bob, btc(5), XRP(25)), Ter(tecLOCKED)); env.close(); - BEAST_EXPECT(expectOffers(env, bob, 1, {{{btc(5), XRP(25)}}})); BEAST_EXPECT(ammAlice.expectBalances(XRP(500), btc(105), ammAlice.tokens())); } @@ -3179,13 +3165,13 @@ private: {.env = env, .issuer = g1, .holders = {a1, a2, a3, a4}, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); MPTTester btc( {.env = env, .issuer = g1, .holders = {a1, a2, a3, a4}, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); env(pay(g1, a1, eth(1'000))); env(pay(g1, a2, eth(100))); @@ -3232,7 +3218,7 @@ private: btc.set({.flags = tfMPTLock}); // assets can't be bought on the market - AMM const ammA3(env, a3, btc(1), XRP(1), Ter(tecFROZEN)); + AMM const ammA3(env, a3, btc(1), XRP(1), Ter(tecLOCKED)); // direct issues can be sent env(pay(g1, a2, btc(1))); @@ -3274,7 +3260,7 @@ private: {.env = env, .issuer = g1, .holders = {a2, a3, a4}, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); env(pay(g1, a3, btc(2'000))); env(pay(g1, a4, btc(2'001))); @@ -3340,7 +3326,7 @@ private: .issuer = gw_, .holders = {alice, becky, zelda}, .pay = 20'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // alice uses a regular key with the master disabled. Account const alie{"alie", KeyType::Secp256k1}; @@ -3350,8 +3336,8 @@ private: // Attach signers to alice. env(signers(alice, 2, {{becky, 1}, {bogie, 1}}), Sig(alie)); env.close(); - int constexpr kSIGNER_LIST_OWNERS{2}; - env.require(Owners(alice, kSIGNER_LIST_OWNERS + 0)); + static constexpr int kSignerListOwners{2}; + env.require(Owners(alice, kSignerListOwners + 0)); Msig const ms{becky, bogie}; @@ -3446,14 +3432,14 @@ private: .issuer = bob_, .holders = {alice_, gw_}, .pay = 100'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester eth( {.env = env, .issuer = bob_, .holders = {alice_, gw_}, .pay = 100'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammXrpBtc(env, bob_, XRP(100), btc(100'000)); env(offer(gw_, XRP(100), btc(100'000)), Txflags(tfPassive)); @@ -3487,7 +3473,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 100'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(100), btc(100)); @@ -3508,7 +3494,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 100'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammBob(env, bob_, XRP(100), btc(100)); @@ -3536,7 +3522,7 @@ private: {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(pay(gw_, bob_, btc(100'000'000))); env(pay(gw_, alice_, btc(100'000'000))); diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp index 8132c012ad..18f2d6df2f 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"); @@ -1119,14 +1120,14 @@ private: env(pay(ann, cam, dBux(60)), Path(localBob, dan), Sendmax(aBux(200))); env.close(); - BEAST_EXPECT(expectHolding(env, ann, aBux(kNONE))); - BEAST_EXPECT(expectHolding(env, ann, dBux(kNONE))); + BEAST_EXPECT(expectHolding(env, ann, aBux(kNone))); + BEAST_EXPECT(expectHolding(env, ann, dBux(kNone))); BEAST_EXPECT(expectHolding(env, localBob, aBux(72))); BEAST_EXPECT(expectHolding(env, localBob, dBux(40))); - BEAST_EXPECT(expectHolding(env, cam, aBux(kNONE))); + BEAST_EXPECT(expectHolding(env, cam, aBux(kNone))); BEAST_EXPECT(expectHolding(env, cam, dBux(60))); - BEAST_EXPECT(expectHolding(env, dan, aBux(kNONE))); - BEAST_EXPECT(expectHolding(env, dan, dBux(kNONE))); + BEAST_EXPECT(expectHolding(env, dan, aBux(kNone))); + BEAST_EXPECT(expectHolding(env, dan, dBux(kNone))); AMM const ammBob(env, localBob, aBux(30), dBux(30)); @@ -1138,12 +1139,12 @@ private: env.close(); BEAST_EXPECT(ammBob.expectBalances(aBux(30), dBux(30), ammBob.tokens())); - BEAST_EXPECT(expectHolding(env, ann, aBux(kNONE))); + BEAST_EXPECT(expectHolding(env, ann, aBux(kNone))); BEAST_EXPECT(expectHolding(env, ann, dBux(0))); - BEAST_EXPECT(expectHolding(env, cam, aBux(kNONE))); + BEAST_EXPECT(expectHolding(env, cam, aBux(kNone))); BEAST_EXPECT(expectHolding(env, cam, dBux(60))); BEAST_EXPECT(expectHolding(env, dan, aBux(0))); - BEAST_EXPECT(expectHolding(env, dan, dBux(kNONE))); + BEAST_EXPECT(expectHolding(env, dan, dBux(kNone))); } } @@ -2713,7 +2714,7 @@ private: // Carol offers to buy 1000 XRP for 1000 USD. She removes Bob's next // 1000 offers as unfunded and hits the step limit. env(offer(carol_, USD(1'000), XRP(1'000))); - env.require(Balance(carol_, USD(kNONE))); + env.require(Balance(carol_, USD(kNone))); env.require(Owners(carol_, 1)); env.require(Balance(bob_, USD(0))); env.require(Owners(bob_, 1)); @@ -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 4318a19503..31b54ceee0 100644 --- a/src/test/app/AMMMPT_test.cpp +++ b/src/test/app/AMMMPT_test.cpp @@ -128,7 +128,7 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | kMptDexFlags, .authHolder = true}); AMM const ammAlice(env, alice_, USD(10'000), btc(10'000)); } @@ -142,9 +142,9 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); usd.set({.flags = tfMPTLock}); - AMM const ammAliceFail(env, alice_, XRP(10'000), usd(10'000), Ter(tecFROZEN)); + AMM const ammAliceFail(env, alice_, XRP(10'000), usd(10'000), Ter(tecLOCKED)); usd.set({.flags = tfMPTUnlock}); AMM const ammAlice(env, alice_, XRP(10'000), usd(10'000)); } @@ -346,9 +346,9 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); btc.set({.flags = tfMPTLock}); - AMM const ammAlice(env, alice_, USD(10'000), btc(10'000), Ter(tecFROZEN)); + AMM const ammAlice(env, alice_, USD(10'000), btc(10'000), Ter(tecLOCKED)); BEAST_EXPECT(!ammAlice.ammExists()); } @@ -361,11 +361,11 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); btc.set({.holder = alice_, .flags = tfMPTLock}); // alice's token is locked - AMM const ammAlice(env, alice_, USD(10'000), btc(10'000), Ter(tecFROZEN)); + AMM const ammAlice(env, alice_, USD(10'000), btc(10'000), Ter(tecLOCKED)); BEAST_EXPECT(!ammAlice.ammExists()); // bob can create @@ -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)); } @@ -495,7 +496,7 @@ private: {.env = env, .issuer = gw_, .holders = {alice_, carol_}, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS, + .flags = tfMPTCanLock | kMptDexFlags, .authHolder = true}); // Depositing mismatched token, invalid Asset1In.issue @@ -686,21 +687,21 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM ammAlice(env, alice_, USD(10'000), btc(10'000)); btc.set({.flags = tfMPTLock}); ammAlice.deposit( - carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); ammAlice.deposit( - carol_, USD(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, USD(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); - ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); ammAlice.deposit( - carol_, USD(100), btc(100), std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, USD(100), btc(100), std::nullopt, std::nullopt, Ter(tecLOCKED)); } // Individually lock MPT or freeze IOU (AMM) with IOU/MPT AMM @@ -712,7 +713,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM ammAlice(env, alice_, USD(10'000), btc(10'000)); @@ -721,20 +722,19 @@ private: // Carol can not deposit locked mpt ammAlice.deposit( - carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); - ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); if (!features[featureAMMClawback]) { - ammAlice.deposit( - carol_, USD(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); + ammAlice.deposit(carol_, USD(100), std::nullopt, std::nullopt, std::nullopt); } else { - // Carol can not deposit non-forzen token either + // Carol can not deposit non-frozen token either ammAlice.deposit( - carol_, USD(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, USD(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); } // Alice can deposit because she's not individually locked @@ -777,9 +777,9 @@ private: ammAlice.deposit(carol_, USD(100), std::nullopt, std::nullopt, std::nullopt); // Can not deposit locked token - ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); ammAlice.deposit( - carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); // Unlock AMM MPT btc.set({.holder = ammAlice.ammAccount(), .flags = tfMPTUnlock}); @@ -798,23 +798,23 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); MPTTester usd( {.env = env, .issuer = gw_, .holders = {alice_, carol_}, .pay = 40'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM ammAlice(env, alice_, usd(10'000), btc(10'000)); // Carol's BTC is locked btc.set({.holder = carol_, .flags = tfMPTLock}); ammAlice.deposit( - carol_, usd(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, usd(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); ammAlice.deposit( - carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); // Unlock carol's BTC btc.set({.holder = carol_, .flags = tfMPTUnlock}); @@ -830,9 +830,9 @@ private: ammAlice.deposit(carol_, usd(100), std::nullopt, std::nullopt, std::nullopt); // Can not deposit locked token BTC - ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); ammAlice.deposit( - carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, btc(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); // Unlock AMM MPT BTC btc.set({.holder = ammAlice.ammAccount(), .flags = tfMPTUnlock}); @@ -847,9 +847,9 @@ private: ammAlice.deposit(carol_, btc(100), std::nullopt, std::nullopt, std::nullopt); // Can not deposit locked token USD - ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.deposit(carol_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); ammAlice.deposit( - carol_, usd(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecFROZEN)); + carol_, usd(100), std::nullopt, std::nullopt, std::nullopt, Ter(tecLOCKED)); // Unlock AMM MPT USD usd.set({.holder = ammAlice.ammAccount(), .flags = tfMPTUnlock}); @@ -870,7 +870,7 @@ private: {.maxAmt = 1'000'000, .authorize = {{alice}}, .pay = {{{alice}, 10'000}}, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | kMptDexFlags, .authHolder = true}); AMM amm(env, alice, XRP(10'000), btc(10'000)); @@ -903,7 +903,7 @@ private: AMM amm(env, gw, XRP(10'000), btc(10'000)); - amm.deposit({.account = alice, .asset1In = btc(10), .err = Ter(tecNO_PERMISSION)}); + amm.deposit({.account = alice, .asset1In = btc(10), .err = Ter(tecNO_AUTH)}); } // Insufficient XRP balance @@ -2035,7 +2035,7 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | kMptDexFlags, .authHolder = true}); AMM ammAlice(env, alice_, XRP(10'000), btc(10'000)); WithdrawArg const args{ @@ -2053,7 +2053,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 2'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); // Invalid tokens ammAlice.withdraw(alice_, 0, std::nullopt, std::nullopt, Ter(temBAD_AMM_TOKENS)); @@ -2224,7 +2224,7 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | kMptDexFlags, .authHolder = true}); MPT const btc = btcm; @@ -2245,23 +2245,22 @@ private: Env env{*this}; env.fund(XRP(30'000), gw_, alice_); env.close(); - auto btcm = MPTTester( + auto btc = MPTTester( {.env = env, .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanTrade, + .flags = kMptDexFlags, + .mutableFlags = tmfMPTCanMutateCanTransfer, .authHolder = true}); - MPT const btc = btcm; AMM amm(env, gw_, XRP(10'000), btc(10'000)); + amm.deposit(DepositArg{.account = alice_, .asset1In = XRP(200), .asset2In = btc(200)}); + // Allow to withdraw if transfer is disabled + btc.set({.mutableFlags = tmfMPTClearCanTransfer}); amm.withdraw( - WithdrawArg{ - .account = alice_, - .asset1Out = btc(100), - .assets = {{XRP, btc}}, - .err = Ter(tecNO_PERMISSION)}); + WithdrawArg{.account = alice_, .asset1Out = btc(100), .assets = {{XRP, btc}}}); } // Globally locked MPT @@ -2275,15 +2274,15 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS, + .flags = tfMPTCanLock | kMptDexFlags, .authHolder = true}); AMM ammAlice(env, alice_, XRP(10'000), btc(10'000)); btc.set({.flags = tfMPTLock}); ammAlice.withdraw( - alice_, MPT(ammAlice[1])(100), std::nullopt, std::nullopt, Ter(tecFROZEN)); - ammAlice.withdraw(alice_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); + alice_, MPT(ammAlice[1])(100), std::nullopt, std::nullopt, Ter(tecLOCKED)); + ammAlice.withdraw(alice_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); // can single withdraw the other asset ammAlice.withdraw({.account = alice_, .asset1Out = XRP(100)}); @@ -2299,20 +2298,20 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); MPTTester const usd( {.env = env, .issuer = gw_, .holders = {alice_}, .pay = 40'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM ammAlice(env, alice_, usd(10'000), btc(10'000)); // Alice's BTC is locked btc.set({.holder = alice_, .flags = tfMPTLock}); - ammAlice.withdraw(alice_, 1000, std::nullopt, std::nullopt, Ter(tecFROZEN)); - ammAlice.withdraw(alice_, btc(100), std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.withdraw(alice_, 1000, std::nullopt, std::nullopt, Ter(tecLOCKED)); + ammAlice.withdraw(alice_, btc(100), std::nullopt, std::nullopt, Ter(tecLOCKED)); // can withdraw the other asset ammAlice.withdraw(alice_, usd(100), std::nullopt, std::nullopt); @@ -2333,15 +2332,15 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM ammAlice(env, alice_, USD(10'000), btc(10'000)); // Alice's BTC is locked btc.set({.holder = alice_, .flags = tfMPTLock}); - ammAlice.withdraw(alice_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); - ammAlice.withdraw(alice_, btc(100), std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.withdraw(alice_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); + ammAlice.withdraw(alice_, btc(100), std::nullopt, std::nullopt, Ter(tecLOCKED)); // can still single withdraw the unlocked other asset ammAlice.withdraw(alice_, USD(100), std::nullopt, std::nullopt); @@ -2360,8 +2359,8 @@ private: ammAlice.withdraw(alice_, USD(100), std::nullopt, std::nullopt); // Can not withdraw locked token BTC - ammAlice.withdraw(alice_, 1'000, std::nullopt, std::nullopt, Ter(tecFROZEN)); - ammAlice.withdraw(alice_, btc(100), std::nullopt, std::nullopt, Ter(tecFROZEN)); + ammAlice.withdraw(alice_, 1'000, std::nullopt, std::nullopt, Ter(tecLOCKED)); + ammAlice.withdraw(alice_, btc(100), std::nullopt, std::nullopt, Ter(tecLOCKED)); // Unlock AMM MPT btc.set({.holder = ammAlice.ammAccount(), .flags = tfMPTUnlock}); @@ -3476,7 +3475,7 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 2'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM amm(env, gw_, XRP(1'000), btc(1'000), false, 1'000); // auction slot is owned by the creator of the AMM i.e. gw @@ -3501,7 +3500,7 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 2'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM amm(env, gw_, XRP(1'000), btc(1'000), false, 1'000); // auction slot is owned by the creator of the AMM i.e. gw @@ -3609,7 +3608,7 @@ private: .issuer = gw_, .holders = {alice_, carol_, bob_}, .pay = 30'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM ammAlice(env, alice_, btc(10'000'000'000), USD(10'000)); ammAlice.deposit(carol_, 1'000'000); @@ -3645,7 +3644,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 1'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM amm(env, gw_, XRP(10), btc(1'000)); auto const lpIssue = amm.lptIssue(); env.trust(STAmount{lpIssue, 100}, alice_); @@ -3710,7 +3709,7 @@ private: .issuer = gw_, .holders = {alice_, carol_, bob_}, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM ammAlice(env, alice_, XRP(10'000), btc(10'000)); ammAlice.deposit(carol_, 1'000'000); @@ -3755,7 +3754,7 @@ private: .issuer = gw_, .holders = {alice_, carol_, bob_}, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM ammAlice(env, alice_, XRP(10'000), btc(10'000)); ammAlice.deposit(carol_, 1'000'000); @@ -3769,18 +3768,17 @@ private: // 1st Interval after close, price for 0th interval. env(ammAlice.bid({.account = bob_})); - env.close(seconds(kAUCTION_SLOT_INTERVAL_DURATION + 1)); + env.close(seconds(kAuctionSlotIntervalDuration + 1)); BEAST_EXPECT(ammAlice.expectAuctionSlot(0, 1, IOUAmount{1'155, -1})); // 10th Interval after close, price for 1st interval. env(ammAlice.bid({.account = carol_})); - env.close(seconds((10 * kAUCTION_SLOT_INTERVAL_DURATION) + 1)); + env.close(seconds((10 * kAuctionSlotIntervalDuration) + 1)); BEAST_EXPECT(ammAlice.expectAuctionSlot(0, 10, IOUAmount{121'275, -3})); // 20th Interval (expired) after close, price for 10th interval. env(ammAlice.bid({.account = bob_})); - env.close( - seconds((kAUCTION_SLOT_TIME_INTERVALS * kAUCTION_SLOT_INTERVAL_DURATION) + 1)); + env.close(seconds((kAuctionSlotTimeIntervals * kAuctionSlotIntervalDuration) + 1)); BEAST_EXPECT(ammAlice.expectAuctionSlot(0, std::nullopt, IOUAmount{127'33875, -5})); // 0 Interval. @@ -3883,7 +3881,7 @@ private: btc(13'000'000'671), STAmount{USD, UINT64_C(13'114'03663044931), -11}, ammTokens)); // Auction slot expired, no discounted fee - env.close(seconds(kTOTAL_TIME_SLOT_SECS + 1)); + env.close(seconds(kTotalTimeSlotSecs + 1)); // clock is parent's based env.close(); @@ -3916,7 +3914,7 @@ private: testAMM( [&](AMM& ammAlice, Env& env) { // Bid a tiny amount - auto const tiny = Number{STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET}; + auto const tiny = Number{STAmount::kMinValue, STAmount::kMinOffset}; env(ammAlice.bid({.account = alice_, .bidMin = IOUAmount{tiny}})); // Auction slot purchase price is equal to the tiny amount // since the minSlotPrice is 0 with no trading fee. @@ -3927,7 +3925,7 @@ private: // Bid the tiny amount env(ammAlice.bid({ .account = alice_, - .bidMin = IOUAmount{STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET}, + .bidMin = IOUAmount{STAmount::kMinValue, STAmount::kMinOffset}, })); // Pay slightly higher price BEAST_EXPECT(ammAlice.expectAuctionSlot(0, 0, IOUAmount{tiny * Number{105, -2}})); @@ -3970,7 +3968,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 2'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); fund(env, gw_, {alice_, bob_}, {USD(2'000)}, Fund::TokenOnly); AMM amm(env, gw_, btc(1'000'000'000), USD(1'010), false, 1'000); auto const lpIssue = amm.lptIssue(); @@ -4006,7 +4004,7 @@ private: .issuer = gw_, .holders = {alice_, bob_}, .pay = 2'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM amm(env, gw_, XRP(1'000), btc(1'010), false, 1'000); json::Value const tx = amm.bid({.account = alice_, .bidMin = 500}); @@ -4067,7 +4065,7 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); // to clawback from AMM account, must use AMMClawback instead of // Clawback @@ -4102,7 +4100,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 100, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // XRP balance is below reserve AMM const ammAlice(env, acct, XRP(10), btc(10)); // Pay below reserve @@ -4121,7 +4119,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 20'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); // XRP balance is above reserve AMM const ammAlice(env, acct, XRP(1'000'000), btc(10'000)); // Pay below reserve @@ -4137,16 +4135,16 @@ private: testAMM( [&](AMM& ammAlice, Env& env) { env(escrow::create(carol_, ammAlice.ammAccount(), MPT(ammAlice[1])(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(1'500), Ter(tecNO_PERMISSION)); env(escrow::create(carol_, ammAlice.ammAccount(), XRP(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(1'500), Ter(tecNO_PERMISSION)); }, @@ -4231,7 +4229,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000)); btc.set({.flags = tfMPTLock}); @@ -4257,7 +4255,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000)); btc.set({.holder = carol_, .flags = tfMPTLock}); @@ -4278,7 +4276,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000)); btc.set({.holder = alice_, .flags = tfMPTLock}); @@ -4299,13 +4297,13 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); MPTTester eth( {.env = env, .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice_, eth(10'000), btc(10'000)); btc.set({.holder = carol_, .flags = tfMPTLock}); @@ -4335,7 +4333,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000)); btc.set({.holder = ammAlice.ammAccount(), .flags = tfMPTLock}); @@ -4634,7 +4632,7 @@ private: .holders = {alice_, carol_}, .transferFee = 10'000, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); auto ammAlice = AMM(env, alice_, XRP(10'000), btc(10'010'000'000'000'000)); env.close(); auto carolMPT = env.balance(carol_, MPT(btc)); @@ -4762,13 +4760,13 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 3'000'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, carol_}, .pay = 3'000'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env.fund(XRP(1'000), bob_); env.close(); auto ammEthXrp = AMM(env, alice_, XRP(10'000), eth(1'000'000'000'000'000'000)); @@ -4812,13 +4810,13 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 3'000'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_}, .pay = 1'000'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); auto ammAlice = AMM(env, alice_, XRP(10'000), btc(1'000'000'000'000'000'000)); env.fund(XRP(1'000), bob_); env.close(); @@ -4860,7 +4858,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM ammAlice(env, alice_, XRP(10'000), btc(10'100'000'000'000'000)); env(offer(bob_, XRP(100), MPT(ammAlice[1])(100'000'000'000'000)), Txflags(tfPassive)); env.close(); @@ -4895,7 +4893,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 2'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(bob_, XRP(50), btc(150)), Txflags(tfPassive)); env.close(); AMM const ammAlice(env, alice_, XRP(1'000), btc(1'050)); @@ -4914,7 +4912,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM ammAlice(env, alice_, XRP(10'000), btc(10'100)); env(offer(bob_, MPT(ammAlice[1])(100), XRP(100))); env.close(); @@ -4940,14 +4938,14 @@ private: .holders = {alice_, carol_}, .transferFee = 25'000, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, carol_}, .transferFee = 25'000, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice(env, alice_, btc(1'000'000'000'000'000), eth(1'100'000'000'000'000)); // This offer succeeds to cross pre- and post-amendment // because the strand's out amount is small enough to match @@ -4976,7 +4974,7 @@ private: .holders = {alice_, carol_}, .transferFee = 100, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm(env, alice_, XRP(1'000), btc(500'000'000'000'000)); env(offer(carol_, XRP(100), btc(55'000'000'000'000))); env.close(); @@ -4999,7 +4997,7 @@ private: .holders = {alice_, carol_}, .transferFee = 100, .pay = 3'000'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const amm(env, alice_, XRP(1'000), btc(50'000'000'000'000'000)); env(offer(carol_, XRP(10), btc(5'500'000'000'000'000))); env.close(); @@ -5019,14 +5017,14 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 20'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_, ed}, .transferFee = 25'000, .pay = 20'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice( env, alice_, btc(10'000'000'000'000'000), eth(11'000'000'000'000'000)); @@ -5066,14 +5064,14 @@ private: .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .transferFee = 25'000, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice(env, alice_, btc(1'000), eth(1'100)); env(rate(gw_, 1.25)); env.close(); @@ -5109,28 +5107,28 @@ private: .holders = {alice_, bob_, carol_, dan, ed}, .transferFee = 25'000, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_, dan, ed}, .transferFee = 25'000, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const can( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_, dan, ed}, .transferFee = 25'000, .pay = 2'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const gbp( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_, dan, ed}, .transferFee = 25'000, .pay = 3'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice(env, alice_, gbp(1'000'000), eth(10'125)); env(pay(gw_, bob_, can(1'953'125))); env.close(); @@ -5189,25 +5187,25 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 500'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 500'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const usd( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 500'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eur( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 500'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const xrpEur(env, alice_, XRP(10'100), eur(100'000'000'000'000'000)); AMM const eurBtc( env, alice_, eur(100'000'000'000'000'000), btc(102'000'000'000'000'000)); @@ -5262,25 +5260,25 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 50'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 50'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const usd( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 50'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eur( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 50'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const xrpEur(env, alice_, XRP(10'100), eur(10'000'000'000'000'000)); AMM const eurBtc(env, alice_, eur(10'000'000'000'000'000), btc(10'200'000'000'000'000)); AMM const btcUsd(env, alice_, btc(10'100'000'000'000'000), usd(10'000'000'000'000'000)); @@ -5315,13 +5313,13 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000'000'000'000'000)); for (int i = 0; i < 30; ++i) @@ -5351,13 +5349,13 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 400'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000'000'000'000'000)); for (int i = 0; i < 29; ++i) @@ -5388,7 +5386,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 30'000'000'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(bob_, XRP(100), btc(100'001'000'000'000))); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000'000'000'000)); @@ -5411,7 +5409,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000)); btc.set({.holder = carol_, .flags = tfMPTLock}); @@ -5432,7 +5430,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000)); btc.set({.holder = alice_, .flags = tfMPTLock}); @@ -5603,7 +5601,7 @@ private: env.fund(XRP(10'000), lP1); env.fund(XRP(10'000), lP2); MPTTester const tst( - {.env = env, .issuer = gw, .holders = {lP1, lP2}, .flags = kMPT_DEX_FLAGS}); + {.env = env, .issuer = gw, .holders = {lP1, lP2}, .flags = kMptDexFlags}); env(offer(gw, XRP(11'500'000'000), tst(1'000'000'000'000'000))); @@ -5819,7 +5817,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_}, .pay = 30'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); auto const usd = gw_["USD"]; env.trust(usd(30'000), alice_); @@ -5942,7 +5940,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_, ed}, .pay = 30'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(carol_, btc(5'000000), USD(5))); AMM const ammAlice(env, alice_, USD(1'005), btc(1'000'000000)); @@ -5971,7 +5969,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_, ed}, .pay = 30'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(carol_, btc(5'000000), USD(5))); // Set 0.25% fee @@ -5998,7 +5996,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_, ed}, .pay = 30'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(carol_, btc(10'000000), USD(10))); // Set 1% fee @@ -6026,7 +6024,7 @@ private: .issuer = gw_, .holders = {alice_, bob_, carol_, ed}, .pay = 30'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(carol_, btc(9'000000), USD(9))); // Set 1% fee @@ -6072,7 +6070,7 @@ private: .issuer = gw, .holders = holders, .pay = 40'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); auto const usd = gw["USD"]; for (auto const& holder : holders) @@ -6163,7 +6161,7 @@ private: .issuer = gw, .holders = holders, .pay = 40'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); auto const usd = gw["USD"]; for (auto const& holder : holders) @@ -6256,7 +6254,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; @@ -6298,9 +6297,9 @@ private: struct MPTList { - MPTTester const USD; - MPTTester const ETH; - MPTTester const CAN; + MPTTester const usd; + MPTTester const eth; + MPTTester const can; }; auto prep = [&](Env& env, uint16_t gwTransferFee, uint16_t gw1TransferFee) -> MPTList { @@ -6311,34 +6310,34 @@ private: .holders = {alice_, bob_, carol_, ed}, .transferFee = gwTransferFee, .pay = 2'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester eth( {.env = env, .issuer = gw1, .holders = {alice_, bob_, carol_, ed}, .transferFee = gw1TransferFee, .pay = 2'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); MPTTester can( {.env = env, .issuer = gw1, .holders = {alice_, bob_, carol_, ed}, .transferFee = gw1TransferFee, .pay = 2'000'000'000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env.close(); return MPTList{ - .USD = std::move(usd), - .ETH = std::move(eth), - .CAN = std::move(can), + .usd = std::move(usd), + .eth = std::move(eth), + .can = std::move(can), }; }; - std::uint32_t constexpr kLOW_RATE = 10'000; - std::uint32_t constexpr kHIGH_RATE = 50'000; + static constexpr std::uint32_t kLowRate = 10'000; + static constexpr std::uint32_t kHighRate = 50'000; for (auto const& rates : - {std::make_pair(kLOW_RATE, kHIGH_RATE), std::make_pair(kHIGH_RATE, kLOW_RATE)}) + {std::make_pair(kLowRate, kHighRate), std::make_pair(kHighRate, kLowRate)}) { // Offer Selection @@ -6356,9 +6355,9 @@ private: { Env env(*this, features); auto mpts = prep(env, rates.first, rates.second); - auto usd = mpts.USD; - auto eth = mpts.ETH; - auto can = mpts.CAN; + auto usd = mpts.usd; + auto eth = mpts.eth; + auto can = mpts.can; std::optional amm; if (i == 0 || i == 2) @@ -6401,9 +6400,9 @@ private: { Env env(*this, features); auto mpts = prep(env, rates.first, rates.second); - auto usd = mpts.USD; - auto eth = mpts.ETH; - auto can = mpts.CAN; + auto usd = mpts.usd; + auto eth = mpts.eth; + auto can = mpts.can; std::optional amm; if (i == 0 || i == 2) { @@ -6446,9 +6445,9 @@ private: { Env env(*this, features); auto mpts = prep(env, rates.first, rates.second); - auto usd = mpts.USD; - auto eth = mpts.ETH; - auto can = mpts.CAN; + auto usd = mpts.usd; + auto eth = mpts.eth; + auto can = mpts.can; std::optional amm; if (i == 0 || i == 2) { @@ -6472,7 +6471,7 @@ private: if (i == 2) { - if (rates.first == kLOW_RATE) + if (rates.first == kLowRate) { BEAST_EXPECT(expectOffers( env, @@ -6512,9 +6511,9 @@ private: { Env env(*this, features); auto mpts = prep(env, rates.first, rates.second); - auto usd = mpts.USD; - auto eth = mpts.ETH; - auto can = mpts.CAN; + auto usd = mpts.usd; + auto eth = mpts.eth; + auto can = mpts.can; std::optional amm; if (i == 0 || i == 2) { @@ -6537,7 +6536,7 @@ private: // limitQuality if (i == 2) { - if (rates.first == kLOW_RATE) + if (rates.first == kLowRate) { // Ed offer is partially crossed. // The updated rounding makes limitQuality @@ -6590,9 +6589,9 @@ private: { Env env(*this, features); auto mpts = prep(env, rates.first, rates.second); - auto usd = mpts.USD; - auto eth = mpts.ETH; - auto can = mpts.CAN; + auto usd = mpts.usd; + auto eth = mpts.eth; + auto can = mpts.can; std::optional amm; if (i == 0 || i == 2) @@ -6616,7 +6615,7 @@ private: { // NOLINTBEGIN(bugprone-unchecked-optional-access) i==2 implies amm is // emplaced (i>0) - if (rates.first == kLOW_RATE) + if (rates.first == kLowRate) { // Liquidity is consumed from AMM strand only BEAST_EXPECT(amm->expectBalances( @@ -6706,7 +6705,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 2'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); WithdrawArg const args{ .asset1Out = XRP(100), .asset2Out = btc(100), @@ -6729,7 +6728,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 2'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); btc(100).value().setJson(jv[jss::EPrice]); env(jv, Ter(telENV_RPC_FAILED)); }, @@ -6754,7 +6753,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 40'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(alice_, btc(1), USD(0.01))); env.close(); @@ -6788,7 +6787,7 @@ private: .issuer = gw_, .holders = {alice_, carol_}, .pay = 40'000'000000, - .flags = kMPT_DEX_FLAGS}); + .flags = kMptDexFlags}); env(offer(alice_, btc(1), XRP(0.01))); env.close(); @@ -6838,7 +6837,7 @@ private: .issuer = gw, .holders = {alice, bob}, .pay = 40'000'000000, - .flags = tfMPTCanClawback | tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | tfMPTCanLock | kMptDexFlags}); AMM amm(env, alice, btc(2), usd(1)); amm.deposit(alice, IOUAmount{1'876123487565916, -15}); @@ -6877,7 +6876,7 @@ private: .issuer = gw_, .holders = {alice_}, .pay = 30'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); AMM amm(env, alice_, btc(100), XRP(100)); env.close(); @@ -6885,33 +6884,33 @@ private: cb(amm, btc); }; - // Deposit two assets, one of which is frozen, - // then we should get tecFROZEN error. + // Deposit two assets, one of which is locked, + // then we should get tecLOCKED error. { Env env(*this); testAMMDeposit(env, [&](AMM& amm, MPTTester& btc) { - amm.deposit(alice_, btc(100), XRP(100), std::nullopt, tfTwoAsset, Ter(tecFROZEN)); + amm.deposit(alice_, btc(100), XRP(100), std::nullopt, tfTwoAsset, Ter(tecLOCKED)); }); } - // Deposit one asset, which is the frozen token, - // then we should get tecFROZEN error. + // Deposit one asset, which is the locked token, + // then we should get tecLOCKED error. { Env env(*this); testAMMDeposit(env, [&](AMM& amm, MPTTester& btc) { amm.deposit( - alice_, btc(100), std::nullopt, std::nullopt, tfSingleAsset, Ter(tecFROZEN)); + alice_, btc(100), std::nullopt, std::nullopt, tfSingleAsset, Ter(tecLOCKED)); }); } // Deposit one asset which is not the frozen token, - // but the other asset is frozen. We should get tecFROZEN error + // but the other asset is frozen. We should get tecLOCKED error // when feature AMMClawback is enabled. { Env env(*this); testAMMDeposit(env, [&](AMM& amm, MPTTester& btc) { amm.deposit( - alice_, XRP(100), std::nullopt, std::nullopt, tfSingleAsset, Ter(tecFROZEN)); + alice_, XRP(100), std::nullopt, std::nullopt, tfSingleAsset, Ter(tecLOCKED)); }); } } @@ -6928,7 +6927,7 @@ private: Env env( *this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = XRPAmount(1); + cfg->fees.referenceFee = XRPAmount(1); return cfg; }), all); @@ -6936,7 +6935,7 @@ private: MPTTester const usd({.env = env, .issuer = gw_, .holders = {alice_}, .pay = 20'000}); MPTTester const btc({.env = env, .issuer = gw_, .holders = {alice_}, .pay = 20'000}); AMM amm(env, gw_, usd(10'000), btc(10'000)); - for (auto i = 0; i < kMAX_DELETABLE_AMM_TRUST_LINES + 10; ++i) + for (auto i = 0; i < kMaxDeletableAmmTrustLines + 10; ++i) { Account const a{std::to_string(i)}; env.fund(XRP(1'000), a); @@ -6982,7 +6981,7 @@ private: Env env( *this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = XRPAmount(1); + cfg->fees.referenceFee = XRPAmount(1); return cfg; }), all); @@ -6990,7 +6989,7 @@ private: MPTTester const usd({.env = env, .issuer = gw_, .holders = {alice_}, .pay = 20'000}); MPTTester const btc({.env = env, .issuer = gw_, .holders = {alice_}, .pay = 20'000}); AMM amm(env, gw_, usd(10'000), btc(10'000)); - for (auto i = 0; i < (kMAX_DELETABLE_AMM_TRUST_LINES * 2) + 10; ++i) + for (auto i = 0; i < (kMaxDeletableAmmTrustLines * 2) + 10; ++i) { Account const a{std::to_string(i)}; env.fund(XRP(1'000), a); @@ -7017,7 +7016,7 @@ private: Env env( *this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = XRPAmount(1); + cfg->fees.referenceFee = XRPAmount(1); return cfg; }), all); @@ -7036,12 +7035,12 @@ private: } // This test validates both invariant changes work together for - // the specific case of MPT/MPT pools with > maxDeletableAMMTrustLines. + // the specific case of MPT/MPT pools with > kMaxDeletableAmmTrustLines. { Env env( *this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = XRPAmount(1); + cfg->fees.referenceFee = XRPAmount(1); return cfg; }), all); @@ -7054,7 +7053,7 @@ private: // MPT/MPT pool with MANY trustlines AMM amm(env, gw_, usd(10'000), btc(10'000)); - for (auto i = 0; i < (kMAX_DELETABLE_AMM_TRUST_LINES * 2) + 10; ++i) + for (auto i = 0; i < (kMaxDeletableAmmTrustLines * 2) + 10; ++i) { Account const a{std::to_string(i)}; env.fund(XRP(1'000), a); diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp index abb20e6009..4819f8265a 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)); } @@ -2730,18 +2731,17 @@ private: // 1st Interval after close, price for 0th interval. env(ammAlice.bid({.account = bob_})); - env.close(seconds(kAUCTION_SLOT_INTERVAL_DURATION + 1)); + env.close(seconds(kAuctionSlotIntervalDuration + 1)); BEAST_EXPECT(ammAlice.expectAuctionSlot(0, 1, IOUAmount{1'155, -1})); // 10th Interval after close, price for 1st interval. env(ammAlice.bid({.account = carol_})); - env.close(seconds((10 * kAUCTION_SLOT_INTERVAL_DURATION) + 1)); + env.close(seconds((10 * kAuctionSlotIntervalDuration) + 1)); BEAST_EXPECT(ammAlice.expectAuctionSlot(0, 10, IOUAmount{121'275, -3})); // 20th Interval (expired) after close, price for 10th interval. env(ammAlice.bid({.account = bob_})); - env.close( - seconds((kAUCTION_SLOT_TIME_INTERVALS * kAUCTION_SLOT_INTERVAL_DURATION) + 1)); + env.close(seconds((kAuctionSlotTimeIntervals * kAuctionSlotIntervalDuration) + 1)); BEAST_EXPECT(ammAlice.expectAuctionSlot(0, std::nullopt, IOUAmount{127'33875, -5})); // 0 Interval. @@ -2968,7 +2968,7 @@ private: ammTokens)); } // Auction slot expired, no discounted fee - env.close(seconds(kTOTAL_TIME_SLOT_SECS + 1)); + env.close(seconds(kTotalTimeSlotSecs + 1)); // clock is parent's based env.close(); if (!features[fixAMMv1_1]) @@ -3057,7 +3057,7 @@ private: testAMM( [&](AMM& ammAlice, Env& env) { // Bid a tiny amount - auto const tiny = Number{STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET}; + auto const tiny = Number{STAmount::kMinValue, STAmount::kMinOffset}; env(ammAlice.bid({.account = alice_, .bidMin = IOUAmount{tiny}})); // Auction slot purchase price is equal to the tiny amount // since the minSlotPrice is 0 with no trading fee. @@ -3067,7 +3067,7 @@ private: // Bid the tiny amount env(ammAlice.bid({ .account = alice_, - .bidMin = IOUAmount{STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET}, + .bidMin = IOUAmount{STAmount::kMinValue, STAmount::kMinOffset}, })); // Pay slightly higher price BEAST_EXPECT(ammAlice.expectAuctionSlot(0, 0, IOUAmount{tiny * Number{105, -2}})); @@ -3225,9 +3225,9 @@ private: testAMM([&](AMM& ammAlice, Env& env) { auto const baseFee = env.current()->fees().base; env(escrow::create(carol_, ammAlice.ammAccount(), XRP(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); }); @@ -5090,13 +5090,13 @@ private: Env env( *this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = XRPAmount(1); + cfg->fees.referenceFee = XRPAmount(1); return cfg; }), all); fund(env, gw_, {alice_}, XRP(20'000), {USD(10'000)}); AMM amm(env, gw_, XRP(10'000), USD(10'000)); - for (auto i = 0; i < kMAX_DELETABLE_AMM_TRUST_LINES + 10; ++i) + for (auto i = 0; i < kMaxDeletableAmmTrustLines + 10; ++i) { Account const a{std::to_string(i)}; env.fund(XRP(1'000), a); @@ -5148,13 +5148,13 @@ private: Env env( *this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = XRPAmount(1); + cfg->fees.referenceFee = XRPAmount(1); return cfg; }), all); fund(env, gw_, {alice_}, XRP(20'000), {USD(10'000)}); AMM amm(env, gw_, XRP(10'000), USD(10'000)); - for (auto i = 0; i < (kMAX_DELETABLE_AMM_TRUST_LINES * 2) + 10; ++i) + for (auto i = 0; i < (kMaxDeletableAmmTrustLines * 2) + 10; ++i) { Account const a{std::to_string(i)}; env.fund(XRP(1'000), a); @@ -5212,7 +5212,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; @@ -6723,9 +6724,9 @@ private: AccountID const accountId = xrpl::pseudoAccountAddress(*env.current(), keylet.key); env(pay(env.master.id(), accountId, XRP(1000)), - Seq(kAUTOFILL), - Fee(kAUTOFILL), - Sig(kAUTOFILL)); + Seq(kAutofill), + Fee(kAutofill), + Sig(kAutofill)); } AMM const ammAlice( @@ -7077,6 +7078,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.referenceFee = 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 < kMaxDeletableAmmTrustLines + 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) == kVoteWeightScaleFactor); + } + // 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 { @@ -7147,6 +7237,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..951f99919b 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()); @@ -214,7 +215,7 @@ public: BEAST_EXPECT(env.closed()->exists(keylet::ownerDir(carol.id()))); BEAST_EXPECT(env.closed()->exists(keylet::depositPreauth(carol.id(), becky.id()))); BEAST_EXPECT(env.closed()->exists(keylet::offer(carol.id(), carolOfferSeq))); - BEAST_EXPECT(env.closed()->exists(keylet::kTICKET(carol.id(), carolTicketSeq))); + BEAST_EXPECT(env.closed()->exists(keylet::kTicket(carol.id(), carolTicketSeq))); BEAST_EXPECT(env.closed()->exists(keylet::signers(carol.id()))); // Delete carol's account even with stuff in her directory. Show @@ -228,7 +229,7 @@ public: BEAST_EXPECT(!env.closed()->exists(keylet::ownerDir(carol.id()))); BEAST_EXPECT(!env.closed()->exists(keylet::depositPreauth(carol.id(), becky.id()))); BEAST_EXPECT(!env.closed()->exists(keylet::offer(carol.id(), carolOfferSeq))); - BEAST_EXPECT(!env.closed()->exists(keylet::kTICKET(carol.id(), carolTicketSeq))); + BEAST_EXPECT(!env.closed()->exists(keylet::kTicket(carol.id(), carolTicketSeq))); BEAST_EXPECT(!env.closed()->exists(keylet::signers(carol.id()))); // Verify that Carol's XRP, minus the fee, was transferred to becky. @@ -340,8 +341,8 @@ public: using namespace std::chrono_literals; std::uint32_t const escrowSeq{env.seq(alice)}; env(escrow::create(alice, becky, XRP(333)), - escrow::kFINISH_TIME(env.now() + 3s), - escrow::kCANCEL_TIME(env.now() + 4s)); + escrow::kFinishTime(env.now() + 3s), + escrow::kCancelTime(env.now() + 4s)); env.close(); // alice and becky should be unable to delete their accounts because @@ -369,8 +370,8 @@ public: std::uint32_t const escrowSeq{env.seq(carol)}; env(escrow::create(carol, becky, usd(1)), - escrow::kFINISH_TIME(env.now() + 3s), - escrow::kCANCEL_TIME(env.now() + 4s)); + escrow::kFinishTime(env.now() + 3s), + escrow::kCancelTime(env.now() + 4s)); env.close(); incLgrSeqForAccDel(env, gw1); @@ -460,8 +461,8 @@ public: // Alice creates 1001 offers. This is one greater than the number of // directory entries an AccountDelete will remove. std::uint32_t const offerSeq0{env.seq(alice)}; - constexpr int kOFFER_COUNT{1001}; - for (int i{0}; i < kOFFER_COUNT; ++i) + static constexpr int kOfferCount{1001}; + for (int i{0}; i < kOfferCount; ++i) { env(offer(alice, gw[currency](1), XRP(1))); env.close(); @@ -497,11 +498,11 @@ public: BEAST_EXPECT(closed->exists(aliceOwnerDirKey)); // alice's directory nodes. - for (std::uint32_t i{0}; i < ((kOFFER_COUNT / 32) + 1); ++i) + for (std::uint32_t i{0}; i < ((kOfferCount / 32) + 1); ++i) BEAST_EXPECT(closed->exists(keylet::page(aliceOwnerDirKey, i))); // alice's offers. - for (std::uint32_t i{0}; i < kOFFER_COUNT; ++i) + for (std::uint32_t i{0}; i < kOfferCount; ++i) BEAST_EXPECT(closed->exists(keylet::offer(alice.id(), offerSeq0 + i))); } @@ -512,10 +513,10 @@ public: env(acctdelete(alice, gw), Fee(acctDelFee), Ter(tefTOO_BIG)); // Cancel one of alice's offers. Then the account delete can succeed. - env.require(offers(alice, kOFFER_COUNT)); + env.require(offers(alice, kOfferCount)); env(offerCancel(alice, offerSeq0)); env.close(); - env.require(offers(alice, kOFFER_COUNT - 1)); + env.require(offers(alice, kOfferCount - 1)); // alice successfully deletes her account. auto const alicePreDelBal{env.balance(alice)}; @@ -531,11 +532,11 @@ public: BEAST_EXPECT(!closed->exists(aliceOwnerDirKey)); // alice's former directory nodes. - for (std::uint32_t i{0}; i < ((kOFFER_COUNT / 32) + 1); ++i) + for (std::uint32_t i{0}; i < ((kOfferCount / 32) + 1); ++i) BEAST_EXPECT(!closed->exists(keylet::page(aliceOwnerDirKey, i))); // alice's former offers. - for (std::uint32_t i{0}; i < kOFFER_COUNT; ++i) + for (std::uint32_t i{0}; i < kOfferCount; ++i) BEAST_EXPECT(!closed->exists(keylet::offer(alice.id(), offerSeq0 + i))); } } @@ -661,7 +662,7 @@ public: BEAST_EXPECT(closed->exists(keylet::account(bob.id()))); for (std::uint32_t i = 0; i < 250; ++i) { - BEAST_EXPECT(closed->exists(keylet::kTICKET(bob.id(), ticketSeq + i))); + BEAST_EXPECT(closed->exists(keylet::kTicket(bob.id(), ticketSeq + i))); } } @@ -680,7 +681,7 @@ public: BEAST_EXPECT(!closed->exists(keylet::account(bob.id()))); for (std::uint32_t i = 0; i < 250; ++i) { - BEAST_EXPECT(!closed->exists(keylet::kTICKET(bob.id(), ticketSeq + i))); + BEAST_EXPECT(!closed->exists(keylet::kTicket(bob.id(), ticketSeq + i))); } } } diff --git a/src/test/app/AccountSet_test.cpp b/src/test/app/AccountSet_test.cpp index c30553dad9..6688e3693f 100644 --- a/src/test/app/AccountSet_test.cpp +++ b/src/test/app/AccountSet_test.cpp @@ -536,7 +536,7 @@ public: env(fset(alice, asfRequireAuth), Ter(tecOWNERS)); // Remove the signer list. After that asfRequireAuth should succeed. - env(signers(alice, test::jtx::kNONE)); + env(signers(alice, test::jtx::kNone)); env.close(); BEAST_EXPECT(dirIsEmpty(*env.closed(), keylet::ownerDir(alice))); 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/AmendmentTable_test.cpp b/src/test/app/AmendmentTable_test.cpp index 5d4ca6f745..219aaabdda 100644 --- a/src/test/app/AmendmentTable_test.cpp +++ b/src/test/app/AmendmentTable_test.cpp @@ -208,7 +208,7 @@ public: std::unique_ptr makeTable(test::jtx::Env& env, std::chrono::seconds majorityTime) { - static std::vector const kSUPPORTED = combine( + static std::vector const kSupported = combine( makeDefaultYes(yes_), // Use non-intuitive default votes for "enabled_" and "vetoed_" // so that when the tests later explicitly enable or veto them, @@ -218,7 +218,7 @@ public: makeDefaultYes(vetoed_), makeObsolete(obsolete_)); return makeTable( - env.app(), majorityTime, kSUPPORTED, makeSection(enabled_), makeSection(vetoed_)); + env.app(), majorityTime, kSupported, makeSection(enabled_), makeSection(vetoed_)); } void @@ -1165,7 +1165,7 @@ public: testcase("hasUnsupportedEnabled"); using namespace std::chrono_literals; - weeks constexpr kW(1); + constexpr weeks kW(1); test::jtx::Env env{*this, makeConfig()}; auto table = makeTable(env, kW); BEAST_EXPECT(!table->hasUnsupportedEnabled()); diff --git a/src/test/app/Batch_test.cpp b/src/test/app/Batch_test.cpp index 8010b1e120..8755fe9f9c 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) @@ -2658,7 +2658,7 @@ class Batch_test : public beast::unit_test::Suite testcase("loan"); bool const lendingBatchEnabled = !std::ranges::any_of( - Batch::kDISABLED_TX_TYPES, + Batch::kDisabledTxTypes, [](auto const& disabled) { return disabled == ttLOAN_BROKER_SET; }); using namespace test::jtx; @@ -2699,10 +2699,10 @@ class Batch_test : public beast::unit_test::Suite { using namespace loanBroker; env(set(lender, vaultKeylet.key), - kMANAGEMENT_FEE_RATE(TenthBips16(100)), - kDEBT_MAXIMUM(debtMaximumValue), - kCOVER_RATE_MINIMUM(TenthBips32(percentageToTenthBips(10))), - kCOVER_RATE_LIQUIDATION(TenthBips32(percentageToTenthBips(25)))); + kManagementFeeRate(TenthBips16(100)), + kDebtMaximum(debtMaximumValue), + kCoverRateMinimum(TenthBips32(percentageToTenthBips(10))), + kCoverRateLiquidation(TenthBips32(percentageToTenthBips(25)))); env(coverDeposit(lender, brokerKeylet.key, coverDepositValue)); @@ -2727,9 +2727,9 @@ class Batch_test : public beast::unit_test::Suite set(lender, brokerKeylet.key, asset(1000).value()), // Not allowed to include the counterparty signature Sig(sfCounterpartySignature, borrower), - Sig(kNONE), - Fee(kNONE), - Seq(kNONE)), + Sig(kNone), + Fee(kNone), + Seq(kNone)), lenderSeq + 1), batch::Inner( pay(lender, loanKeylet.key, STAmount{asset, asset(500).value()}), @@ -2744,9 +2744,9 @@ class Batch_test : public beast::unit_test::Suite env.json( set(lender, brokerKeylet.key, asset(1000).value()), // Counterparty must be set - Sig(kNONE), - Fee(kNONE), - Seq(kNONE)), + Sig(kNone), + Fee(kNone), + Seq(kNone)), lenderSeq + 1), batch::Inner( pay(lender, loanKeylet.key, STAmount{asset, asset(500).value()}), @@ -2761,10 +2761,10 @@ class Batch_test : public beast::unit_test::Suite env.json( set(lender, brokerKeylet.key, asset(1000).value()), // Counterparty must sign the outer transaction - kCOUNTERPARTY(borrower.id()), - Sig(kNONE), - Fee(kNONE), - Seq(kNONE)), + kCounterparty(borrower.id()), + Sig(kNone), + Fee(kNone), + Seq(kNone)), lenderSeq + 1), batch::Inner( pay(lender, loanKeylet.key, STAmount{asset, asset(500).value()}), @@ -2782,10 +2782,10 @@ class Batch_test : public beast::unit_test::Suite batch::Inner( env.json( set(lender, brokerKeylet.key, asset(1000).value()), - kCOUNTERPARTY(borrower.id()), - Sig(kNONE), - Fee(kNONE), - Seq(kNONE)), + kCounterparty(borrower.id()), + Sig(kNone), + Fee(kNone), + Seq(kNone)), lenderSeq + 1), batch::Inner( pay( @@ -2814,10 +2814,10 @@ class Batch_test : public beast::unit_test::Suite batch::Inner( env.json( set(lender, brokerKeylet.key, asset(1000).value()), - kCOUNTERPARTY(borrower.id()), - Sig(kNONE), - Fee(kNONE), - Seq(kNONE)), + kCounterparty(borrower.id()), + Sig(kNone), + Fee(kNone), + Seq(kNone)), lenderSeq + 1), batch::Inner(manage(lender, loanKeylet.key, tfLoanImpair), lenderSeq + 2), batch::Sig(borrower)); @@ -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"); @@ -4321,7 +4321,7 @@ class Batch_test : public beast::unit_test::Suite batch::Inner(batch::outer(alice, seq, batchFee, tfAllOrNothing), seq), batch::Inner(pay(alice, bob, XRP(1)), seq + 2)); XRPAmount const txBaseFee = getBaseFee(jtx); - BEAST_EXPECT(txBaseFee == XRPAmount(kINITIAL_XRP)); + BEAST_EXPECT(txBaseFee == XRPAmount(kInitialXrp)); } // bad: Raw Transactions array exceeds max entries. @@ -4342,7 +4342,7 @@ class Batch_test : public beast::unit_test::Suite batch::Inner(pay(alice, bob, XRP(1)), seq + 9)); XRPAmount const txBaseFee = getBaseFee(jtx); - BEAST_EXPECT(txBaseFee == XRPAmount(kINITIAL_XRP)); + BEAST_EXPECT(txBaseFee == XRPAmount(kInitialXrp)); } // bad: Signers array exceeds max entries. @@ -4356,7 +4356,7 @@ class Batch_test : public beast::unit_test::Suite batch::Inner(pay(alice, bob, XRP(5)), seq + 2), batch::Sig(bob, carol, alice, bob, carol, alice, bob, carol, alice, alice)); XRPAmount const txBaseFee = getBaseFee(jtx); - BEAST_EXPECT(txBaseFee == XRPAmount(kINITIAL_XRP)); + BEAST_EXPECT(txBaseFee == XRPAmount(kInitialXrp)); } // good: diff --git a/src/test/app/CheckMPT_test.cpp b/src/test/app/CheckMPT_test.cpp index 418b7a4a71..1ca24051dd 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 @@ -282,7 +283,7 @@ class CheckMPT_test : public beast::unit_test::Suite STAmount const startBalance{XRP(1'000).value()}; env.fund(startBalance, gw1, gwF, alice, bob); - auto usdm = MPTTester({.env = env, .issuer = gw1, .flags = kMPT_DEX_FLAGS | tfMPTCanLock}); + auto usdm = MPTTester({.env = env, .issuer = gw1, .flags = kMptDexFlags | tfMPTCanLock}); MPT const usd = usdm; // Bad fee. @@ -348,7 +349,7 @@ class CheckMPT_test : public beast::unit_test::Suite // Globally frozen asset. env.close(); auto usfm = - MPTTester({.env = env, .issuer = gwF, .flags = kMPT_DEX_FLAGS | tfMPTCanLock}); + MPTTester({.env = env, .issuer = gwF, .flags = kMptDexFlags | tfMPTCanLock}); MPT const usf = usfm; usfm.set({.flags = tfMPTLock}); @@ -662,7 +663,7 @@ class CheckMPT_test : public beast::unit_test::Suite {.env = env, .issuer = gw, .holders = {alice}, - .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth, + .flags = kMptDexFlags | tfMPTRequireAuth, .maxAmt = 20}); MPT const usd = usdm; usdm.authorize({.holder = alice}); @@ -855,7 +856,7 @@ class CheckMPT_test : public beast::unit_test::Suite {.env = env, .issuer = gw, .holders = {alice}, - .flags = kMPT_DEX_FLAGS | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTCanLock, .maxAmt = maxAmt}); MPT const usd = usdm; @@ -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(); } @@ -1421,7 +1422,7 @@ class CheckMPT_test : public beast::unit_test::Suite Throw("AccountOwns: must be issuer"); if (auto const& it = mpts.find(s); it != mpts.end()) return it->second[s]; - auto flags = kMPT_DEX_FLAGS | tfMPTCanLock; + auto flags = kMptDexFlags | tfMPTCanLock; if (requireAuth) flags |= tfMPTRequireAuth; auto [it, _] = @@ -1859,10 +1860,10 @@ class CheckMPT_test : public beast::unit_test::Suite // Use offers to automatically create MPT. MPT const oF4 = gw1["OF4"]; gw1.set(oF4, tfMPTLock); - env(offer(gw1, XRP(92), oF4(92)), Ter(tecFROZEN)); + env(offer(gw1, XRP(92), oF4(92)), Ter(tecLOCKED)); env.close(); BEAST_EXPECT(env.le(keylet::mptoken(oF4, alice)) == nullptr); - env(offer(alice, oF4(92), XRP(92)), Ter(tecFROZEN)); + env(offer(alice, oF4(92), XRP(92)), Ter(tecLOCKED)); env.close(); // No one's owner count should have changed. @@ -1950,10 +1951,10 @@ class CheckMPT_test : public beast::unit_test::Suite // Use offers to automatically create MPT. MPT const oF4 = gw1["OF4"]; gw1.set(oF4, tfMPTLock); - env(offer(alice, XRP(91), oF4(91)), Ter(tecFROZEN)); + env(offer(alice, XRP(91), oF4(91)), Ter(tecLOCKED)); env.close(); BEAST_EXPECT(env.le(keylet::mptoken(oF4, alice)) == nullptr); - env(offer(bob, oF4(91), XRP(91)), Ter(tecFROZEN)); + env(offer(bob, oF4(91), XRP(91)), Ter(tecLOCKED)); env.close(); // No one's owner count should have changed. 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/ClawbackMPT_test.cpp b/src/test/app/ClawbackMPT_test.cpp new file mode 100644 index 0000000000..299e63d028 --- /dev/null +++ b/src/test/app/ClawbackMPT_test.cpp @@ -0,0 +1,435 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +namespace xrpl { + +class ClawbackMPT_test : public beast::unit_test::Suite +{ + static std::uint32_t + ticketCount(test::jtx::Env const& env, test::jtx::Account const& acct) + { + std::uint32_t ret{0}; + if (auto const sleAcct = env.le(acct)) + ret = sleAcct->at(~sfTicketCount).value_or(0); + return ret; + } + + void + testValidation(FeatureBitset features) + { + testcase("Validation"); + using namespace test::jtx; + + // MPT clawback fails when featureMPTokensV1 is disabled + { + Env env(*this, features - featureMPTokensV1); + Account const alice{"alice"}; + Account const bob{"bob"}; + + env.fund(XRP(1000), alice, bob); + env.close(); + + auto const mpt = xrpl::test::jtx::MPT(alice.name(), makeMptID(env.seq(alice), alice)); + + env(claw(alice, mpt(5), bob), Ter(temDISABLED)); + env.close(); + } + + // MPT clawback fails when tfMPTCanClawback is not set on the issuance + { + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + mptAlice.create({.ownerCount = 1, .holderCount = 0}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 100); + + mptAlice.claw(alice, bob, 10, tecNO_PERMISSION); + } + + // Test preflight validation failures + { + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + env.fund(XRP(1000), alice, bob); + env.close(); + + auto const mpt = xrpl::test::jtx::MPT(alice.name(), makeMptID(env.seq(alice), alice)); + + // fails due to invalid flag + env(claw(alice, mpt(5), bob), Txflags(0x00008000), Ter(temINVALID_FLAG)); + env.close(); + + // fails due to zero amount + env(claw(alice, mpt(0), bob), Ter(temBAD_AMOUNT)); + env.close(); + + // fails due to negative amount + env(claw(alice, mpt(-1), bob), Ter(temBAD_AMOUNT)); + env.close(); + + // fails when holder is not specified + env(claw(alice, mpt(5)), Ter(temMALFORMED)); + env.close(); + + // fails when issuer and holder are the same account + env(claw(alice, mpt(5), alice), Ter(temMALFORMED)); + env.close(); + } + + // Test preclaim failures + { + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + + auto const fakeMpt = + xrpl::test::jtx::MPT(alice.name(), makeMptID(env.seq(alice), alice)); + + // clawback fails when the issuance does not exist + env(claw(alice, fakeMpt(5), bob), Ter(tecOBJECT_NOT_FOUND)); + env.close(); + + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + + // clawback fails when bob has no MPToken + mptAlice.claw(alice, bob, 5, tecOBJECT_NOT_FOUND); + + mptAlice.authorize({.account = bob}); + + // clawback fails because bob's balance is 0 + mptAlice.claw(alice, bob, 5, tecINSUFFICIENT_FUNDS); + } + } + + void + testPermission(FeatureBitset features) + { + testcase("Permission"); + using namespace test::jtx; + + // Clawing back from a non-existent account fails + { + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + // bob is not funded and does not exist + MPTTester mptAlice(env, alice, MPTInit{}); + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + + mptAlice.claw(alice, bob, 5, terNO_ACCOUNT); + } + + // A non-issuer cannot claw back MPT + { + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + Account const cindy{"cindy"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + env.fund(XRP(1000), cindy); + env.close(); + + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 1000); + + // cindy fails to claw because she is not the issuer + mptAlice.claw(cindy, bob, 200, tecNO_PERMISSION); + } + } + + void + testEnabled(FeatureBitset features) + { + testcase("Enable clawback"); + using namespace test::jtx; + + // Test that alice is able to successfully clawback MPT from bob + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 1000); + + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 1000)); + + // alice claws back 200 tokens from bob + mptAlice.claw(alice, bob, 200); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 800)); + + // alice claws back remaining 800 tokens + mptAlice.claw(alice, bob, 800); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 0)); + } + + void + testMultiIssuance(FeatureBitset features) + { + testcase("Multi issuance"); + using namespace test::jtx; + + // Two issuers each issue their own MPT to cindy. + // Clawback from one does not affect the other. + { + Env env(*this, features); + + Account const alice{"alice"}; + Account const bob{"bob"}; + Account const cindy{"cindy"}; + + MPTTester mptAlice(env, alice, {.holders = {cindy}}); + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + mptAlice.authorize({.account = cindy}); + mptAlice.pay(alice, cindy, 1000); + + MPTTester mptBob(env, bob, MPTInit{}); // cindy already funded by mptAlice + mptBob.create({.ownerCount = 1, .flags = tfMPTCanClawback}); + mptBob.authorize({.account = cindy}); + mptBob.pay(bob, cindy, 1000); + + BEAST_EXPECT(mptAlice.checkMPTokenAmount(cindy, 1000)); + BEAST_EXPECT(mptBob.checkMPTokenAmount(cindy, 1000)); + + // alice claws back 200 from cindy, bob's issuance is unaffected + mptAlice.claw(alice, cindy, 200); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(cindy, 800)); + BEAST_EXPECT(mptBob.checkMPTokenAmount(cindy, 1000)); + + // bob claws back 600 from cindy, alice's issuance is unaffected + mptBob.claw(bob, cindy, 600); + BEAST_EXPECT(mptBob.checkMPTokenAmount(cindy, 400)); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(cindy, 800)); + } + + // One issuer issues MPT to two different holders. + // Clawback from one holder does not affect the other. + { + Env env(*this, features); + + Account const alice{"alice"}; + Account const bob{"bob"}; + Account const cindy{"cindy"}; + + MPTTester mptAlice(env, alice, {.holders = {bob, cindy}}); + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.authorize({.account = cindy}); + mptAlice.pay(alice, bob, 600); + mptAlice.pay(alice, cindy, 1000); + + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 600)); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(cindy, 1000)); + + // alice claws back 500 from bob, cindy's balance is unchanged + mptAlice.claw(alice, bob, 500); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 100)); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(cindy, 1000)); + + // alice claws back 300 from cindy, bob's balance is unchanged + mptAlice.claw(alice, cindy, 300); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(cindy, 700)); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 100)); + } + } + + void + testZeroBalanceAfterClawback(FeatureBitset features) + { + testcase("Zero balance after clawback"); + using namespace test::jtx; + + // After clawback reduces balance to zero, the MPToken object + // still exists (unlike IOU trustlines which are deleted). + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 1000); + + BEAST_EXPECT(ownerCount(env, bob) == 1); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 1000)); + + // alice claws back the full amount + mptAlice.claw(alice, bob, 1000); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 0)); + + // bob still holds the MPToken object (balance 0, not deleted) + BEAST_EXPECT(ownerCount(env, bob) == 1); + } + + void + testLockedMPT(FeatureBitset features) + { + testcase("Locked MPT"); + using namespace test::jtx; + + // Test that globally locked MPT can still be clawed back + { + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + mptAlice.create( + {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanLock | tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 1000); + + // globally lock the issuance + mptAlice.set({.account = alice, .flags = tfMPTLock}); + + // clawback succeeds despite global lock + mptAlice.claw(alice, bob, 200); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 800)); + } + + // Test that individually locked MPT can still be clawed back + { + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + mptAlice.create( + {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanLock | tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 1000); + + // individually lock bob's MPToken + mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock}); + + // clawback succeeds despite individual lock + mptAlice.claw(alice, bob, 200); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 800)); + } + } + + void + testAmountExceedsAvailable(FeatureBitset features) + { + testcase("Amount exceeds available"); + using namespace test::jtx; + + // When alice tries to claw back more than bob holds, + // only the available balance is clawed back + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 1000); + + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 1000)); + + // alice tries to claw back 2000, but bob only has 1000 + mptAlice.claw(alice, bob, 2000); + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 0)); + BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(0)); + + // MPToken object still exists with 0 balance + BEAST_EXPECT(ownerCount(env, bob) == 1); + } + + void + testTickets(FeatureBitset features) + { + testcase("Tickets"); + using namespace test::jtx; + + // Tests MPT clawback using tickets + Env env(*this, features); + Account const alice{"alice"}; + Account const bob{"bob"}; + + MPTTester mptAlice(env, alice, {.holders = {bob}}); + mptAlice.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback}); + mptAlice.authorize({.account = bob}); + mptAlice.pay(alice, bob, 100); + + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 100)); + + // alice creates 10 tickets + std::uint32_t ticketCnt = 10; + std::uint32_t aliceTicketSeq{env.seq(alice) + 1}; + env(ticket::create(alice, ticketCnt)); + env.close(); + std::uint32_t const aliceSeq{env.seq(alice)}; + BEAST_EXPECT(ticketCount(env, alice) == ticketCnt); + BEAST_EXPECT(ownerCount(env, alice) == ticketCnt + 1); // tickets + issuance + + while (ticketCnt > 0) + { + // alice claws back 5 tokens using a ticket + env(claw(alice, mptAlice.mpt(5), bob), ticket::Use(aliceTicketSeq++)); + env.close(); + + ticketCnt--; + BEAST_EXPECT(ticketCount(env, alice) == ticketCnt); + } + + // alice clawed back 50 tokens total, 50 remain + BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 50)); + + // account sequence numbers did not advance + BEAST_EXPECT(env.seq(alice) == aliceSeq); + } + + void + testWithFeats(FeatureBitset features) + { + testValidation(features); + testPermission(features); + testEnabled(features); + testMultiIssuance(features); + testZeroBalanceAfterClawback(features); + testLockedMPT(features); + testAmountExceedsAvailable(features); + testTickets(features); + } + +public: + void + run() override + { + using namespace test::jtx; + FeatureBitset const all{testableAmendments()}; + testWithFeats(all); + } +}; + +BEAST_DEFINE_TESTSUITE(ClawbackMPT, app, xrpl); +} // namespace xrpl diff --git a/src/test/app/Credentials_test.cpp b/src/test/app/Credentials_test.cpp index fa180d0603..9416ca222f 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); @@ -456,17 +461,17 @@ struct Credentials_test : public beast::unit_test::Suite testcase( "Credentials fail, credentialType length > " "maxCredentialTypeLength."); - constexpr std::string_view kLONG_CRED_TYPE = + static constexpr std::string_view kLongCredType = "abcdefghijklmnopqrstuvwxyz01234567890qwertyuiop[]" "asdfghjkl;'zxcvbnm8237tr28weufwldebvfv8734t07p"; - static_assert(kLONG_CRED_TYPE.size() > kMAX_CREDENTIAL_TYPE_LENGTH); - auto jv = credentials::create(subject, issuer, kLONG_CRED_TYPE); + static_assert(kLongCredType.size() > kMaxCredentialTypeLength); + auto jv = credentials::create(subject, issuer, kLongCredType); env(jv, Ter(temMALFORMED)); } { testcase("Credentials fail, URI length > 256."); - constexpr std::string_view kLONG_URI = + static constexpr std::string_view kLongUri = "abcdefghijklmnopqrstuvwxyz01234567890qwertyuiop[]" "asdfghjkl;'zxcvbnm8237tr28weufwldebvfv8734t07p " "9hfup;wDJFBVSD8f72 " @@ -475,9 +480,9 @@ struct Credentials_test : public beast::unit_test::Suite "vujhgWQIE7F6WEUYFGWUKEYFVQW87FGWOEFWEFUYWVEF8723GFWEFB" "WULE" "fv28o37gfwEFB3872TFO8GSDSDVD"; - static_assert(kLONG_URI.size() > kMAX_CREDENTIAL_URI_LENGTH); + static_assert(kLongUri.size() > kMaxCredentialUriLength); env(credentials::create(subject, issuer, credType), - credentials::Uri(kLONG_URI), + credentials::Uri(kLongUri), Ter(temMALFORMED)); } @@ -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/CrossingLimitsMPT_test.cpp b/src/test/app/CrossingLimitsMPT_test.cpp index e9a9861a3a..4a016f31dc 100644 --- a/src/test/app/CrossingLimitsMPT_test.cpp +++ b/src/test/app/CrossingLimitsMPT_test.cpp @@ -52,7 +52,7 @@ public: // Carol offers to buy 1000 XRP for 1000 USD. She removes Bob's next // 1000 offers as unfunded and hits the step limit. env(offer("carol", usd(1'000), XRP(1'000))); - env.require(Balance("carol", usd(kNONE))); + env.require(Balance("carol", usd(kNone))); env.require(Owners("carol", 1)); env.require(Balance("bob", usd(0))); env.require(Owners("bob", 1)); @@ -198,13 +198,13 @@ public: .token = "USD", .issuer = gw, .holders = {alice, carol}, - .limit = kMAX_MP_TOKEN_AMOUNT}); + .limit = kMaxMpTokenAmount}); auto const eur = issue2( {.env = env, .token = "EUR", .issuer = gw, .holders = {bob}, - .limit = kMAX_MP_TOKEN_AMOUNT}); + .limit = kMaxMpTokenAmount}); env(pay(gw, alice, usd(4'000))); env(pay(gw, carol, usd(3))); @@ -289,13 +289,13 @@ public: .token = "USD", .issuer = gw, .holders = {alice, carol}, - .limit = kMAX_MP_TOKEN_AMOUNT}); + .limit = kMaxMpTokenAmount}); auto const eur = issue2( {.env = env, .token = "EUR", .issuer = gw, .holders = {bob}, - .limit = kMAX_MP_TOKEN_AMOUNT}); + .limit = kMaxMpTokenAmount}); env(pay(gw, alice, usd(4'000))); env(pay(gw, carol, usd(3))); diff --git a/src/test/app/CrossingLimits_test.cpp b/src/test/app/CrossingLimits_test.cpp index 331afddad1..3cf8f50990 100644 --- a/src/test/app/CrossingLimits_test.cpp +++ b/src/test/app/CrossingLimits_test.cpp @@ -51,7 +51,7 @@ public: // Carol offers to buy 1000 XRP for 1000 USD. She removes Bob's next // 1000 offers as unfunded and hits the step limit. env(offer("carol", usd(1000), XRP(1000))); - env.require(Balance("carol", usd(kNONE))); + env.require(Balance("carol", usd(kNone))); env.require(Owners("carol", 1)); env.require(Balance("bob", usd(0))); env.require(Owners("bob", 1)); diff --git a/src/test/app/Delegate_test.cpp b/src/test/app/Delegate_test.cpp index 6ec4c250f6..588aeee634 100644 --- a/src/test/app/Delegate_test.cpp +++ b/src/test/app/Delegate_test.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -195,7 +196,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; @@ -552,27 +553,27 @@ class Delegate_test : public beast::unit_test::Suite for (auto i = 0; i < 20; ++i) { - // bob is the delegated account, his sequence won't kINCREMENT + // bob is the delegated account, his sequence won't kIncrement env(pay(alice, carol, XRP(10)), Fee(XRP(10)), delegate::As(bob)); env.close(); BEAST_EXPECT(env.seq(alice) == aliceSeq + 1); BEAST_EXPECT(env.seq(bob) == bobSeq); aliceSeq = env.seq(alice); - // bob sends payment for himself, his sequence will kINCREMENT + // bob sends payment for himself, his sequence will kIncrement env(pay(bob, carol, XRP(10)), Fee(XRP(10))); BEAST_EXPECT(env.seq(alice) == aliceSeq); BEAST_EXPECT(env.seq(bob) == bobSeq + 1); bobSeq = env.seq(bob); - // alice is the delegated account, her sequence won't kINCREMENT + // alice is the delegated account, her sequence won't kIncrement env(pay(bob, carol, XRP(10)), Fee(XRP(10)), delegate::As(alice)); env.close(); BEAST_EXPECT(env.seq(alice) == aliceSeq); BEAST_EXPECT(env.seq(bob) == bobSeq + 1); bobSeq = env.seq(bob); - // alice sends payment for herself, her sequence will kINCREMENT + // alice sends payment for herself, her sequence will kIncrement env(pay(alice, carol, XRP(10)), Fee(XRP(10))); BEAST_EXPECT(env.seq(alice) == aliceSeq + 1); BEAST_EXPECT(env.seq(bob) == bobSeq); @@ -1879,6 +1880,149 @@ class Delegate_test : public beast::unit_test::Suite BEAST_EXPECT(env.balance(edward) == edwardBalance); } + void + testMultiSignDelegatorAsSigner() + { + // checkMultiSign disallows the owner of the account to + // be part of the multisigner list. When it is a delegated transaction, + // the delegate account should not be part of the multisigner list. + testcase("test delegator as multisigner in delegate's signer list"); + using namespace jtx; + + Env env(*this); + Account const alice{"alice"}; + Account const bob{"bob"}; + Account const carol{"carol"}; + Account const daria{"daria"}; + env.fund(XRP(100000), alice, bob, carol, daria); + env.close(); + + env(delegate::set(alice, bob, {"Payment"})); + env.close(); + + // bob's signer list includes the delegator alice and daria + env(signers(bob, 2, {{alice, 1}, {daria, 1}})); + env.close(); + + auto aliceBalance = env.balance(alice); + auto bobBalance = env.balance(bob); + auto carolBalance = env.balance(carol); + auto const amt = 100; + + // alice can sign as a multisigner for bob + env(pay(alice, carol, XRP(100)), Fee(XRP(10)), delegate::As(bob), Msig(alice, daria)); + env.close(); + + BEAST_EXPECT(env.balance(alice) == aliceBalance - XRP(amt)); + BEAST_EXPECT(env.balance(bob) == bobBalance - XRP(10)); + BEAST_EXPECT(env.balance(carol) == carolBalance + XRP(amt)); + + // alice can not sign as a multisigner if she sent the transaction by herself. + env(pay(alice, carol, XRP(100)), Fee(XRP(10)), Msig(alice, daria), Ter(telENV_RPC_FAILED)); + env.close(); + + // Get new balances + aliceBalance = env.balance(alice); + bobBalance = env.balance(bob); + carolBalance = env.balance(carol); + + // bob (the delegate) should not appear as a multisigner in his transaction sent on behalf + // of alice. STTx::checkMultiSign catches this at the local-check stage, so the jtx + // framework returns telENV_RPC_FAILED. + env(pay(alice, carol, XRP(50)), + Fee(XRP(10)), + delegate::As(bob), + Msig(alice, bob), + Ter(telENV_RPC_FAILED)); + env.close(); + BEAST_EXPECT(env.balance(alice) == aliceBalance); + BEAST_EXPECT(env.balance(bob) == bobBalance); + BEAST_EXPECT(env.balance(carol) == carolBalance); + } + + void + testSignForDelegated() + { + // In sortAndValidateSigners, if it is a delegated transaction, the delegate account is + // the forbidden account from appearing in its own Signers array. + testcase("test sign_for with delegated transaction"); + using namespace jtx; + + Env env(*this); + Account const alice{"alice"}; + Account const bob{"bob"}; + Account const carol{"carol"}; + Account const daria{"daria"}; + env.fund(XRP(100000), alice, bob, carol, daria); + env.close(); + + env(delegate::set(alice, bob, {"Payment"})); + env.close(); + + // bob's signer list includes the delegator alice and daria + env(signers(bob, 2, {{alice, 1}, {daria, 1}})); + env.close(); + + auto const baseFee = env.current()->fees().base; + + auto const sendAmt = 1'000'000; + auto makeDelegateTx = [&]() -> json::Value { + json::Value jv; + jv[jss::tx_json][jss::Account] = alice.human(); + jv[jss::tx_json][sfDelegate.jsonName] = bob.human(); + jv[jss::tx_json][jss::TransactionType] = jss::Payment; + jv[jss::tx_json][jss::Destination] = carol.human(); + jv[jss::tx_json][jss::Amount] = sendAmt; + jv[jss::tx_json][jss::Fee] = std::to_string((10 * baseFee).drops()); + jv[jss::tx_json][jss::Sequence] = env.seq(alice); + jv[jss::tx_json][jss::SigningPubKey] = ""; + return jv; + }; + + // The delegator alice and daria both sign via sign_for, which is valid + { + auto const aliceBalance = env.balance(alice); + auto const bobBalance = env.balance(bob); + auto const dariaBalance = env.balance(daria); + auto const carolBalance = env.balance(carol); + + json::Value jv = makeDelegateTx(); + jv[jss::account] = alice.human(); + jv[jss::secret] = alice.name(); + auto jrr = env.rpc("json", "sign_for", to_string(jv))[jss::result]; + BEAST_EXPECT(jrr[jss::status] == "success"); + + json::Value jv2; + jv2[jss::tx_json] = jrr[jss::tx_json]; + jv2[jss::account] = daria.human(); + jv2[jss::secret] = daria.name(); + jrr = env.rpc("json", "sign_for", to_string(jv2))[jss::result]; + BEAST_EXPECT(jrr[jss::status] == "success"); + + json::Value jvSubmit; + jvSubmit[jss::tx_json] = jrr[jss::tx_json]; + jrr = env.rpc("json", "submit_multisigned", to_string(jvSubmit))[jss::result]; + BEAST_EXPECT(jrr[jss::status] == "success"); + env.close(); + BEAST_EXPECT(env.balance(alice) == aliceBalance - XRPAmount(sendAmt)); + BEAST_EXPECT(env.balance(bob) == bobBalance - (10 * baseFee)); + BEAST_EXPECT(env.balance(daria) == dariaBalance); + BEAST_EXPECT(env.balance(carol) == carolBalance + XRPAmount(sendAmt)); + } + + // The delegated account bob attempts sign_for, will be rejected. + { + json::Value jv = makeDelegateTx(); + jv[jss::account] = bob.human(); + jv[jss::secret] = bob.name(); + auto jrr = env.rpc("json", "sign_for", to_string(jv))[jss::result]; + BEAST_EXPECT(jrr[jss::status] == "error"); + BEAST_EXPECT( + jrr[jss::error_message].asString().find( + "A Signer may not be the transaction's Account") != std::string::npos); + } + } + void testPermissionValue(FeatureBitset features) { @@ -1898,7 +2042,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; @@ -2086,6 +2230,8 @@ class Delegate_test : public beast::unit_test::Suite testSingleSignBadSecret(); testMultiSign(); testMultiSignQuorumNotMet(); + testMultiSignDelegatorAsSigner(); + testSignForDelegated(); testPermissionValue(all); testTxRequireFeatures(all); testTxDelegableCount(); diff --git a/src/test/app/DepositAuth_test.cpp b/src/test/app/DepositAuth_test.cpp index e0b48d8572..98597a175f 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; @@ -1232,7 +1232,7 @@ struct DepositPreauth_test : public beast::unit_test::Suite env.close(); auto const seq = env.seq(alice); - env(escrow::create(alice, bob, XRP(1000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, bob, XRP(1000)), escrow::kFinishTime(env.now() + 1s)); env.close(); // zelda can't finish escrow with invalid credentials 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/EscrowToken_test.cpp b/src/test/app/EscrowToken_test.cpp index bf7cf90bf2..5bb1303dba 100644 --- a/src/test/app/EscrowToken_test.cpp +++ b/src/test/app/EscrowToken_test.cpp @@ -122,23 +122,23 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), createResult); env.close(); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), finishResult); env.close(); auto const seq2 = env.seq(alice); env(escrow::create(alice, bob, usd(1'000)), - escrow::kCONDITION(escrow::kCB2), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb2), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150), createResult); env.close(); @@ -166,8 +166,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecNO_TARGET)); env.close(); @@ -203,16 +203,16 @@ struct EscrowToken_test : public beast::unit_test::Suite // Create Escrow #1 & #2 auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); auto const seq2 = env.seq(alice); env(escrow::create(alice, bob, usd(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 3s), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 3s), Fee(baseFee), Ter(tesSUCCESS)); env.close(); @@ -224,16 +224,16 @@ struct EscrowToken_test : public beast::unit_test::Suite // Cannot Create Escrow without asfAllowTrustLineLocking env(escrow::create(alice, bob, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); // Can finish the escrow created before the flag was cleared env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -260,7 +260,7 @@ struct EscrowToken_test : public beast::unit_test::Suite env.fund(XRP(5000), alice, bob, gw); env(escrow::create(alice, bob, usd(1)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Fee(XRP(-1)), Ter(temBAD_FEE)); env.close(); @@ -277,8 +277,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.fund(XRP(5000), alice, bob, gw); env(escrow::create(alice, bob, usd(-1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(temBAD_AMOUNT)); env.close(); @@ -295,8 +295,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.fund(XRP(5000), alice, bob, gw); env(escrow::create(alice, bob, bad(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(temBAD_CURRENCY)); env.close(); @@ -321,8 +321,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.fund(XRP(5000), alice, bob, gw); env(escrow::create(gw, alice, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); @@ -341,8 +341,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.memoize(gw); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_ISSUER)); env.close(); @@ -365,8 +365,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(gw, alice, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); @@ -384,8 +384,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env(fset(gw, asfAllowTrustLineLocking)); env.close(); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_LINE)); env.close(); @@ -409,8 +409,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -434,8 +434,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -465,8 +465,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecFROZEN)); env.close(); @@ -496,8 +496,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecFROZEN)); env.close(); @@ -520,8 +520,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecINSUFFICIENT_FUNDS)); env.close(); @@ -547,8 +547,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, usd(10'001)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecINSUFFICIENT_FUNDS)); env.close(); @@ -577,8 +577,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice cannot create escrow for 1/10 iou - precision loss env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(largeMantissa ? (TER)tesSUCCESS : (TER)tecPRECISION_LOSS)); env.close(); @@ -616,8 +616,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -632,8 +632,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob cannot finish because he is not authorized env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -658,8 +658,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -669,8 +669,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob cannot finish because of deep freeze env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecFROZEN)); env.close(); @@ -706,16 +706,16 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); // bob cannot finish because insufficient reserve to create line env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecNO_LINE_INSUF_RESERVE)); env.close(); @@ -740,16 +740,16 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); // alice cannot finish because bob does not have a trustline env(escrow::finish(alice, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecNO_LINE)); env.close(); @@ -774,8 +774,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(5)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -785,8 +785,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice cannot finish because bob's limit is too low env(escrow::finish(alice, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecLIMIT_EXCEEDED)); env.close(); @@ -811,8 +811,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(5)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -824,8 +824,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const bobPreLimit = env.limit(bob, usd); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -866,8 +866,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, usd(1)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee), Ter(tesSUCCESS)); env.close(); @@ -886,6 +886,70 @@ struct EscrowToken_test : public beast::unit_test::Suite } } + void + testIOUCancelDoApply(FeatureBitset features) + { + testcase("IOU Cancel DoApply"); + using namespace jtx; + using namespace std::literals; + + { + Env env{*this, features}; + auto const baseFee = env.current()->fees().base; + auto const alice = Account("alice"); + auto const bob = Account("bob"); + auto const gw = Account("gw"); + auto const usd = gw["USD"]; + + env.fund(XRP(10'000), alice, bob, gw); + env.close(); + + env(fset(gw, asfAllowTrustLineLocking)); + env.close(); + + env.trust(usd(100'000), alice); + env.trust(usd(100'000), bob); + env.close(); + + env(pay(gw, alice, usd(10'000))); + env.close(); + + auto const seq = env.seq(alice); + env(escrow::create(alice, bob, usd(1'000)), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), + Fee(baseFee)); + env.close(); + + BEAST_EXPECT(env.balance(alice, usd) == usd(9'000)); + + env(pay(alice, gw, usd(9'000))); + env.close(); + + env(trust(alice, usd(0))); + env.close(); + + auto const trustLineKey = keylet::line(alice.id(), gw.id(), usd.currency); + BEAST_EXPECT(!env.current()->exists(trustLineKey)); + + env.close(); + env.close(); + + auto const expectedResult = env.current()->rules().enabled(fixCleanup3_2_0) + ? Ter(tesSUCCESS) + : Ter(tefEXCEPTION); + env(escrow::cancel(alice, alice, seq), Fee(baseFee), expectedResult); + env.close(); + + if (env.current()->rules().enabled(fixCleanup3_2_0)) + { + BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq))); + BEAST_EXPECT(env.current()->exists(trustLineKey)); + BEAST_EXPECT(env.balance(alice, usd) == usd(1'000)); + } + } + } + void testIOUBalances(FeatureBitset features) { @@ -917,8 +981,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preAliceUSD = env.balance(alice, usd); auto const preBobUSD = env.balance(bob, usd); env(escrow::create(alice, bob, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -932,8 +996,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preAliceUSD = env.balance(alice, usd); auto const preBobUSD = env.balance(bob, usd); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -950,9 +1014,9 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preAliceUSD = env.balance(alice, usd); auto const preBobUSD = env.balance(bob, usd); env(escrow::create(alice, bob, usd(1'000)), - escrow::kCONDITION(escrow::kCB2), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb2), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -1003,8 +1067,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const bseq = env.seq(bob); env(escrow::create(alice, alice, usd(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 500s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 500s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -1027,8 +1091,8 @@ struct EscrowToken_test : public beast::unit_test::Suite } env(escrow::create(bob, bob, usd(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -1113,13 +1177,13 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const aseq = env.seq(alice); auto const bseq = env.seq(bob); - env(escrow::create(alice, bob, usd(1'000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, bob, usd(1'000)), escrow::kFinishTime(env.now() + 1s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); env(escrow::create(bob, carol, usd(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -1245,14 +1309,14 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); auto const aseq = env.seq(alice); - env(escrow::create(alice, gw, usd(1'000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, gw, usd(1'000)), escrow::kFinishTime(env.now() + 1s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); env(escrow::create(gw, carol, usd(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Ter(tecNO_PERMISSION)); env.close(5s); @@ -1394,8 +1458,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(t.src); auto const delta = usd(1'000); env(escrow::create(t.src, t.dst, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -1404,8 +1468,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preDst = env.balance(t.dst, usd); env(escrow::finish(t.dst, t.src, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -1446,8 +1510,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // issuer cannot create escrow env(escrow::create(gw, alice, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); @@ -1484,15 +1548,15 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(t.src); auto const preSrc = env.balance(t.src, usd); env(escrow::create(t.src, t.dst, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); // issuer can finish escrow, no dest trustline env(escrow::finish(t.dst, t.src, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); auto const preAmount = 10'000; @@ -1514,8 +1578,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // issuer cannot receive escrow env(escrow::create(gw, gw, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); @@ -1555,8 +1619,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); auto const delta = usd(125); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); auto const transferRate = escrow::rate(env, alice, seq1); @@ -1564,8 +1628,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob can finish escrow env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -1592,8 +1656,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); auto const delta = usd(125); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); auto transferRate = escrow::rate(env, alice, seq1); @@ -1605,8 +1669,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob can finish escrow - rate unchanged env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -1634,8 +1698,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); auto const delta = usd(125); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); auto transferRate = escrow::rate(env, alice, seq1); @@ -1647,8 +1711,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob can finish escrow - rate changed env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -1676,8 +1740,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); auto const delta = usd(125); env(escrow::create(alice, bob, delta), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 3s), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 3s), Fee(baseFee)); env.close(); auto transferRate = escrow::rate(env, alice, seq1); @@ -1725,16 +1789,16 @@ struct EscrowToken_test : public beast::unit_test::Suite auto seq1 = env.seq(alice); auto const delta = usd(125); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); // bob can finish auto const preBobLimit = env.limit(bob, usd); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); auto const postBobLimit = env.limit(bob, usd); @@ -1776,8 +1840,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto seq1 = env.seq(alice); auto const delta = usd(125); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -1792,15 +1856,15 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice can create escrow - bob has auth seq1 = env.seq(alice); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); // bob can finish env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); } @@ -1840,8 +1904,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow fails - frozen trustline env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecFROZEN)); env.close(); @@ -1853,8 +1917,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow success seq1 = env.seq(alice); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -1864,8 +1928,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob finish escrow success regardless of frozen assets env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -1876,8 +1940,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow success seq1 = env.seq(alice); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -1915,8 +1979,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow fails - frozen trustline env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecFROZEN)); env.close(); @@ -1928,8 +1992,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow success seq1 = env.seq(alice); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -1939,8 +2003,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob finish escrow success regardless of frozen assets env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -1952,8 +2016,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow success seq1 = env.seq(alice); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -1991,8 +2055,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow fails - frozen trustline env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecFROZEN)); env.close(); @@ -2004,8 +2068,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow success seq1 = env.seq(alice); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -2015,8 +2079,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob finish escrow fails because of deep frozen assets env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecFROZEN)); env.close(); @@ -2029,8 +2093,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow success seq1 = env.seq(alice); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -2073,8 +2137,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // create escrow success auto const delta = usd(1'000); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); env(pay(alice, gw, usd(10'000)), Ter(tecPATH_PARTIAL)); @@ -2096,14 +2160,14 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const delta = usd(1'000); env(escrow::create(alice, bob, delta), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); env(escrow::create(alice, bob, usd(10'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecINSUFFICIENT_FUNDS)); env.close(); @@ -2141,8 +2205,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice cannot create escrow for 1/10 iou - precision loss env(escrow::create(alice, bob, usd(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(largeMantissa ? (TER)tesSUCCESS : (TER)tecPRECISION_LOSS)); env.close(); @@ -2150,15 +2214,15 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); // alice can create escrow for 1'000 iou env(escrow::create(alice, bob, usd(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); // bob finish escrow success env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); } @@ -2195,22 +2259,22 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), createResult); env.close(); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), finishResult); env.close(); auto const seq2 = env.seq(alice); env(escrow::create(alice, bob, mpt(1'000)), - escrow::kCONDITION(escrow::kCB2), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb2), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150), createResult); env.close(); @@ -2244,8 +2308,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const result = withMPT ? Ter(temBAD_AMOUNT) : Ter(temDISABLED); env(jv, - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), result); env.close(); @@ -2270,8 +2334,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, mpt(-1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(temBAD_AMOUNT)); env.close(); @@ -2301,8 +2365,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(gw, alice, mpt(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); @@ -2323,8 +2387,8 @@ struct EscrowToken_test : public beast::unit_test::Suite jv[jss::Amount][jss::mpt_issuance_id] = "00000004A407AF5856CCF3C42619DAA925813FC955C72983"; env(jv, - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecOBJECT_NOT_FOUND)); env.close(); @@ -2348,8 +2412,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, mpt(3)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); @@ -2369,8 +2433,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const mpt = mptGw["MPT"]; env(escrow::create(alice, bob, mpt(4)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecOBJECT_NOT_FOUND)); env.close(); @@ -2399,8 +2463,8 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.authorize({.account = gw, .holder = alice, .flags = tfMPTUnauthorize}); env(escrow::create(alice, bob, mpt(5)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -2432,8 +2496,8 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.authorize({.account = gw, .holder = bob, .flags = tfMPTUnauthorize}); env(escrow::create(alice, bob, mpt(6)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -2463,8 +2527,8 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.set({.account = gw, .holder = alice, .flags = tfMPTLock}); env(escrow::create(alice, bob, mpt(7)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecLOCKED)); env.close(); @@ -2494,8 +2558,8 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.set({.account = gw, .holder = bob, .flags = tfMPTLock}); env(escrow::create(alice, bob, mpt(8)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecLOCKED)); env.close(); @@ -2519,8 +2583,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, mpt(9)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -2544,8 +2608,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, mpt(11)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecINSUFFICIENT_FUNDS)); env.close(); @@ -2570,8 +2634,8 @@ struct EscrowToken_test : public beast::unit_test::Suite env.close(); env(escrow::create(alice, bob, mpt(11)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecINSUFFICIENT_FUNDS)); env.close(); @@ -2609,8 +2673,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2619,8 +2683,8 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.authorize({.account = gw, .holder = bob, .flags = tfMPTUnauthorize}); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -2649,8 +2713,8 @@ struct EscrowToken_test : public beast::unit_test::Suite }); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecOBJECT_NOT_FOUND)); env.close(); @@ -2678,8 +2742,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(8)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2688,8 +2752,8 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.set({.account = gw, .holder = bob, .flags = tfMPTLock}); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecLOCKED)); env.close(); @@ -2726,15 +2790,15 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecINSUFFICIENT_RESERVE)); env.close(); @@ -2760,15 +2824,15 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2795,15 +2859,15 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); env(escrow::finish(carol, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); env.close(); @@ -2841,8 +2905,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCANCEL_TIME(env.now() + 2s), - escrow::kCONDITION(escrow::kCB1), + escrow::kCancelTime(env.now() + 2s), + escrow::kCondition(escrow::kCb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2914,8 +2978,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preAliceMPT = env.balance(alice, mpt); auto const preBobMPT = env.balance(bob, mpt); env(escrow::create(alice, bob, mpt(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2931,8 +2995,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preAliceMPT = env.balance(alice, mpt); auto const preBobMPT = env.balance(bob, mpt); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2951,9 +3015,9 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preAliceMPT = env.balance(alice, mpt); auto const preBobMPT = env.balance(bob, mpt); env(escrow::create(alice, bob, mpt(1'000)), - escrow::kCONDITION(escrow::kCB2), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb2), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2984,8 +3048,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq = env.seq(alice); auto const preAliceMPT = env.balance(alice, mpt); env(escrow::create(alice, alice, mpt(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -2996,8 +3060,8 @@ struct EscrowToken_test : public beast::unit_test::Suite BEAST_EXPECT(issuerMPTEscrowed(env, mpt) == 1'000); env(escrow::finish(alice, alice, seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -3013,9 +3077,9 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq = env.seq(alice); auto const preAliceMPT = env.balance(alice, mpt); env(escrow::create(alice, alice, mpt(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -3040,15 +3104,15 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const preBobMPT = env.balance(bob, mpt); auto const preCarolMPT = env.balance(carol, mpt); env(escrow::create(alice, bob, mpt(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); env(escrow::create(carol, bob, mpt(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -3077,7 +3141,7 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.authorize({.account = alice}); mptGw.authorize({.account = bob}); auto const mpt = mptGw["MPT"]; - env(pay(gw, alice, mpt(kMAX_MP_TOKEN_AMOUNT))); + env(pay(gw, alice, mpt(kMaxMpTokenAmount))); env.close(); auto const preAliceMPT = env.balance(alice, mpt); @@ -3086,8 +3150,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -3099,8 +3163,8 @@ struct EscrowToken_test : public beast::unit_test::Suite BEAST_EXPECT(issuerMPTEscrowed(env, mpt) == 1); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -3130,7 +3194,7 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.authorize({.account = alice}); mptGw.authorize({.account = bob}); auto const mpt = mptGw["MPT"]; - env(pay(gw, alice, mpt(kMAX_MP_TOKEN_AMOUNT))); + env(pay(gw, alice, mpt(kMaxMpTokenAmount))); env.close(); auto const preAliceMPT = env.balance(alice, mpt); @@ -3139,44 +3203,44 @@ struct EscrowToken_test : public beast::unit_test::Suite // Escrow Max MPT - 10 auto const seq1 = env.seq(alice); - env(escrow::create(alice, bob, mpt(kMAX_MP_TOKEN_AMOUNT - 10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + env(escrow::create(alice, bob, mpt(kMaxMpTokenAmount - 10)), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); // Escrow 10 MPT auto const seq2 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); - BEAST_EXPECT(env.balance(alice, mpt) == preAliceMPT - mpt(kMAX_MP_TOKEN_AMOUNT)); - BEAST_EXPECT(mptEscrowed(env, alice, mpt) == kMAX_MP_TOKEN_AMOUNT); + BEAST_EXPECT(env.balance(alice, mpt) == preAliceMPT - mpt(kMaxMpTokenAmount)); + BEAST_EXPECT(mptEscrowed(env, alice, mpt) == kMaxMpTokenAmount); BEAST_EXPECT(env.balance(bob, mpt) == preBobMPT); BEAST_EXPECT(mptEscrowed(env, bob, mpt) == 0); BEAST_EXPECT(env.balance(gw, mpt) == outstandingMPT); - BEAST_EXPECT(issuerMPTEscrowed(env, mpt) == kMAX_MP_TOKEN_AMOUNT); + BEAST_EXPECT(issuerMPTEscrowed(env, mpt) == kMaxMpTokenAmount); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); env(escrow::finish(bob, alice, seq2), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); - BEAST_EXPECT(env.balance(alice, mpt) == preAliceMPT - mpt(kMAX_MP_TOKEN_AMOUNT)); + BEAST_EXPECT(env.balance(alice, mpt) == preAliceMPT - mpt(kMaxMpTokenAmount)); BEAST_EXPECT(mptEscrowed(env, alice, mpt) == 0); - BEAST_EXPECT(env.balance(bob, mpt) == preBobMPT + mpt(kMAX_MP_TOKEN_AMOUNT)); + BEAST_EXPECT(env.balance(bob, mpt) == preBobMPT + mpt(kMaxMpTokenAmount)); BEAST_EXPECT(mptEscrowed(env, bob, mpt) == 0); BEAST_EXPECT(env.balance(gw, mpt) == outstandingMPT); BEAST_EXPECT(issuerMPTEscrowed(env, mpt) == 0); @@ -3210,8 +3274,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const bseq = env.seq(bob); env(escrow::create(alice, alice, mpt(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 500s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 500s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -3234,8 +3298,8 @@ struct EscrowToken_test : public beast::unit_test::Suite } env(escrow::create(bob, bob, mpt(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -3303,13 +3367,13 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const aseq = env.seq(alice); auto const bseq = env.seq(bob); - env(escrow::create(alice, bob, mpt(1'000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, bob, mpt(1'000)), escrow::kFinishTime(env.now() + 1s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); env(escrow::create(bob, carol, mpt(1'000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -3426,8 +3490,8 @@ struct EscrowToken_test : public beast::unit_test::Suite BEAST_EXPECT(preEscrowed == 0); env(escrow::create(alice, gw, mpt(1'000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -3438,8 +3502,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // issuer (dest) can finish escrow env(escrow::finish(gw, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -3489,8 +3553,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); auto const delta = mpt(125); env(escrow::create(alice, bob, mpt(125)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); auto const transferRate = escrow::rate(env, alice, seq1); @@ -3502,8 +3566,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob can finish escrow env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -3545,9 +3609,9 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); auto const delta = mpt(125); env(escrow::create(alice, bob, mpt(125)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 3s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 3s), Fee(baseFee * 150)); env.close(); auto const transferRate = escrow::rate(env, alice, seq1); @@ -3590,8 +3654,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); auto const delta = mpt(125); env(escrow::create(alice, gw, mpt(125)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); auto const transferRate = escrow::rate(env, alice, seq1); @@ -3603,8 +3667,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob can finish escrow env(escrow::finish(gw, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); @@ -3645,15 +3709,15 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const delta = mpt(125); // alice can create escrow - is authorized env(escrow::create(alice, bob, mpt(100)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); // bob can finish escrow - is authorized env(escrow::finish(bob, alice, seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); } @@ -3686,9 +3750,9 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice create escrow auto seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(100)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150)); env.close(); @@ -3698,8 +3762,8 @@ struct EscrowToken_test : public beast::unit_test::Suite // bob cannot finish env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecLOCKED)); env.close(); @@ -3733,9 +3797,9 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice cannot create escrow to non issuer env(escrow::create(alice, bob, mpt(100)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150), Ter(tecNO_AUTH)); env.close(); @@ -3745,15 +3809,15 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice an create escrow to issuer auto seq = env.seq(alice); env(escrow::create(alice, gw, mpt(100)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); // gw can finish env(escrow::finish(gw, alice, seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); env.close(); } @@ -3763,9 +3827,9 @@ struct EscrowToken_test : public beast::unit_test::Suite // alice an create escrow to issuer auto seq = env.seq(alice); env(escrow::create(alice, gw, mpt(100)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150)); env.close(); @@ -3802,8 +3866,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); @@ -3819,8 +3883,8 @@ struct EscrowToken_test : public beast::unit_test::Suite mptGw.destroy({.id = mptGw.issuanceID(), .ownerCount = 1, .err = tecHAS_OBLIGATIONS}); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -3849,8 +3913,8 @@ struct EscrowToken_test : public beast::unit_test::Suite auto const seq1 = env.seq(alice); env(escrow::create(alice, bob, mpt(10)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -3864,8 +3928,8 @@ struct EscrowToken_test : public beast::unit_test::Suite {.account = alice, .flags = tfMPTUnauthorize, .err = tecHAS_OBLIGATIONS}); env(escrow::finish(bob, alice, seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -3887,6 +3951,7 @@ struct EscrowToken_test : public beast::unit_test::Suite testIOUFinishPreclaim(features); testIOUFinishDoApply(features); testIOUCancelPreclaim(features); + testIOUCancelDoApply(features); testIOUBalances(features); testIOUMetaAndOwnership(features); testIOURippleState(features); @@ -3928,6 +3993,7 @@ public: {all - featureSingleAssetVault - featureLendingProtocol, all}) { testIOUWithFeats(feats); + testIOUWithFeats(feats - fixCleanup3_2_0); testMPTWithFeats(feats); testMPTWithFeats(feats - fixTokenEscrowV1); } diff --git a/src/test/app/Escrow_test.cpp b/src/test/app/Escrow_test.cpp index 408e9c4edf..3e76524cf1 100644 --- a/src/test/app/Escrow_test.cpp +++ b/src/test/app/Escrow_test.cpp @@ -47,27 +47,27 @@ struct Escrow_test : public beast::unit_test::Suite Env env(*this, features); auto const baseFee = env.current()->fees().base; env.fund(XRP(5000), "alice", "bob"); - env(escrow::create("alice", "bob", XRP(1000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create("alice", "bob", XRP(1000)), escrow::kFinishTime(env.now() + 1s)); env.close(); auto const seq1 = env.seq("alice"); env(escrow::create("alice", "bob", XRP(1000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); env.close(); env(escrow::finish("bob", "alice", seq1), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); auto const seq2 = env.seq("alice"); env(escrow::create("alice", "bob", XRP(1000)), - escrow::kCONDITION(escrow::kCB2), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s), + escrow::kCondition(escrow::kCb2), + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s), Fee(baseFee * 150)); env.close(); env(escrow::cancel("bob", "alice", seq2), Fee(baseFee * 150)); @@ -90,7 +90,7 @@ struct Escrow_test : public beast::unit_test::Suite auto const ts = env.now() + 97s; auto const seq = env.seq("alice"); - env(escrow::create("alice", "bob", XRP(1000)), escrow::kFINISH_TIME(ts)); + env(escrow::create("alice", "bob", XRP(1000)), escrow::kFinishTime(ts)); // Advance the ledger, verifying that the finish won't complete // prematurely. @@ -112,8 +112,8 @@ struct Escrow_test : public beast::unit_test::Suite auto const seq = env.seq("alice"); env(escrow::create("alice", "bob", XRP(1000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(ts)); + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(ts)); // Advance the ledger, verifying that the cancel won't complete // prematurely. @@ -122,8 +122,8 @@ struct Escrow_test : public beast::unit_test::Suite // Verify that a finish won't work anymore. env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); @@ -144,8 +144,8 @@ struct Escrow_test : public beast::unit_test::Suite auto const seq = env.seq("alice"); env(escrow::create("alice", "bob", XRP(1000)), - escrow::kFINISH_TIME(fts), - escrow::kCANCEL_TIME(cts)); + escrow::kFinishTime(fts), + escrow::kCancelTime(cts)); // Advance the ledger, verifying that the finish and cancel won't // complete prematurely. @@ -175,8 +175,8 @@ struct Escrow_test : public beast::unit_test::Suite auto const seq = env.seq("alice"); env(escrow::create("alice", "bob", XRP(1000)), - escrow::kFINISH_TIME(fts), - escrow::kCANCEL_TIME(cts)); + escrow::kFinishTime(fts), + escrow::kCancelTime(cts)); // Advance the ledger, verifying that the finish and cancel won't // complete prematurely. @@ -219,14 +219,14 @@ struct Escrow_test : public beast::unit_test::Suite // required: env(fset(bob, asfRequireDest)); env(escrow::create(alice, bob, XRP(1000)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Ter(tecDST_TAG_NEEDED)); // set source and dest tags auto const seq = env.seq(alice); env(escrow::create(alice, bob, XRP(1000)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Stag(1), Dtag(2)); @@ -259,7 +259,7 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(XRP(5000), "bob", "george"); env(fset("george", asfDisallowXRP)); - env(escrow::create("bob", "george", XRP(10)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create("bob", "george", XRP(10)), escrow::kFinishTime(env.now() + 1s)); } } @@ -278,21 +278,21 @@ struct Escrow_test : public beast::unit_test::Suite // Creating an escrow with only a cancel time is not allowed: env(escrow::create("alice", "bob", XRP(100)), - escrow::kCANCEL_TIME(env.now() + 90s), + escrow::kCancelTime(env.now() + 90s), Fee(baseFee * 150), Ter(temMALFORMED)); - // Creating an escrow with only a cancel time and a kCONDITION is + // Creating an escrow with only a cancel time and a kCondition is // allowed: auto const seq = env.seq("alice"); env(escrow::create("alice", "bob", XRP(100)), - escrow::kCANCEL_TIME(env.now() + 90s), - escrow::kCONDITION(escrow::kCB1), + escrow::kCancelTime(env.now() + 90s), + escrow::kCondition(escrow::kCb1), Fee(baseFee * 150)); env.close(); env(escrow::finish("carol", "alice", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150)); BEAST_EXPECT(env.balance("bob") == XRP(5100)); @@ -300,9 +300,9 @@ struct Escrow_test : public beast::unit_test::Suite // allowed: auto const seqFt = env.seq("alice"); env(escrow::create("alice", "bob", XRP(100)), - escrow::kFINISH_TIME(env.now()), // Set finish time to now so that - // we can call finish immediately. - escrow::kCANCEL_TIME(env.now() + 50s), + escrow::kFinishTime(env.now()), // Set finish time to now so that + // we can call finish immediately. + escrow::kCancelTime(env.now() + 50s), Fee(baseFee * 150)); env.close(); env(escrow::finish("carol", "alice", seqFt), Fee(150 * baseFee)); @@ -324,24 +324,24 @@ struct Escrow_test : public beast::unit_test::Suite // temINVALID_FLAG env(escrow::create("alice", "bob", XRP(1000)), - escrow::kFINISH_TIME(env.now() + 5s), + escrow::kFinishTime(env.now() + 5s), Txflags(tfPassive), Ter(temINVALID_FLAG)); // Finish time is in the past env(escrow::create("alice", "bob", XRP(1000)), - escrow::kFINISH_TIME(env.now() - 5s), + escrow::kFinishTime(env.now() - 5s), Ter(tecNO_PERMISSION)); // Cancel time is in the past env(escrow::create("alice", "bob", XRP(1000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(env.now() - 5s), + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(env.now() - 5s), Ter(tecNO_PERMISSION)); // no destination account env(escrow::create("alice", "carol", XRP(1000)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Ter(tecNO_DST)); env.fund(XRP(5000), "carol"); @@ -353,43 +353,43 @@ struct Escrow_test : public beast::unit_test::Suite // set the asfAllowTrustLineLocking flag auto const txResult = withTokenEscrow ? Ter(tecNO_PERMISSION) : Ter(temBAD_AMOUNT); env(escrow::create("alice", "carol", Account("alice")["USD"](500)), - escrow::kFINISH_TIME(env.now() + 5s), + escrow::kFinishTime(env.now() + 5s), txResult); } // Sending zero or no XRP: env(escrow::create("alice", "carol", XRP(0)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Ter(temBAD_AMOUNT)); env(escrow::create("alice", "carol", XRP(-1000)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Ter(temBAD_AMOUNT)); // Fail if neither CancelAfter nor FinishAfter are specified: env(escrow::create("alice", "carol", XRP(1)), Ter(temBAD_EXPIRATION)); - // Fail if neither a FinishTime nor a kCONDITION are attached: + // Fail if neither a FinishTime nor a kCondition are attached: env(escrow::create("alice", "carol", XRP(1)), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCancelTime(env.now() + 1s), Ter(temMALFORMED)); // Fail if FinishAfter has already passed: env(escrow::create("alice", "carol", XRP(1)), - escrow::kFINISH_TIME(env.now() - 1s), + escrow::kFinishTime(env.now() - 1s), Ter(tecNO_PERMISSION)); // If both CancelAfter and FinishAfter are set, then CancelAfter must // be strictly later than FinishAfter. env(escrow::create("alice", "carol", XRP(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 10s), - escrow::kCANCEL_TIME(env.now() + 10s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 10s), + escrow::kCancelTime(env.now() + 10s), Ter(temBAD_EXPIRATION)); env(escrow::create("alice", "carol", XRP(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 10s), - escrow::kCANCEL_TIME(env.now() + 5s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 10s), + escrow::kCancelTime(env.now() + 5s), Ter(temBAD_EXPIRATION)); // Carol now requires the use of a destination tag @@ -397,14 +397,14 @@ struct Escrow_test : public beast::unit_test::Suite // missing destination tag env(escrow::create("alice", "carol", XRP(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(env.now() + 1s), Ter(tecDST_TAG_NEEDED)); // Success! env(escrow::create("alice", "carol", XRP(1)), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(env.now() + 1s), Dtag(1)); { // Fail if the sender wants to send more than he has: @@ -413,17 +413,17 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(accountReserve + accountIncrement + XRP(50), "daniel"); env(escrow::create("daniel", "bob", XRP(51)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Ter(tecUNFUNDED)); env.fund(accountReserve + accountIncrement + XRP(50), "evan"); env(escrow::create("evan", "bob", XRP(50)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Ter(tecUNFUNDED)); env.fund(accountReserve, "frank"); env(escrow::create("frank", "bob", XRP(1)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Ter(tecINSUFFICIENT_RESERVE)); } @@ -431,21 +431,21 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(XRP(5000), "hannah"); auto const seq = env.seq("hannah"); env(escrow::create("hannah", "hannah", XRP(10)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Fee(150 * baseFee)); env.close(); env(escrow::finish("hannah", "hannah", seq + 7), Fee(150 * baseFee), Ter(tecNO_TARGET)); } - { // Try to specify a kCONDITION for a non-conditional payment + { // Try to specify a kCondition for a non-conditional payment env.fund(XRP(5000), "ivan"); auto const seq = env.seq("ivan"); - env(escrow::create("ivan", "ivan", XRP(10)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create("ivan", "ivan", XRP(10)), escrow::kFinishTime(env.now() + 1s)); env.close(); env(escrow::finish("ivan", "ivan", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); } @@ -465,7 +465,7 @@ struct Escrow_test : public beast::unit_test::Suite auto const baseFee = env.current()->fees().base; env.fund(XRP(5000), "alice", "bob"); auto const seq = env.seq("alice"); - env(escrow::create("alice", "alice", XRP(1000)), escrow::kFINISH_TIME(env.now() + 5s)); + env(escrow::create("alice", "alice", XRP(1000)), escrow::kFinishTime(env.now() + 5s)); env.require(Balance("alice", XRP(4000) - drops(baseFee))); // Not enough time has elapsed for a finish and canceling isn't @@ -489,7 +489,7 @@ struct Escrow_test : public beast::unit_test::Suite auto const baseFee = env.current()->fees().base; env.fund(XRP(5000), "alice", "bob", "zelda"); auto const seq = env.seq("alice"); - env(escrow::create("alice", "bob", XRP(1000)), escrow::kFINISH_TIME(env.now() + 5s)); + env(escrow::create("alice", "bob", XRP(1000)), escrow::kFinishTime(env.now() + 5s)); env.require(Balance("alice", XRP(4000) - drops(baseFee))); // Not enough time has elapsed for a finish and canceling isn't @@ -519,7 +519,7 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); auto const seq = env.seq("alice"); - env(escrow::create("alice", "bob", XRP(1000)), escrow::kFINISH_TIME(env.now() + 5s)); + env(escrow::create("alice", "bob", XRP(1000)), escrow::kFinishTime(env.now() + 5s)); env.require(Balance("alice", XRP(4000) - drops(baseFee))); // Not enough time has elapsed for a finish and canceling isn't @@ -559,7 +559,7 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); auto const seq = env.seq("alice"); - env(escrow::create("alice", "bob", XRP(1000)), escrow::kFINISH_TIME(env.now() + 5s)); + env(escrow::create("alice", "bob", XRP(1000)), escrow::kFinishTime(env.now() + 5s)); env.require(Balance("alice", XRP(4000) - drops(baseFee))); env.close(); @@ -581,8 +581,8 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(XRP(5000), "alice", "bob"); auto const seq = env.seq("alice"); env(escrow::create("alice", "alice", XRP(1000)), - escrow::kCONDITION(escrow::kCB2), - escrow::kFINISH_TIME(env.now() + 5s)); + escrow::kCondition(escrow::kCb2), + escrow::kFinishTime(env.now() + 5s)); env.require(Balance("alice", XRP(4000) - drops(baseFee))); // Not enough time has elapsed for a finish and canceling isn't @@ -591,20 +591,20 @@ struct Escrow_test : public beast::unit_test::Suite env(escrow::cancel("bob", "alice", seq), Ter(tecNO_PERMISSION)); env(escrow::finish("alice", "alice", seq), Ter(tecNO_PERMISSION)); env(escrow::finish("alice", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB2), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb2), Fee(150 * baseFee), Ter(tecNO_PERMISSION)); env(escrow::finish("bob", "alice", seq), Ter(tecNO_PERMISSION)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB2), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb2), Fee(150 * baseFee), Ter(tecNO_PERMISSION)); env.close(); // Cancel continues to not be possible. Finish is possible but - // requires the kFULFILLMENT associated with the escrow. + // requires the kFulfillment associated with the escrow. env(escrow::cancel("alice", "alice", seq), Ter(tecNO_PERMISSION)); env(escrow::cancel("bob", "alice", seq), Ter(tecNO_PERMISSION)); env(escrow::finish("bob", "alice", seq), Ter(tecCRYPTOCONDITION_ERROR)); @@ -612,8 +612,8 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB2), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb2), Fee(150 * baseFee)); } { @@ -624,8 +624,8 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(XRP(5000), "alice", "bob"); auto const seq = env.seq("alice"); env(escrow::create("alice", "alice", XRP(1000)), - escrow::kCONDITION(escrow::kCB3), - escrow::kFINISH_TIME(env.now() + 5s)); + escrow::kCondition(escrow::kCb3), + escrow::kFinishTime(env.now() + 5s)); env.require(Balance("alice", XRP(4000) - drops(baseFee))); env.close(); @@ -639,18 +639,18 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); env(escrow::finish("alice", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB2), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb2), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB3), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(escrow::kCb3), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee), Ter(tecNO_PERMISSION)); env(escrow::finish("alice", "alice", seq), - escrow::kCONDITION(escrow::kCB3), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(escrow::kCb3), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee)); } { @@ -661,8 +661,8 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(XRP(5000), "alice", "bob", "zelda"); auto const seq = env.seq("alice"); env(escrow::create("alice", "alice", XRP(1000)), - escrow::kCONDITION(escrow::kCB3), - escrow::kFINISH_TIME(env.now() + 5s)); + escrow::kCondition(escrow::kCb3), + escrow::kFinishTime(env.now() + 5s)); env.require(Balance("alice", XRP(4000) - drops(baseFee))); env.close(); @@ -682,18 +682,18 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); env(escrow::finish("alice", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB2), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb2), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB3), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(escrow::kCb3), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee), Ter(tecNO_PERMISSION)); env(escrow::finish("zelda", "alice", seq), - escrow::kCONDITION(escrow::kCB3), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(escrow::kCb3), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee)); } } @@ -713,63 +713,63 @@ struct Escrow_test : public beast::unit_test::Suite auto const seq = env.seq("alice"); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 0); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(env.now() + 1s)); + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(env.now() + 1s)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); env.require(Balance("alice", XRP(4000) - drops(baseFee))); env.require(Balance("carol", XRP(5000))); env(escrow::cancel("bob", "alice", seq), Ter(tecNO_PERMISSION)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); - // Attempt to finish without a kFULFILLMENT + // Attempt to finish without a kFulfillment env(escrow::finish("bob", "alice", seq), Ter(tecCRYPTOCONDITION_ERROR)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); - // Attempt to finish with a kCONDITION instead of a kFULFILLMENT + // Attempt to finish with a kCondition instead of a kFulfillment env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kCB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kCb1), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kCB2), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kCb2), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kCB3), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kCb3), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); - // Attempt to finish with an incorrect kCONDITION and various + // Attempt to finish with an incorrect kCondition and various // combinations of correct and incorrect fulfillments. env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb1), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB2), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb2), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); - // Attempt to finish with the correct kCONDITION & kFULFILLMENT + // Attempt to finish with the correct kCondition & kFulfillment env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(150 * baseFee)); // SLE removed on finish @@ -780,15 +780,15 @@ struct Escrow_test : public beast::unit_test::Suite BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 0); env(escrow::cancel("bob", "carol", 1), Ter(tecNO_TARGET)); } - { // Test cancel when kCONDITION is present + { // Test cancel when kCondition is present Env env(*this, features); auto const baseFee = env.current()->fees().base; env.fund(XRP(5000), "alice", "bob", "carol"); auto const seq = env.seq("alice"); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 0); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(escrow::kCB2), - escrow::kCANCEL_TIME(env.now() + 1s)); + escrow::kCondition(escrow::kCb2), + escrow::kCancelTime(env.now() + 1s)); env.close(); env.require(Balance("alice", XRP(4000) - drops(baseFee))); // balance restored on cancel @@ -804,8 +804,8 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); auto const seq = env.seq("alice"); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(escrow::kCB3), - escrow::kCANCEL_TIME(env.now() + 1s)); + escrow::kCondition(escrow::kCb3), + escrow::kCancelTime(env.now() + 1s)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); // cancel fails before expiration env(escrow::cancel("bob", "alice", seq), Ter(tecNO_PERMISSION)); @@ -813,8 +813,8 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); // finish fails after expiration env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB3), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(escrow::kCb3), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee), Ter(tecNO_PERMISSION)); BEAST_EXPECT((*env.le("alice"))[sfOwnerCount] == 1); @@ -825,8 +825,8 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(XRP(5000), "alice", "bob", "carol"); std::vector v; - v.resize(escrow::kCB1.size() + 2, 0x78); - std::memcpy(v.data() + 1, escrow::kCB1.data(), escrow::kCB1.size()); + v.resize(escrow::kCb1.size() + 2, 0x78); + std::memcpy(v.data() + 1, escrow::kCb1.data(), escrow::kCb1.size()); auto const p = v.data(); auto const s = v.size(); @@ -834,45 +834,45 @@ struct Escrow_test : public beast::unit_test::Suite auto const ts = env.now() + 1s; // All these are expected to fail, because the - // kCONDITION we pass in is malformed in some way + // kCondition we pass in is malformed in some way env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p, s}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p, s}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p, s - 1}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p, s - 1}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p, s - 2}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p, s - 2}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p + 1, s - 1}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p + 1, s - 1}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p + 1, s - 3}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p + 1, s - 3}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p + 2, s - 2}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p + 2, s - 2}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p + 2, s - 3}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p + 2, s - 3}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); auto const seq = env.seq("alice"); auto const baseFee = env.current()->fees().base; env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{p + 1, s - 2}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{p + 1, s - 2}), + escrow::kCancelTime(ts), Fee(10 * baseFee)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(150 * baseFee)); env.require(Balance("alice", XRP(4000) - drops(10 * baseFee))); env.require(Balance("bob", XRP(5000) - drops(150 * baseFee))); @@ -883,15 +883,15 @@ struct Escrow_test : public beast::unit_test::Suite env.fund(XRP(5000), "alice", "bob", "carol"); std::vector cv; - cv.resize(escrow::kCB2.size() + 2, 0x78); - std::memcpy(cv.data() + 1, escrow::kCB2.data(), escrow::kCB2.size()); + cv.resize(escrow::kCb2.size() + 2, 0x78); + std::memcpy(cv.data() + 1, escrow::kCb2.data(), escrow::kCb2.size()); auto const cp = cv.data(); auto const cs = cv.size(); std::vector fv; - fv.resize(escrow::kFB2.size() + 2, 0x13); - std::memcpy(fv.data() + 1, escrow::kFB2.data(), escrow::kFB2.size()); + fv.resize(escrow::kFb2.size() + 2, 0x13); + std::memcpy(fv.data() + 1, escrow::kFb2.data(), escrow::kFb2.size()); auto const fp = fv.data(); auto const fs = fv.size(); @@ -899,181 +899,181 @@ struct Escrow_test : public beast::unit_test::Suite auto const ts = env.now() + 1s; // All these are expected to fail, because the - // kCONDITION we pass in is malformed in some way + // kCondition we pass in is malformed in some way env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp, cs}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp, cs}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp, cs - 1}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp, cs - 1}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp, cs - 2}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp, cs - 2}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp + 1, cs - 1}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp + 1, cs - 1}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp + 1, cs - 3}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp + 1, cs - 3}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp + 2, cs - 2}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp + 2, cs - 2}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp + 2, cs - 3}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp + 2, cs - 3}), + escrow::kCancelTime(ts), Ter(temMALFORMED)); auto const seq = env.seq("alice"); auto const baseFee = env.current()->fees().base; env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kCancelTime(ts), Fee(10 * baseFee)); // Now, try to fulfill using the same sequence of // malformed conditions. env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp, cs}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp, cs}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp, cs - 1}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp, cs - 1}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp, cs - 2}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp, cs - 2}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 1}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp + 1, cs - 1}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 3}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp + 1, cs - 3}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 2, cs - 2}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp + 2, cs - 2}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 2, cs - 3}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp + 2, cs - 3}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); - // Now, using the correct kCONDITION, try malformed fulfillments: + // Now, using the correct kCondition, try malformed fulfillments: env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp, fs}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp, fs}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp, fs - 1}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp, fs - 1}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp, fs - 2}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp, fs - 2}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp + 1, fs - 1}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp + 1, fs - 1}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp + 1, fs - 3}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp + 1, fs - 3}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp + 1, fs - 3}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp + 1, fs - 3}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp + 2, fs - 2}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp + 2, fs - 2}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{cp + 1, cs - 2}), - escrow::kFULFILLMENT(Slice{fp + 2, fs - 3}), + escrow::kCondition(Slice{cp + 1, cs - 2}), + escrow::kFulfillment(Slice{fp + 2, fs - 3}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); // Now try for the right one env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB2), - escrow::kFULFILLMENT(escrow::kFB2), + escrow::kCondition(escrow::kCb2), + escrow::kFulfillment(escrow::kFb2), Fee(150 * baseFee)); env.require(Balance("alice", XRP(4000) - drops(10 * baseFee))); env.require(Balance("carol", XRP(6000))); } - { // Test empty kCONDITION during creation and - // empty kCONDITION & kFULFILLMENT during finish + { // Test empty kCondition during creation and + // empty kCondition & kFulfillment during finish Env env(*this, features); env.fund(XRP(5000), "alice", "bob", "carol"); env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(Slice{}), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCondition(Slice{}), + escrow::kCancelTime(env.now() + 1s), Ter(temMALFORMED)); auto const seq = env.seq("alice"); auto const baseFee = env.current()->fees().base; env(escrow::create("alice", "carol", XRP(1000)), - escrow::kCONDITION(escrow::kCB3), - escrow::kCANCEL_TIME(env.now() + 1s)); + escrow::kCondition(escrow::kCb3), + escrow::kCancelTime(env.now() + 1s)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{}), - escrow::kFULFILLMENT(Slice{}), + escrow::kCondition(Slice{}), + escrow::kFulfillment(Slice{}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB3), - escrow::kFULFILLMENT(Slice{}), + escrow::kCondition(escrow::kCb3), + escrow::kFulfillment(Slice{}), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(Slice{}), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(Slice{}), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee), Ter(tecCRYPTOCONDITION_ERROR)); // Assemble finish that is missing the Condition or the Fulfillment // since either both must be present, or neither can: env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB3), + escrow::kCondition(escrow::kCb3), Ter(temMALFORMED)); env(escrow::finish("bob", "alice", seq), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kFulfillment(escrow::kFb3), Ter(temMALFORMED)); // Now finish it. env(escrow::finish("bob", "alice", seq), - escrow::kCONDITION(escrow::kCB3), - escrow::kFULFILLMENT(escrow::kFB3), + escrow::kCondition(escrow::kCb3), + escrow::kFulfillment(escrow::kFb3), Fee(150 * baseFee)); env.require(Balance("carol", XRP(6000))); env.require(Balance("alice", XRP(4000) - drops(baseFee))); } - { // Test a kCONDITION other than PreimageSha256, which + { // Test a kCondition other than PreimageSha256, which // would require a separate amendment Env env(*this, features); env.fund(XRP(5000), "alice", "bob"); @@ -1087,8 +1087,8 @@ struct Escrow_test : public beast::unit_test::Suite // FIXME: this transaction should, eventually, return temDISABLED // instead of temMALFORMED. env(escrow::create("alice", "bob", XRP(1000)), - escrow::kCONDITION(cb), - escrow::kCANCEL_TIME(env.now() + 1s), + escrow::kCondition(cb), + escrow::kCancelTime(env.now() + 1s), Ter(temMALFORMED)); } } @@ -1112,8 +1112,8 @@ struct Escrow_test : public beast::unit_test::Suite auto const bseq = env.seq(bruce); env(escrow::create(alice, alice, XRP(1000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 500s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 500s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -1129,8 +1129,8 @@ struct Escrow_test : public beast::unit_test::Suite } env(escrow::create(bruce, bruce, XRP(1000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -1187,13 +1187,13 @@ struct Escrow_test : public beast::unit_test::Suite auto const aseq = env.seq(alice); auto const bseq = env.seq(bruce); - env(escrow::create(alice, bruce, XRP(1000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, bruce, XRP(1000)), escrow::kFinishTime(env.now() + 1s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); env(escrow::create(bruce, carol, XRP(1000)), - escrow::kFINISH_TIME(env.now() + 1s), - escrow::kCANCEL_TIME(env.now() + 2s)); + escrow::kFinishTime(env.now() + 1s), + escrow::kCancelTime(env.now() + 2s)); BEAST_EXPECT( (*env.meta())[sfTransactionResult] == static_cast(tesSUCCESS)); env.close(5s); @@ -1296,7 +1296,7 @@ struct Escrow_test : public beast::unit_test::Suite { auto const jtx = env.jt( escrow::create("alice", "carol", XRP(1000)), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kFinishTime(env.now() + 1s), Seq(1), Fee(baseFee)); auto const pf = @@ -1352,12 +1352,12 @@ struct Escrow_test : public beast::unit_test::Suite // bob creates a bunch of tickets because he will be burning // through them with tec transactions. Just because we can // we'll use them up starting from largest and going smaller. - constexpr static std::uint32_t kBOB_TICKET_COUNT{20}; - env(ticket::create(bob, kBOB_TICKET_COUNT)); + static constexpr std::uint32_t kBobTicketCount{20}; + env(ticket::create(bob, kBobTicketCount)); env.close(); std::uint32_t bobTicket{env.seq(bob)}; env.require(tickets(alice, 1)); - env.require(tickets(bob, kBOB_TICKET_COUNT)); + env.require(tickets(bob, kBobTicketCount)); // Note that from here on all transactions use tickets. No account // root sequences should change. @@ -1369,11 +1369,11 @@ struct Escrow_test : public beast::unit_test::Suite std::uint32_t const escrowSeq = aliceTicket; env(escrow::create(alice, bob, XRP(1000)), - escrow::kFINISH_TIME(ts), + escrow::kFinishTime(ts), ticket::Use(aliceTicket)); BEAST_EXPECT(env.seq(alice) == aliceRootSeq); env.require(tickets(alice, 0)); - env.require(tickets(bob, kBOB_TICKET_COUNT)); + env.require(tickets(bob, kBobTicketCount)); // Advance the ledger, verifying that the finish won't complete // prematurely. Note that each tec consumes one of bob's tickets. @@ -1412,12 +1412,12 @@ struct Escrow_test : public beast::unit_test::Suite // bob creates a bunch of tickets because he will be burning // through them with tec transactions. - constexpr std::uint32_t kBOB_TICKET_COUNT{20}; + static constexpr std::uint32_t kBobTicketCount{20}; std::uint32_t bobTicket{env.seq(bob) + 1}; - env(ticket::create(bob, kBOB_TICKET_COUNT)); + env(ticket::create(bob, kBobTicketCount)); env.close(); env.require(tickets(alice, 1)); - env.require(tickets(bob, kBOB_TICKET_COUNT)); + env.require(tickets(bob, kBobTicketCount)); // Note that from here on all transactions use tickets. No account // root sequences should change. @@ -1429,12 +1429,12 @@ struct Escrow_test : public beast::unit_test::Suite std::uint32_t const escrowSeq = aliceTicket; env(escrow::create(alice, bob, XRP(1000)), - escrow::kCONDITION(escrow::kCB1), - escrow::kCANCEL_TIME(ts), + escrow::kCondition(escrow::kCb1), + escrow::kCancelTime(ts), ticket::Use(aliceTicket)); BEAST_EXPECT(env.seq(alice) == aliceRootSeq); env.require(tickets(alice, 0)); - env.require(tickets(bob, kBOB_TICKET_COUNT)); + env.require(tickets(bob, kBobTicketCount)); // Advance the ledger, verifying that the cancel won't complete // prematurely. @@ -1449,8 +1449,8 @@ struct Escrow_test : public beast::unit_test::Suite // Verify that a finish won't work anymore. env(escrow::finish(bob, alice, escrowSeq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(150 * baseFee), ticket::Use(bobTicket++), Ter(tecNO_PERMISSION)); @@ -1491,7 +1491,7 @@ struct Escrow_test : public beast::unit_test::Suite env.close(); auto const seq = env.seq(alice); - env(escrow::create(alice, bob, XRP(1000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, bob, XRP(1000)), escrow::kFinishTime(env.now() + 1s)); env.close(); env(fset(bob, asfDepositAuth)); @@ -1517,7 +1517,7 @@ struct Escrow_test : public beast::unit_test::Suite std::string const credIdx = jv[jss::result][jss::index].asString(); auto const seq = env.seq(alice); - env(escrow::create(alice, bob, XRP(1000)), escrow::kFINISH_TIME(env.now() + 50s)); + env(escrow::create(alice, bob, XRP(1000)), escrow::kFinishTime(env.now() + 50s)); env.close(); // Bob require pre-authorization @@ -1570,7 +1570,7 @@ struct Escrow_test : public beast::unit_test::Suite std::string const credIdx = jv[jss::result][jss::index].asString(); auto const seq = env.seq(alice); - env(escrow::create(alice, bob, XRP(1000)), escrow::kFINISH_TIME(env.now() + 50s)); + env(escrow::create(alice, bob, XRP(1000)), escrow::kFinishTime(env.now() + 50s)); // time advance env.close(); env.close(); @@ -1595,7 +1595,7 @@ struct Escrow_test : public beast::unit_test::Suite .asString(); auto const seq = env.seq(alice); - env(escrow::create(alice, bob, XRP(1000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, bob, XRP(1000)), escrow::kFinishTime(env.now() + 1s)); env.close(); // Bob require pre-authorization diff --git a/src/test/app/FeeVote_test.cpp b/src/test/app/FeeVote_test.cpp index 8300b458b6..22e8322bb5 100644 --- a/src/test/app/FeeVote_test.cpp +++ b/src/test/app/FeeVote_test.cpp @@ -213,18 +213,18 @@ class FeeVote_test : public beast::unit_test::Suite // defaults Section const config; auto setup = setupFeeVote(config); - BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee); - BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve); - BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve); + BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee); + BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve); + BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve); } { Section config; config.append( {"reference_fee = 50", "account_reserve = 1234567", "owner_reserve = 1234"}); auto setup = setupFeeVote(config); - BEAST_EXPECT(setup.reference_fee == 50); - BEAST_EXPECT(setup.account_reserve == 1234567); - BEAST_EXPECT(setup.owner_reserve == 1234); + BEAST_EXPECT(setup.referenceFee == 50); + BEAST_EXPECT(setup.accountReserve == 1234567); + BEAST_EXPECT(setup.ownerReserve == 1234); } { Section config; @@ -232,9 +232,9 @@ class FeeVote_test : public beast::unit_test::Suite {"reference_fee = blah", "account_reserve = yada", "owner_reserve = foo"}); // Illegal values are ignored, and the defaults left unchanged auto setup = setupFeeVote(config); - BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee); - BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve); - BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve); + BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee); + BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve); + BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve); } { Section config; @@ -242,9 +242,9 @@ class FeeVote_test : public beast::unit_test::Suite {"reference_fee = -50", "account_reserve = -1234567", "owner_reserve = -1234"}); // Illegal values are ignored, and the defaults left unchanged auto setup = setupFeeVote(config); - BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee); - BEAST_EXPECT(setup.account_reserve == static_cast(-1234567)); - BEAST_EXPECT(setup.owner_reserve == static_cast(-1234)); + BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee); + BEAST_EXPECT(setup.accountReserve == static_cast(-1234567)); + BEAST_EXPECT(setup.ownerReserve == static_cast(-1234)); } { auto const big64 = std::to_string( @@ -256,9 +256,9 @@ class FeeVote_test : public beast::unit_test::Suite "owner_reserve = " + big64}); // Illegal values are ignored, and the defaults left unchanged auto setup = setupFeeVote(config); - BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee); - BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve); - BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve); + BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee); + BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve); + BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve); } } @@ -271,9 +271,9 @@ class FeeVote_test : public beast::unit_test::Suite { jtx::Env env(*this, jtx::testableAmendments() - featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -301,9 +301,9 @@ class FeeVote_test : public beast::unit_test::Suite { jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -334,9 +334,9 @@ class FeeVote_test : public beast::unit_test::Suite { jtx::Env env(*this, jtx::testableAmendments() - featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -356,9 +356,9 @@ class FeeVote_test : public beast::unit_test::Suite { jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -383,9 +383,9 @@ class FeeVote_test : public beast::unit_test::Suite jtx::Env env(*this, jtx::testableAmendments()); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -422,9 +422,9 @@ class FeeVote_test : public beast::unit_test::Suite jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -470,9 +470,9 @@ class FeeVote_test : public beast::unit_test::Suite jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -501,9 +501,9 @@ class FeeVote_test : public beast::unit_test::Suite jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -547,9 +547,9 @@ class FeeVote_test : public beast::unit_test::Suite jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -578,9 +578,9 @@ class FeeVote_test : public beast::unit_test::Suite using namespace jtx; FeeSetup setup; - setup.reference_fee = 42; - setup.account_reserve = 1234567; - setup.owner_reserve = 7654321; + setup.referenceFee = 42; + setup.accountReserve = 1234567; + setup.ownerReserve = 7654321; // Test with XRPFees enabled { @@ -588,9 +588,9 @@ class FeeVote_test : public beast::unit_test::Suite auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote")); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -609,7 +609,7 @@ class FeeVote_test : public beast::unit_test::Suite feeVote->doValidation(currentFees, ledger->rules(), *val); BEAST_EXPECT(val->isFieldPresent(sfBaseFeeDrops)); - BEAST_EXPECT(val->getFieldAmount(sfBaseFeeDrops) == XRPAmount(setup.reference_fee)); + BEAST_EXPECT(val->getFieldAmount(sfBaseFeeDrops) == XRPAmount(setup.referenceFee)); } // Test with XRPFees disabled (legacy format) @@ -618,9 +618,9 @@ class FeeVote_test : public beast::unit_test::Suite auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote")); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -638,7 +638,7 @@ class FeeVote_test : public beast::unit_test::Suite // In legacy mode, should vote using legacy fields BEAST_EXPECT(val->isFieldPresent(sfBaseFee)); - BEAST_EXPECT(val->getFieldU64(sfBaseFee) == setup.reference_fee); + BEAST_EXPECT(val->getFieldU64(sfBaseFee) == setup.referenceFee); } } @@ -650,9 +650,9 @@ class FeeVote_test : public beast::unit_test::Suite using namespace jtx; FeeSetup setup; - setup.reference_fee = 42; - setup.account_reserve = 1234567; - setup.owner_reserve = 7654321; + setup.referenceFee = 42; + setup.accountReserve = 1234567; + setup.ownerReserve = 7654321; Env env(*this, testableAmendments() | featureXRPFees); @@ -663,9 +663,9 @@ class FeeVote_test : public beast::unit_test::Suite auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote")); auto ledger = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -689,9 +689,9 @@ class FeeVote_test : public beast::unit_test::Suite env.app().getTimeKeeper().now(), pub, sec, calcNodeID(pub), [&](STValidation& v) { v.setFieldU32(sfLedgerSequence, ledger->seq()); // Vote for different fees than current - v.setFieldAmount(sfBaseFeeDrops, XRPAmount{setup.reference_fee}); - v.setFieldAmount(sfReserveBaseDrops, XRPAmount{setup.account_reserve}); - v.setFieldAmount(sfReserveIncrementDrops, XRPAmount{setup.owner_reserve}); + v.setFieldAmount(sfBaseFeeDrops, XRPAmount{setup.referenceFee}); + v.setFieldAmount(sfReserveBaseDrops, XRPAmount{setup.accountReserve}); + v.setFieldAmount(sfReserveIncrementDrops, XRPAmount{setup.ownerReserve}); }); if ((i % 2) != 0) val->setTrusted(); @@ -723,10 +723,10 @@ class FeeVote_test : public beast::unit_test::Suite BEAST_EXPECT(!feeTx.isFieldPresent(sfReferenceFeeUnits)); // Check the values - BEAST_EXPECT(feeTx.getFieldAmount(sfBaseFeeDrops) == XRPAmount{setup.reference_fee}); - BEAST_EXPECT(feeTx.getFieldAmount(sfReserveBaseDrops) == XRPAmount{setup.account_reserve}); + BEAST_EXPECT(feeTx.getFieldAmount(sfBaseFeeDrops) == XRPAmount{setup.referenceFee}); + BEAST_EXPECT(feeTx.getFieldAmount(sfReserveBaseDrops) == XRPAmount{setup.accountReserve}); BEAST_EXPECT( - feeTx.getFieldAmount(sfReserveIncrementDrops) == XRPAmount{setup.owner_reserve}); + feeTx.getFieldAmount(sfReserveIncrementDrops) == XRPAmount{setup.ownerReserve}); } void diff --git a/src/test/app/FixNFTokenPageLinks_test.cpp b/src/test/app/FixNFTokenPageLinks_test.cpp index f77d924c94..cfe2fd1808 100644 --- a/src/test/app/FixNFTokenPageLinks_test.cpp +++ b/src/test/app/FixNFTokenPageLinks_test.cpp @@ -173,6 +173,13 @@ class FixNFTokenPageLinks_test : public beast::unit_test::Suite tx.removeMember(sfOwner.jsonName); env(tx, Fee(linkFixFee), Ter(temINVALID)); } + { + // NFTokenPageLink fixes require sfOwner and reject fields that + // belong to other LedgerStateFix types. + json::Value tx = ledgerStateFix::nftPageLinks(alice, alice); + tx[sfBookDirectory.jsonName] = to_string(uint256{1}); + env(tx, Fee(linkFixFee), Ter(temINVALID)); + } { // Invalid LedgerFixType codes. json::Value tx = ledgerStateFix::nftPageLinks(alice, alice); diff --git a/src/test/app/FlowMPT_test.cpp b/src/test/app/FlowMPT_test.cpp index 9bb91755c8..e1d6f512d2 100644 --- a/src/test/app/FlowMPT_test.cpp +++ b/src/test/app/FlowMPT_test.cpp @@ -1774,8 +1774,7 @@ struct FlowMPT_test : public beast::unit_test::Suite BEAST_EXPECT(env.balance(alice, usd) == usd(0)); BEAST_EXPECT(env.balance(carol, usd) == usd(0)); BEAST_EXPECT(env.balance(bob, usd) == usd(100 - d.expBobSellUSD)); - BEAST_EXPECT( - env.balance(gw) == XRPAmount{d.expGwXRP * kDROPS_PER_XRP - baseFee * 9}); + BEAST_EXPECT(env.balance(gw) == XRPAmount{d.expGwXRP * kDropsPerXrp - baseFee * 9}); BEAST_EXPECT(expectOffers(env, john, 0)); BEAST_EXPECT(expectOffers(env, gw, d.expOffersGw)); BEAST_EXPECT(expectOffers(env, dan, d.expOffersDan())); @@ -1901,8 +1900,7 @@ struct FlowMPT_test : public beast::unit_test::Suite BEAST_EXPECT(env.balance(bob, usd) == usd(d.expBobBuyUSD)); BEAST_EXPECT(env.balance(ed) == XRP(d.dstExpectXRP)); BEAST_EXPECT(env.balance(gw, usd) == usd(-d.outstandingUSD)); - BEAST_EXPECT( - env.balance(gw) == XRPAmount{d.expGwXRP * kDROPS_PER_XRP - baseFee * 3}); + BEAST_EXPECT(env.balance(gw) == XRPAmount{d.expGwXRP * kDropsPerXrp - baseFee * 3}); BEAST_EXPECT(expectOffers(env, carol, 0)); BEAST_EXPECT(expectOffers(env, bob, d.expOffersBob())); BEAST_EXPECT(expectOffers(env, gw, d.expOffersGw)); @@ -2007,7 +2005,7 @@ struct FlowMPT_test : public beast::unit_test::Suite auto const baseFee = env.current()->fees().base.drops(); BEAST_EXPECT( - env.balance(alice) == XRPAmount{d.expAliceXRP * kDROPS_PER_XRP - baseFee}); + env.balance(alice) == XRPAmount{d.expAliceXRP * kDropsPerXrp - baseFee}); BEAST_EXPECT(env.balance(carol, usd) == usd(0)); BEAST_EXPECT(env.balance(bob, usd) == usd(100 - d.expBobSellUSD)); BEAST_EXPECT(env.balance(ed, usd) == usd(d.dstExpectUSD)); @@ -2015,7 +2013,7 @@ struct FlowMPT_test : public beast::unit_test::Suite BEAST_EXPECT( env.balance(gw) == XRPAmount{ - d.expGwXRP * kDROPS_PER_XRP - baseFee * (4 + (d.initDst != 0 ? 1 : 0))}); + d.expGwXRP * kDropsPerXrp - baseFee * (4 + (d.initDst != 0 ? 1 : 0))}); BEAST_EXPECT(expectOffers(env, carol, 0)); BEAST_EXPECT(expectOffers(env, bob, d.expOffersBob())); BEAST_EXPECT(expectOffers(env, gw, d.expOffersGw)); 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/GRPCServerTLS_test.cpp b/src/test/app/GRPCServerTLS_test.cpp index 6dbf335b6c..c7156fb3a2 100644 --- a/src/test/app/GRPCServerTLS_test.cpp +++ b/src/test/app/GRPCServerTLS_test.cpp @@ -27,7 +27,7 @@ namespace { -constexpr std::string_view kCA_CERT_CONTENT = +constexpr std::string_view kCaCertContent = "-----BEGIN CERTIFICATE-----\n" "MIIFhjCCA26gAwIBAgIJAL9P70zX30oiMA0GCSqGSIb3DQEBCwUAMFcxCzAJBgNV\n" "BAYTAlVTMQ0wCwYDVQQIDARUZXN0MQ0wCwYDVQQHDARUZXN0MRgwFgYDVQQKDA9S\n" @@ -61,7 +61,7 @@ constexpr std::string_view kCA_CERT_CONTENT = "fAbAYqu0rfMFHUYjzIVnu8WRCC56qYHO5tU=\n" "-----END CERTIFICATE-----\n"; -constexpr std::string_view kSERVER_CERT_CONTENT = +constexpr std::string_view kServerCertContent = "-----BEGIN CERTIFICATE-----\n" "MIIFizCCA3OgAwIBAgIJAIErcpMflkrRMA0GCSqGSIb3DQEBCwUAMFcxCzAJBgNV\n" "BAYTAlVTMQ0wCwYDVQQIDARUZXN0MQ0wCwYDVQQHDARUZXN0MRgwFgYDVQQKDA9S\n" @@ -95,7 +95,7 @@ constexpr std::string_view kSERVER_CERT_CONTENT = "YSyd81wvumIpP+I7BDkQLgTb+NzMmoBIjRg3aVvXSg==\n" "-----END CERTIFICATE-----\n"; -constexpr std::string_view kSERVER_KEY_CONTENT = +constexpr std::string_view kServerKeyContent = "-----BEGIN PRIVATE KEY-----\n" "MIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQCv+Lj9LJfPuSOE\n" "yZqTn2gmG5tJt02ywnuIQet7N5tduxnNs50yXQ00Jeb40dth0HwI5I+AsEVNPIG3\n" @@ -149,7 +149,7 @@ constexpr std::string_view kSERVER_KEY_CONTENT = "S/RYUSUkZ4VvqFUfo7wT8x18urb87w==\n" "-----END PRIVATE KEY-----\n"; -constexpr std::string_view kCLIENT_CERT_CONTENT = +constexpr std::string_view kClientCertContent = "-----BEGIN CERTIFICATE-----\n" "MIIFeDCCA2CgAwIBAgIJAIErcpMflkrSMA0GCSqGSIb3DQEBCwUAMFcxCzAJBgNV\n" "BAYTAlVTMQ0wCwYDVQQIDARUZXN0MQ0wCwYDVQQHDARUZXN0MRgwFgYDVQQKDA9S\n" @@ -183,7 +183,7 @@ constexpr std::string_view kCLIENT_CERT_CONTENT = "cTe8jkzRqYdUfAoV\n" "-----END CERTIFICATE-----\n"; -constexpr std::string_view kCLIENT_KEY_CONTENT = +constexpr std::string_view kClientKeyContent = "-----BEGIN PRIVATE KEY-----\n" "MIIJQwIBADANBgkqhkiG9w0BAQEFAASCCS0wggkpAgEAAoICAQDPQHttw3TLjOqY\n" "S3VkLF3KMRaP2ZtO6A1mXfTbqbKvD41Fazf/cM/v9lPMAlRd2SEY3MeE8KVddKJw\n" @@ -246,26 +246,26 @@ constexpr std::string_view kCLIENT_KEY_CONTENT = class TemporaryTLSCertificates { public: - static constexpr std::string_view kCA_CERT_FILENAME = "ca.pem"; - static constexpr std::string_view kSERVER_CERT_FILENAME = "server_cert.pem"; - static constexpr std::string_view kSERVER_KEY_FILENAME = "server_key.pem"; - static constexpr std::string_view kCLIENT_CERT_FILENAME = "client_cert.pem"; - static constexpr std::string_view kCLIENT_KEY_FILENAME = "client_key.pem"; - static constexpr std::string_view kCERTS_DIR_PREFIX = "grpc_tls_test_"; + static constexpr std::string_view kCaCertFilename = "ca.pem"; + static constexpr std::string_view kServerCertFilename = "server_cert.pem"; + static constexpr std::string_view kServerKeyFilename = "server_key.pem"; + static constexpr std::string_view kClientCertFilename = "client_cert.pem"; + static constexpr std::string_view kClientKeyFilename = "client_key.pem"; + static constexpr std::string_view kCertsDirPrefix = "grpc_tls_test_"; TemporaryTLSCertificates() { auto tmpDir = std::filesystem::temp_directory_path(); auto uniqueDirName = - boost::filesystem::unique_path(std::string(kCERTS_DIR_PREFIX) + "%%%%%%%%"); + boost::filesystem::unique_path(std::string(kCertsDirPrefix) + "%%%%%%%%"); tempDir_ = tmpDir / uniqueDirName.string(); std::filesystem::create_directories(tempDir_); - writeFile(tempDir_ / kCA_CERT_FILENAME, kCA_CERT_CONTENT); - writeFile(tempDir_ / kSERVER_CERT_FILENAME, kSERVER_CERT_CONTENT); - writeFile(tempDir_ / kSERVER_KEY_FILENAME, kSERVER_KEY_CONTENT); - writeFile(tempDir_ / kCLIENT_CERT_FILENAME, kCLIENT_CERT_CONTENT); - writeFile(tempDir_ / kCLIENT_KEY_FILENAME, kCLIENT_KEY_CONTENT); + writeFile(tempDir_ / kCaCertFilename, kCaCertContent); + writeFile(tempDir_ / kServerCertFilename, kServerCertContent); + writeFile(tempDir_ / kServerKeyFilename, kServerKeyContent); + writeFile(tempDir_ / kClientCertFilename, kClientCertContent); + writeFile(tempDir_ / kClientKeyFilename, kClientKeyContent); } virtual ~TemporaryTLSCertificates() @@ -284,31 +284,31 @@ public: [[nodiscard]] std::filesystem::path getCACertPath() const { - return tempDir_ / kCA_CERT_FILENAME; + return tempDir_ / kCaCertFilename; } [[nodiscard]] std::filesystem::path getServerCertPath() const { - return tempDir_ / kSERVER_CERT_FILENAME; + return tempDir_ / kServerCertFilename; } [[nodiscard]] std::filesystem::path getServerKeyPath() const { - return tempDir_ / kSERVER_KEY_FILENAME; + return tempDir_ / kServerKeyFilename; } [[nodiscard]] std::filesystem::path getClientCertPath() const { - return tempDir_ / kCLIENT_CERT_FILENAME; + return tempDir_ / kClientCertFilename; } [[nodiscard]] std::filesystem::path getClientKeyPath() const { - return tempDir_ / kCLIENT_KEY_FILENAME; + return tempDir_ / kClientKeyFilename; } [[nodiscard]] std::filesystem::path @@ -409,7 +409,7 @@ public: // Test 2: TLS client with server CA should succeed grpc::SslCredentialsOptions sslOpts; - sslOpts.pem_root_certs = std::string(kCA_CERT_CONTENT); + sslOpts.pem_root_certs = std::string(kCaCertContent); auto tlsStub = org::xrpl::rpc::v1::XRPLedgerAPIService::NewStub( grpc::CreateChannel(serverAddress, grpc::SslCredentials(sslOpts))); BEAST_EXPECT(makeTestGRPCCall(tlsStub)); @@ -441,16 +441,16 @@ public: // Test 1: TLS client WITHOUT client certificate should FAIL (mTLS requires client cert) grpc::SslCredentialsOptions sslOptsNoClient; - sslOptsNoClient.pem_root_certs = std::string(kCA_CERT_CONTENT); + sslOptsNoClient.pem_root_certs = std::string(kCaCertContent); auto tlsStubNoClient = org::xrpl::rpc::v1::XRPLedgerAPIService::NewStub( grpc::CreateChannel(serverAddress, grpc::SslCredentials(sslOptsNoClient))); BEAST_EXPECT(!makeTestGRPCCall(tlsStubNoClient)); // Test 2: TLS client WITH client certificate should succeed grpc::SslCredentialsOptions sslOptsWithClient; - sslOptsWithClient.pem_root_certs = std::string(kCA_CERT_CONTENT); - sslOptsWithClient.pem_cert_chain = std::string(kCLIENT_CERT_CONTENT); - sslOptsWithClient.pem_private_key = std::string(kCLIENT_KEY_CONTENT); + sslOptsWithClient.pem_root_certs = std::string(kCaCertContent); + sslOptsWithClient.pem_cert_chain = std::string(kClientCertContent); + sslOptsWithClient.pem_private_key = std::string(kClientKeyContent); auto tlsStubWithClient = org::xrpl::rpc::v1::XRPLedgerAPIService::NewStub( grpc::CreateChannel(serverAddress, grpc::SslCredentials(sslOptsWithClient))); BEAST_EXPECT(makeTestGRPCCall(tlsStubWithClient)); @@ -665,7 +665,7 @@ public: // Test: TLS client should be able to connect (no client cert required) grpc::SslCredentialsOptions sslOpts; - sslOpts.pem_root_certs = std::string(kCA_CERT_CONTENT); + sslOpts.pem_root_certs = std::string(kCaCertContent); auto tlsStub = org::xrpl::rpc::v1::XRPLedgerAPIService::NewStub( grpc::CreateChannel(serverAddress, grpc::SslCredentials(sslOpts))); BEAST_EXPECT(makeTestGRPCCall(tlsStub)); @@ -819,16 +819,16 @@ public: // Test 1: TLS client WITHOUT client certificate should FAIL (mTLS requires client cert) grpc::SslCredentialsOptions sslOptsNoClient; - sslOptsNoClient.pem_root_certs = std::string(kCA_CERT_CONTENT); + sslOptsNoClient.pem_root_certs = std::string(kCaCertContent); auto tlsStubNoClient = org::xrpl::rpc::v1::XRPLedgerAPIService::NewStub( grpc::CreateChannel(serverAddress, grpc::SslCredentials(sslOptsNoClient))); BEAST_EXPECT(!makeTestGRPCCall(tlsStubNoClient)); // Test 2: TLS client WITH client certificate should succeed grpc::SslCredentialsOptions sslOptsWithClient; - sslOptsWithClient.pem_root_certs = std::string(kCA_CERT_CONTENT); - sslOptsWithClient.pem_cert_chain = std::string(kCLIENT_CERT_CONTENT); - sslOptsWithClient.pem_private_key = std::string(kCLIENT_KEY_CONTENT); + sslOptsWithClient.pem_root_certs = std::string(kCaCertContent); + sslOptsWithClient.pem_cert_chain = std::string(kClientCertContent); + sslOptsWithClient.pem_private_key = std::string(kClientKeyContent); auto tlsStubWithClient = org::xrpl::rpc::v1::XRPLedgerAPIService::NewStub( grpc::CreateChannel(serverAddress, grpc::SslCredentials(sslOptsWithClient))); BEAST_EXPECT(makeTestGRPCCall(tlsStubWithClient)); diff --git a/src/test/app/Invariants_test.cpp b/src/test/app/Invariants_test.cpp index 965414553f..c8a6e813de 100644 --- a/src/test/app/Invariants_test.cpp +++ b/src/test/app/Invariants_test.cpp @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -50,6 +51,7 @@ #include #include #include +#include #include #include @@ -94,7 +96,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,13 +178,13 @@ 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}; // Invariants normally run in the Transaction's "apply" (operator()) context, and can always // access global Rules. - CurrentTransactionRulesGuard const rg(ov.rules()); + CurrentTransactionRulesGuard const rulesGuard(ov.rules()); BEAST_EXPECT(precheck(a1, a2, ac)); @@ -255,7 +257,7 @@ class Invariants_test : public beast::unit_test::Suite // Clear the balance so the "account deletion left behind a // non-zero balance" check doesn't trip earlier than the desired // check. - sle->at(sfBalance) = beast::kZERO; + sle->at(sfBalance) = beast::kZero; ac.view().erase(sle); return true; }); @@ -284,8 +286,8 @@ class Invariants_test : public beast::unit_test::Suite // Clear the balance so the "account deletion left behind a // non-zero balance" check doesn't trip earlier than the desired // check. - sleA1->at(sfBalance) = beast::kZERO; - sleA2->at(sfBalance) = beast::kZERO; + sleA1->at(sfBalance) = beast::kZero; + sleA2->at(sfBalance) = beast::kZero; ac.view().erase(sleA1); ac.view().erase(sleA2); return true; @@ -309,7 +311,7 @@ class Invariants_test : public beast::unit_test::Suite auto const sleA1 = ac.view().peek(keylet::account(a1)); if (!sleA1) return false; - if (!BEAST_EXPECT(*sleA1->at(sfBalance) != beast::kZERO)) + if (!BEAST_EXPECT(*sleA1->at(sfBalance) != beast::kZero)) return false; ac.view().erase(sleA1); @@ -331,7 +333,7 @@ class Invariants_test : public beast::unit_test::Suite // Clear the balance so the "account deletion left behind a // non-zero balance" check doesn't trip earlier than the desired // check. - sleA1->at(sfBalance) = beast::kZERO; + sleA1->at(sfBalance) = beast::kZero; BEAST_EXPECT(sleA1->at(sfOwnerCount) == 0); adjustOwnerCount(ac.view(), sleA1, 1, ac.journal); @@ -342,7 +344,7 @@ class Invariants_test : public beast::unit_test::Suite XRPAmount{}, STTx{ttACCOUNT_DELETE, [](STObject& tx) {}}); - for (auto const& keyletInfo : kDIRECT_ACCOUNT_KEYLETS) + for (auto const& keyletInfo : kDirectAccountKeylets) { // TODO: Use structured binding once LLVM 16 is the minimum // supported version. See also: @@ -372,7 +374,7 @@ class Invariants_test : public beast::unit_test::Suite // Clear the balance so the "account deletion left behind a // non-zero balance" check doesn't trip earlier than the // desired check. - sleA1->at(sfBalance) = beast::kZERO; + sleA1->at(sfBalance) = beast::kZero; ac.view().erase(sleA1); return true; @@ -392,7 +394,7 @@ class Invariants_test : public beast::unit_test::Suite // Clear the balance so the "account deletion left behind a // non-zero balance" check doesn't trip earlier than the desired // check. - sle->at(sfBalance) = beast::kZERO; + sle->at(sfBalance) = beast::kZero; sle->at(sfOwnerCount) = 0; ac.view().erase(sle); return true; @@ -427,7 +429,7 @@ class Invariants_test : public beast::unit_test::Suite // Clear the balance so the "account deletion left behind a // non-zero balance" check doesn't trip earlier than the desired // check. - sle->at(sfBalance) = beast::kZERO; + sle->at(sfBalance) = beast::kZero; sle->at(sfOwnerCount) = 0; ac.view().erase(sle); @@ -491,7 +493,7 @@ class Invariants_test : public beast::unit_test::Suite // Clear the balance so the "account deletion left behind a // non-zero balance" check doesn't trip earlier than the desired // check. - sle->at(sfBalance) = beast::kZERO; + sle->at(sfBalance) = beast::kZero; sle->at(sfOwnerCount) = 0; ac.view().erase(sle); @@ -763,7 +765,7 @@ class Invariants_test : public beast::unit_test::Suite return false; // Use `drops(1)` to bypass a call to STAmount::canonicalize // with an invalid value - sle->setFieldAmount(sfBalance, kINITIAL_XRP + drops(1)); + sle->setFieldAmount(sfBalance, kInitialXrp + drops(1)); BEAST_EXPECT(!sle->getFieldAmount(sfBalance).negative()); ac.view().update(sle); return true; @@ -797,10 +799,10 @@ class Invariants_test : public beast::unit_test::Suite XRPAmount{-1}); doInvariantCheck( - {{"fee paid exceeds system limit: "s + to_string(kINITIAL_XRP)}, - {"XRP net change of 0 doesn't match fee "s + to_string(kINITIAL_XRP)}}, + {{"fee paid exceeds system limit: "s + to_string(kInitialXrp)}, + {"XRP net change of 0 doesn't match fee "s + to_string(kInitialXrp)}}, [](Account const&, Account const&, ApplyContext&) { return true; }, - XRPAmount{kINITIAL_XRP}); + XRPAmount{kInitialXrp}); doInvariantCheck( {{"fee paid is 20 exceeds fee specified in transaction."}, @@ -892,7 +894,7 @@ class Invariants_test : public beast::unit_test::Suite auto sleNew = std::make_shared(keylet::escrow(a1, (*sle)[sfSequence] + 2)); // Use `drops(1)` to bypass a call to STAmount::canonicalize // with an invalid value - sleNew->setFieldAmount(sfAmount, kINITIAL_XRP + drops(1)); + sleNew->setFieldAmount(sfAmount, kInitialXrp + drops(1)); ac.view().insert(sleNew); return true; }); @@ -1291,8 +1293,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 +1316,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,20 +1330,20 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain 2"; - auto constexpr kTOO_BIG = kMAX_PERMISSIONED_DOMAIN_CREDENTIALS_ARRAY_SIZE + 1; + static constexpr auto kTooBig = kMaxPermissionedDomainCredentialsArraySize + 1; doInvariantCheck( Env(*this, features), - {{"permissioned domain bad credentials size " + std::to_string(kTOO_BIG)}}, + {{"permissioned domain bad credentials size " + std::to_string(kTooBig)}}, [](Account const& a1, Account const& a2, ApplyContext& ac) { - return !!createPermissionedDomain(ac, a1, a2, kTOO_BIG); + return !!createPermissionedDomain(ac, a1, a2, kTooBig); }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : badTers); + fixEnabled ? failTers : badTers); testcase << "PermissionedDomain 3"; doInvariantCheck( @@ -1365,7 +1367,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 +1390,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,21 +1411,21 @@ 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( Env(*this, features), - {{"permissioned domain bad credentials size " + std::to_string(kTOO_BIG)}}, + {{"permissioned domain bad credentials size " + std::to_string(kTooBig)}}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { // create PD auto slePd = createPermissionedDomain(ac, a1, a2); // update PD { - STArray credentials(sfAcceptedCredentials, kTOO_BIG); + STArray credentials(sfAcceptedCredentials, kTooBig); - for (std::size_t n = 0; n < kTOO_BIG; ++n) + for (std::size_t n = 0; n < kTooBig; ++n) { auto cred = STObject::makeInnerObject(sfCredential); cred.setAccountID(sfIssuer, a2); @@ -1440,7 +1442,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 +1472,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 +1500,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 +1518,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 +1526,7 @@ class Invariants_test : public beast::unit_test::Suite }, XRPAmount{}, STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}}, - fixPDEnabled ? failTers : goodTers); + fixEnabled ? failTers : goodTers); } { @@ -1545,7 +1547,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 +1557,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 +1589,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 +1613,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 +1621,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; @@ -1783,7 +1785,7 @@ class Invariants_test : public beast::unit_test::Suite for (std::size_t n = 0; n < numCreds; ++n) { auto credType = "cred_type" + std::to_string(n); - credentials.push_back({a2, credType}); + credentials.push_back({.issuer = a2, .credType = credType}); } std::uint32_t const seq = env.seq(a1); @@ -1800,11 +1802,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 +1908,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 +1926,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 @@ -2040,6 +2039,170 @@ class Invariants_test : public beast::unit_test::Suite } } + void + testBookDirectoryExchangeRate() + { + using namespace test::jtx; + testcase << "book directory exchange rate"; + + auto const getBookRootKey = [](Account const& account, std::uint64_t quality) { + Book const book{xrpIssue(), account["USD"], std::nullopt}; + return keylet::quality(keylet::kBook(book), quality); + }; + + // Root book-directory pages carry exchange-rate metadata that must + // match the quality encoded in the directory key. + auto const makeRootPage = [](Keylet const& dir, std::uint64_t exchangeRate) { + auto sleDir = std::make_shared(dir); + sleDir->setFieldH256(sfRootIndex, dir.key); + STVector256 indexes; + indexes.pushBack(uint256{1}); + sleDir->setFieldV256(sfIndexes, indexes); + sleDir->setFieldU64(sfExchangeRate, exchangeRate); + return sleDir; + }; + + // Child pages do not carry quality metadata; they only point back to + // the root directory. + auto const makeChildPage = [](Keylet const& rootDir) { + auto sleDir = std::make_shared(keylet::page(rootDir, 1)); + sleDir->setFieldH256(sfRootIndex, rootDir.key); + STVector256 indexes; + indexes.pushBack(uint256{2}); + sleDir->setFieldV256(sfIndexes, indexes); + return sleDir; + }; + + auto const makeOfferCreateTx = [] { + return STTx{ttOFFER_CREATE, [](STObject& tx) { + Account const account{"A1"}; + tx.setFieldAmount(sfTakerPays, XRP(1)); + tx.setFieldAmount(sfTakerGets, account["USD"](1)); + }}; + }; + std::initializer_list const failTers = {tecINVARIANT_FAILED, tefINVARIANT_FAILED}; + + // Creating a root book directory with mismatched exchange-rate + // metadata violates the invariant. + doInvariantCheck( + {{"book directory exchange rate does not match directory quality"}}, + [&](Account const& a1, Account const&, ApplyContext& ac) { + auto const directoryQuality = STAmount::kURateOne; + auto const dir = getBookRootKey(a1, directoryQuality); + ac.view().insert(makeRootPage(dir, directoryQuality + 1)); + return true; + }, + XRPAmount{}, + makeOfferCreateTx(), + failTers); + + // A new child page must point to an existing root page. + doInvariantCheck( + {{"book directory root missing"}}, + [&](Account const& a1, Account const&, ApplyContext& ac) { + auto const directoryQuality = STAmount::kURateOne; + auto const rootDir = getBookRootKey(a1, directoryQuality); + // Insert only the child page. It points at rootDir, but the + // corresponding root page is intentionally missing. + ac.view().insert(makeChildPage(rootDir)); + return true; + }, + XRPAmount{}, + makeOfferCreateTx(), + failTers); + + // Legacy bad-root tolerance: + // - The view contains a pre-existing root page with bad sfExchangeRate + // metadata. + // - The simulated transaction only creates a child page pointing to + // that root. + // - The invariant must pass because this transaction did not create + // the bad root, only adding a child page. + { + Env env{*this, defaultAmendments()}; + Account const a1{"A1"}; + env.fund(XRP(1000), a1); + env.close(); + + OpenView view{*env.current()}; + auto const directoryQuality = STAmount::kURateOne; + auto const rootDir = getBookRootKey(a1, directoryQuality); + view.rawInsert(makeRootPage(rootDir, directoryQuality + 1)); + + ValidBookDirectory invariant; + invariant.visitEntry(false, nullptr, makeChildPage(rootDir)); + + test::StreamSink sink{beast::Severity::Warning}; + beast::Journal const jlog{sink}; + BEAST_EXPECT( + invariant.finalize(makeOfferCreateTx(), tesSUCCESS, XRPAmount{}, view, jlog)); + } + + // A bad root is rejected when added, ignored when a legacy bad root is + // modified without changing sfRootIndex or deleted, and checked when a + // modified directory changes sfRootIndex. + { + Env env{*this, defaultAmendments()}; + Account const a1{"A1"}; + env.fund(XRP(1000), a1); + env.close(); + + OpenView view{*env.current()}; + auto const directoryQuality = STAmount::kURateOne; + auto const rootDir = getBookRootKey(a1, directoryQuality); + auto const missingRootDir = getBookRootKey(a1, directoryQuality + 1); + auto const badRoot = makeRootPage(rootDir, directoryQuality + 1); + view.rawInsert(badRoot); + + test::StreamSink sink{beast::Severity::Warning}; + beast::Journal const jlog{sink}; + + { + // add + ValidBookDirectory invariant; + invariant.visitEntry(false, nullptr, badRoot); + + BEAST_EXPECT( + !invariant.finalize(makeOfferCreateTx(), tesSUCCESS, XRPAmount{}, view, jlog)); + } + { + // modify (without changing the sfRootIndex) + ValidBookDirectory invariant; + invariant.visitEntry(false, badRoot, badRoot); + + BEAST_EXPECT( + invariant.finalize(makeOfferCreateTx(), tesSUCCESS, XRPAmount{}, view, jlog)); + } + { + // modify (changing sfRootIndex to a missing root) + auto const childBefore = makeChildPage(rootDir); + auto const childAfter = std::make_shared(*childBefore, childBefore->key()); + childAfter->setFieldH256(sfRootIndex, missingRootDir.key); + + ValidBookDirectory invariant; + invariant.visitEntry(false, childBefore, childAfter); + + test::StreamSink missingRootSink{beast::Severity::Warning}; + beast::Journal const missingRootJlog{missingRootSink}; + BEAST_EXPECT(!invariant.finalize( + makeOfferCreateTx(), tesSUCCESS, XRPAmount{}, view, missingRootJlog)); + BEAST_EXPECT( + missingRootSink.messages().str().find("book directory root missing") != + std::string::npos); + } + { + // delete + view.rawErase(badRoot); + BEAST_EXPECT(!view.exists(rootDir)); + + ValidBookDirectory invariant; + invariant.visitEntry(true, badRoot, badRoot); + BEAST_EXPECT( + invariant.finalize(makeOfferCreateTx(), tesSUCCESS, XRPAmount{}, view, jlog)); + } + } + } + Keylet createLoanBroker(jtx::Account const& a, jtx::Env& env, jtx::PrettyAsset const& asset) { @@ -2059,7 +2222,7 @@ class Invariants_test : public beast::unit_test::Suite auto const loanBrokerKeylet = keylet::loanbroker(a.id(), env.seq(a)); // Create a Loan Broker with all default values. - env(set(a, vaultID), Fee(kINCREMENT)); + env(set(a, vaultID), Fee(kIncrement)); return loanBrokerKeylet; }; @@ -2163,7 +2326,7 @@ class Invariants_test : public beast::unit_test::Suite return iouAsset; } case Asset::MPT: { - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); PrettyAsset const mptAsset = mptt.issuanceID(); mptt.authorize({.account = alice}); @@ -2387,7 +2550,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) { @@ -2430,7 +2593,7 @@ class Invariants_test : public beast::unit_test::Suite std::optional accountShares = std::nullopt; // NOLINTEND(readability-redundant-member-init) }; - auto constexpr kADJUST = [&](ApplyView& ac, xrpl::Keylet keylet, Adjustments args) { + constexpr auto kAdjust = [&](ApplyView& ac, xrpl::Keylet keylet, Adjustments args) { auto sleVault = ac.peek(keylet); if (!sleVault) return false; @@ -2529,7 +2692,7 @@ class Invariants_test : public beast::unit_test::Suite return true; }; - constexpr auto kARGS = [](AccountID id, int adjustment, auto fn) -> Adjustments { + static constexpr auto kArgs = [](AccountID id, int adjustment, auto fn) -> Adjustments { Adjustments sample = { .assetsTotal = adjustment, .assetsAvailable = adjustment, @@ -2918,9 +3081,9 @@ class Invariants_test : public beast::unit_test::Suite (*sleA4)[sfBalance] = *(*sleA4)[sfBalance] + 10; ac.view().update(sleA4); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [&](Adjustments& sample) { - sample.assetsAvailable = (kDROPS_PER_XRP * -100).value(); - sample.assetsTotal = (kDROPS_PER_XRP * -200).value(); + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) { + sample.assetsAvailable = (kDropsPerXrp * -100).value(); + sample.assetsTotal = (kDropsPerXrp * -200).value(); sample.sharesTotal = -1; })); }, @@ -2983,7 +3146,7 @@ class Invariants_test : public beast::unit_test::Suite "set must not change assets outstanding"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) { sample.lossUnrealized = 13; sample.assetsTotal = 20; })); @@ -3000,7 +3163,7 @@ class Invariants_test : public beast::unit_test::Suite "vault transaction must not change loss unrealized"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 100, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 100, [&](Adjustments& sample) { sample.lossUnrealized = 13; })); }, @@ -3015,7 +3178,7 @@ class Invariants_test : public beast::unit_test::Suite {"set assets outstanding must not exceed assets maximum"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) { sample.assetsMaximum = 1; })); }, @@ -3029,7 +3192,7 @@ class Invariants_test : public beast::unit_test::Suite {"assets maximum must be positive"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) { sample.assetsMaximum = -1; })); }, @@ -3075,7 +3238,7 @@ class Invariants_test : public beast::unit_test::Suite (*sleShares)[sfMaximumAmount] = 10; ac.view().update(sleShares); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [](Adjustments&) {})); + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [](Adjustments&) {})); }, XRPAmount{}, STTx{ttVAULT_DEPOSIT, [](STObject&) {}}, @@ -3087,7 +3250,7 @@ class Invariants_test : public beast::unit_test::Suite {"updated shares must not exceed maximum"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [](Adjustments&) {})); + kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [](Adjustments&) {})); auto sleVault = ac.view().peek(keylet); if (!sleVault) @@ -3095,7 +3258,7 @@ class Invariants_test : public beast::unit_test::Suite auto sleShares = ac.view().peek(keylet::mptIssuance((*sleVault)[sfShareMPTID])); if (!sleShares) return false; - (*sleShares)[sfOutstandingAmount] = kMAX_MP_TOKEN_AMOUNT + 1; + (*sleShares)[sfOutstandingAmount] = kMaxMpTokenAmount + 1; ac.view().update(sleShares); return true; }, @@ -3312,7 +3475,7 @@ class Invariants_test : public beast::unit_test::Suite sleVault->at(sfAssetsAvailable) = Number(0); sleVault->at(sfLossUnrealized) = Number(0); sleVault->at(sfShareMPTID) = sharesMptId; - sleVault->at(sfWithdrawalPolicy) = kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE; + sleVault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe; ac.view().insert(sleVault); ac.view().insert(sleShares); @@ -3372,7 +3535,7 @@ class Invariants_test : public beast::unit_test::Suite sleVault->at(sfAssetsAvailable) = Number(0); sleVault->at(sfLossUnrealized) = Number(0); sleVault->at(sfShareMPTID) = sharesMptId; - sleVault->at(sfWithdrawalPolicy) = kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE; + sleVault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe; ac.view().insert(sleVault); ac.view().insert(sleShares); @@ -3401,7 +3564,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; @@ -3413,7 +3576,7 @@ class Invariants_test : public beast::unit_test::Suite sleVault->at(sfAssetsAvailable) = Number(0); sleVault->at(sfLossUnrealized) = Number(0); sleVault->at(sfShareMPTID) = sharesMptId; - sleVault->at(sfWithdrawalPolicy) = kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE; + sleVault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe; ac.view().insert(sleVault); ac.view().insert(sleShares); @@ -3428,7 +3591,7 @@ class Invariants_test : public beast::unit_test::Suite {"deposit must change vault balance"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [](Adjustments& sample) { sample.vaultAssets.reset(); })); }, @@ -3441,7 +3604,7 @@ class Invariants_test : public beast::unit_test::Suite {"deposit assets outstanding must not exceed assets maximum"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 200, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 200, [&](Adjustments& sample) { sample.assetsMaximum = 1; })); }, @@ -3468,7 +3631,7 @@ class Invariants_test : public beast::unit_test::Suite (*sleA4)[sfBalance] = *(*sleA4)[sfBalance] + 10; ac.view().update(sleA4); - return kADJUST(ac.view(), keylet, kARGS(a3.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a3.id(), -10, [&](Adjustments& sample) { sample.accountAssets->amount = -100; })); }, @@ -3498,7 +3661,7 @@ class Invariants_test : public beast::unit_test::Suite (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] + 10; ac.view().update(sleA3); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) { sample.vaultAssets = -20; sample.accountAssets->amount = 10; })); @@ -3521,7 +3684,7 @@ class Invariants_test : public beast::unit_test::Suite (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] - 10; ac.view().update(sleA3); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) { sample.accountAssets->amount = 0; })); }, @@ -3535,7 +3698,7 @@ class Invariants_test : public beast::unit_test::Suite {"deposit must change depositor shares"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) { sample.accountShares.reset(); })); }, @@ -3550,7 +3713,7 @@ class Invariants_test : public beast::unit_test::Suite [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [](Adjustments& sample) { sample.sharesTotal = 0; })); }, @@ -3567,7 +3730,7 @@ class Invariants_test : public beast::unit_test::Suite "amount"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) { sample.accountShares->amount = -5; sample.sharesTotal = -10; })); @@ -3586,7 +3749,7 @@ class Invariants_test : public beast::unit_test::Suite ac.view().update(sleA3); auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) { sample.assetsTotal = 11; })); }, @@ -3607,7 +3770,7 @@ class Invariants_test : public beast::unit_test::Suite "deposit and assets available must add up"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) { sample.assetsTotal = 7; sample.assetsAvailable = 7; })); @@ -3623,7 +3786,7 @@ class Invariants_test : public beast::unit_test::Suite {"withdrawal must change vault balance"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [](Adjustments& sample) { sample.vaultAssets.reset(); })); }, @@ -3648,7 +3811,7 @@ class Invariants_test : public beast::unit_test::Suite (*sleA4)[sfBalance] = *(*sleA4)[sfBalance] + 10; ac.view().update(sleA4); - return kADJUST(ac.view(), keylet, kARGS(a3.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a3.id(), -10, [&](Adjustments& sample) { sample.accountAssets->amount = -100; })); }, @@ -3682,7 +3845,7 @@ class Invariants_test : public beast::unit_test::Suite (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] + 10; ac.view().update(sleA3); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) { sample.vaultAssets = 10; sample.accountAssets->amount = -20; })); @@ -3697,7 +3860,7 @@ class Invariants_test : public beast::unit_test::Suite {"withdrawal must change one destination balance"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - if (!kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [&](Adjustments& sample) { + if (!kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) { *sample.vaultAssets -= 5; }))) return false; @@ -3718,7 +3881,7 @@ class Invariants_test : public beast::unit_test::Suite {"withdrawal must change depositor shares"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) { sample.accountShares.reset(); })); }, @@ -3732,7 +3895,7 @@ class Invariants_test : public beast::unit_test::Suite {"withdrawal must change vault shares"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [](Adjustments& sample) { sample.sharesTotal = 0; })); }, @@ -3748,7 +3911,7 @@ class Invariants_test : public beast::unit_test::Suite "amount"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) { sample.accountShares->amount = 5; sample.sharesTotal = 10; })); @@ -3764,7 +3927,7 @@ class Invariants_test : public beast::unit_test::Suite "withdrawal and assets available must add up"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) { sample.assetsTotal = -15; sample.assetsAvailable = -15; })); @@ -3783,7 +3946,7 @@ class Invariants_test : public beast::unit_test::Suite ac.view().update(sleA3); auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) { sample.assetsTotal = -7; })); }, @@ -3851,7 +4014,7 @@ class Invariants_test : public beast::unit_test::Suite "amount"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq() - 2); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) { sample.accountShares->amount = 5; })); }, @@ -3866,7 +4029,7 @@ class Invariants_test : public beast::unit_test::Suite {"clawback must change vault balance"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq() - 2); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), -1, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a2.id(), -1, [&](Adjustments& sample) { sample.vaultAssets.reset(); })); }, @@ -3880,7 +4043,7 @@ class Invariants_test : public beast::unit_test::Suite {"clawback may only be performed by the asset issuer"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq()); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [&](Adjustments& sample) {})); + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {})); }, XRPAmount{}, STTx{ttVAULT_CLAWBACK, [](STObject&) {}}, @@ -3892,7 +4055,7 @@ class Invariants_test : public beast::unit_test::Suite {"clawback may only be performed by the asset issuer"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq() - 2); - return kADJUST(ac.view(), keylet, kARGS(a2.id(), 0, [&](Adjustments& sample) {})); + return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {})); }, XRPAmount{}, STTx{ttVAULT_CLAWBACK, [&](STObject& tx) { tx[sfAccount] = a4.id(); }}, @@ -3905,7 +4068,7 @@ class Invariants_test : public beast::unit_test::Suite "clawback must change vault shares"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq() - 2); - return kADJUST(ac.view(), keylet, kARGS(a4.id(), 10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a4.id(), 10, [&](Adjustments& sample) { sample.sharesTotal = 0; })); }, @@ -3923,7 +4086,7 @@ class Invariants_test : public beast::unit_test::Suite {"clawback must change holder shares"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq() - 2); - return kADJUST(ac.view(), keylet, kARGS(a4.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a4.id(), -10, [&](Adjustments& sample) { sample.accountShares.reset(); })); }, @@ -3943,7 +4106,7 @@ class Invariants_test : public beast::unit_test::Suite "clawback and assets available must add up"}, [&](Account const& a1, Account const& a2, ApplyContext& ac) { auto const keylet = keylet::vault(a1.id(), ac.view().seq() - 2); - return kADJUST(ac.view(), keylet, kARGS(a4.id(), -10, [&](Adjustments& sample) { + return kAdjust(ac.view(), keylet, kArgs(a4.id(), -10, [&](Adjustments& sample) { sample.accountShares->amount = -8; sample.assetsTotal = -7; sample.assetsAvailable = -7; @@ -3966,6 +4129,63 @@ class Invariants_test : public beast::unit_test::Suite using namespace test::jtx; testcase << "MPT"; + MPTIssue const nonCanonicalMPTIssue{makeMptID(1, AccountID(0x4985601))}; + auto const nonCanonicalMPTAmount = [&](SField const& field) { + return STAmount{ + field, + nonCanonicalMPTIssue, + kMaxMpTokenAmount + std::uint64_t{1}, + 0, + false, + STAmount::Unchecked{}}; + }; + auto const negativeMPTAmount = [&](SField const& field) { + return STAmount{field, nonCanonicalMPTIssue, 2, 0, true, STAmount::Unchecked{}}; + }; + auto const nonCanonicalMPTPayment = [&]() { + return STTx{ttPAYMENT, [&](STObject& tx) { + tx.setFieldAmount(sfAmount, nonCanonicalMPTAmount(sfAmount)); + }}; + }; + + doInvariantCheck( + Env{*this, defaultAmendments() - fixCleanup3_2_0}, + {}, + [](Account const&, Account const&, ApplyContext&) { return true; }, + XRPAmount{}, + nonCanonicalMPTPayment(), + {tesSUCCESS, tesSUCCESS}); + + doInvariantCheck( + {{"ledger entry contains non-canonical MPT or XRP amount"}}, + [&](Account const& a1, Account const& a2, ApplyContext& ac) { + auto const sle = ac.view().peek(keylet::account(a1.id())); + if (!sle) + return false; + + auto sleNew = std::make_shared(keylet::check(a1.id(), (*sle)[sfSequence])); + sleNew->setAccountID(sfAccount, a1.id()); + sleNew->setAccountID(sfDestination, a2.id()); + sleNew->setFieldAmount(sfSendMax, nonCanonicalMPTAmount(sfSendMax)); + ac.view().insert(sleNew); + return true; + }); + + doInvariantCheck( + {{"ledger entry contains non-canonical MPT or XRP amount"}}, + [&](Account const& a1, Account const& a2, ApplyContext& ac) { + auto const sle = ac.view().peek(keylet::account(a1.id())); + if (!sle) + return false; + + auto sleNew = std::make_shared(keylet::check(a1.id(), (*sle)[sfSequence])); + sleNew->setAccountID(sfAccount, a1.id()); + sleNew->setAccountID(sfDestination, a2.id()); + sleNew->setFieldAmount(sfSendMax, negativeMPTAmount(sfSendMax)); + ac.view().insert(sleNew); + return true; + }); + // MPT OutstandingAmount > MaximumAmount doInvariantCheck( {{"OutstandingAmount overflow"}}, @@ -4106,6 +4326,297 @@ class Invariants_test : public beast::unit_test::Suite return true; }); } + + // sfReferenceHolding can only be set on creation by VaultCreate. A + // non-VaultCreate transaction that creates an MPTokenIssuance with + // sfReferenceHolding present must trip the invariant. + doInvariantCheck( + {{"sfReferenceHolding set on a new MPTokenIssuance by a " + "non-VaultCreate transaction"}}, + [](Account const& a1, Account const&, ApplyContext& ac) { + auto const sleAcct = ac.view().peek(keylet::account(a1.id())); + if (!sleAcct) + return false; + MPTIssue const mpt{makeMptID(sleAcct->getFieldU32(sfSequence), a1)}; + auto sleNew = std::make_shared(keylet::mptIssuance(mpt.getMptID())); + sleNew->setFieldH256(sfReferenceHolding, uint256{1}); + ac.view().insert(sleNew); + return true; + }, + XRPAmount{}, + STTx{ttACCOUNT_SET, [](STObject&) {}}); + + // sfReferenceHolding is immutable: changing the field on an + // existing MPTokenIssuance must trip the invariant. Set up a real + // vault via preclose (so the share issuance carries + // sfReferenceHolding), then mutate it in precheck to produce a + // before/after pair. + { + uint256 vaultKey; + doInvariantCheck( + {{"sfReferenceHolding was modified on an existing " + "MPTokenIssuance"}}, + [&](Account const&, Account const&, ApplyContext& ac) { + auto const sleVault = ac.view().peek(keylet::vault(vaultKey)); + if (!sleVault) + return false; + auto sleIssuance = + ac.view().peek(keylet::mptIssuance(sleVault->at(sfShareMPTID))); + if (!sleIssuance) + return false; + sleIssuance->setFieldH256(sfReferenceHolding, uint256{2}); + ac.view().update(sleIssuance); + return true; + }, + XRPAmount{}, + STTx{ttACCOUNT_SET, [](STObject&) {}}, + {tecINVARIANT_FAILED, tefINVARIANT_FAILED}, + [&](Account const& a1, Account const&, Env& env) { + Account const issuer{"issuer"}; + env.fund(XRP(10'000), issuer); + env.close(); + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = a1}); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = a1, .asset = asset}); + env(tx); + env.close(); + vaultKey = keylet.key; + return true; + }); + } + + // A vault pseudo-account's MPToken cannot be deleted by anything + // other than a VaultDelete transaction. Set up a vault, then have + // an arbitrary tx erase the pseudo's MPToken in precheck. + { + uint256 vaultKey; + doInvariantCheck( + {{"vault pseudo-account holding deleted by a " + "non-VaultDelete transaction"}}, + [&](Account const&, Account const&, ApplyContext& ac) { + auto const sleVault = ac.view().peek(keylet::vault(vaultKey)); + if (!sleVault) + return false; + auto const sleIssuance = + ac.view().peek(keylet::mptIssuance(sleVault->at(sfShareMPTID))); + if (!sleIssuance || !sleIssuance->isFieldPresent(sfReferenceHolding)) + return false; + auto sleHolding = ac.view().peek( + keylet::unchecked(sleIssuance->getFieldH256(sfReferenceHolding))); + if (!sleHolding) + return false; + ac.view().erase(sleHolding); + return true; + }, + XRPAmount{}, + STTx{ttACCOUNT_SET, [](STObject&) {}}, + {tecINVARIANT_FAILED, tefINVARIANT_FAILED}, + [&](Account const& a1, Account const&, Env& env) { + Account const issuer{"issuer"}; + env.fund(XRP(10'000), issuer); + env.close(); + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = a1}); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = a1, .asset = asset}); + env(tx); + env.close(); + vaultKey = keylet.key; + return true; + }); + } + + // Invalid transfer + std::array, 3> const invalidTransferTests = { + std::make_pair(ttAMM_WITHDRAW, false), + std::make_pair(ttPAYMENT, false), + std::make_pair(ttPAYMENT, true)}; + for (auto const enabled : {true, false}) + { + for (auto const& [tx, crossCurrencyPayment] : invalidTransferTests) + { + for (auto const flag : + {static_cast(lsfMPTLocked), + ~lsfMPTCanTransfer, + ~lsfMPTCanTrade, + 0u}) + { + MPTID id{}; + auto const isSuccess = !enabled || flag == 0 || + (tx == ttPAYMENT && !crossCurrencyPayment && (flag == ~lsfMPTCanTrade)) || + (tx == ttAMM_WITHDRAW && + (flag == ~lsfMPTCanTrade || flag == ~lsfMPTCanTransfer)); + std::pair const error = isSuccess + ? std::make_pair(TER(tesSUCCESS), TER(tesSUCCESS)) + : std::make_pair(TER(tecINVARIANT_FAILED), TER(tefINVARIANT_FAILED)); + doInvariantCheck( + {{isSuccess ? "" : "invalid MPToken transfer between holders"}}, + [&](Account const& a1, Account const& a2, ApplyContext& ac) { + auto update = [&](AccountID const& a, std::uint64_t v) { + auto sle = ac.view().peek(keylet::mptoken(id, a)); + if (!sle) + return false; + sle->at(sfMPTAmount) = v; + ac.view().update(sle); + return true; + }; + auto issuanceSle = ac.view().peek(keylet::mptIssuance(id)); + if (!issuanceSle) + return false; + auto const flags = issuanceSle->at(sfFlags); + if (flag == lsfMPTLocked) + { + issuanceSle->at(sfFlags) = flags | lsfMPTLocked; + } + else if (flag != 0u) + { + issuanceSle->at(sfFlags) = flags & flag; + } + issuanceSle->at(sfOutstandingAmount) = 200; + ac.view().update(issuanceSle); + return update(a1, 101) && update(a2, 99); + }, + XRPAmount{}, + STTx{ + tx, + [&](STObject& tx) { + if (crossCurrencyPayment) + { + tx.setFieldAmount( + sfSendMax, STAmount(MPTAmount{100}, MPTIssue{id})); + } + }}, + {error.first, error.second}, + [&](Account const& a1, Account const& a2, Env& env) { + Account const gw("gw"); + env.fund(XRP(1'000), gw); + MPTTester const usd( + {.env = env, .issuer = gw, .holders = {a1, a2}, .pay = 100}); + id = usd.issuanceID(); + if (!enabled) + { + env.disableFeature(featureMPTokensV2); + } + return true; + }); + } + } + } + } + + void + testAMM() + { + testcase << "AMM"; + using namespace jtx; + + MPTID mptID{}; + uint256 ammID{}; + AccountID ammAccountID{}; + Account const gw{"gw"}; + Issue lptIssue{}; + PrettyAsset poolAsset{xrpIssue()}; + + auto deleteAMMAccount = [&](ApplyContext& ac, bool) { + auto sle = ac.view().peek(keylet::account(ammAccountID)); + if (!sle) + return false; + ac.view().erase(sle); + return true; + }; + + auto updateLPTokensBalance = [&](ApplyContext& ac, std::int64_t amount) { + auto sle = ac.view().peek(keylet::amm(ammID)); + if (!sle) + return false; + sle->setFieldAmount(sfLPTokenBalance, STAmount{lptIssue, amount}); + ac.view().update(sle); + return true; + }; + auto updateLPTokensBadAmount = [&](ApplyContext& ac, bool) { + return updateLPTokensBalance(ac, -1); + }; + auto updateLPTokensBadBalance = [&](ApplyContext& ac, bool) { + return updateLPTokensBalance(ac, 200'000'000); + }; + auto updateAMM = [&](ApplyContext& ac, bool) { return updateLPTokensBalance(ac, 10); }; + + auto updateAMMPool = [&](ApplyContext& ac, bool isMPT) { + if (isMPT) + { + auto sle = ac.view().peek(keylet::mptoken(mptID, ammAccountID)); + if (!sle) + return false; + sle->setFieldU64(sfMPTAmount, 1); + ac.view().update(sle); + return true; + } + auto sle = ac.view().peek(keylet::account(ammAccountID)); + if (!sle) + return false; + sle->setFieldAmount(sfBalance, XRP(1)); + ac.view().update(sle); + return true; + }; + + auto test = [&](auto const txType, + auto&& update, + bool isMPT, + TER error = tecINVARIANT_FAILED) { + doInvariantCheck( + {{"AMM"}}, + [&](Account const&, Account const&, ApplyContext& ac) { return update(ac, isMPT); }, + XRPAmount{}, + STTx{txType, [&](STObject& tx) {}}, + {tecINVARIANT_FAILED, error}, + [&](Account const&, Account const&, Env& env) { + env.fund(XRP(1'000), gw); + poolAsset = [&]() -> PrettyAsset { + if (isMPT) + { + MPT const mpt = MPTTester({.env = env, .issuer = gw}); + mptID = mpt.issuanceID; + return mpt; + } + return gw["USD"]; + }(); + AMM const amm(env, gw, XRP(100), poolAsset(100)); + ammAccountID = amm.ammAccount(); + ammID = amm.ammID(); + lptIssue = amm.lptIssue(); + return true; + }); + }; + + for (bool const isMPT : {false, true}) + { + auto const error = isMPT ? TER(tecINVARIANT_FAILED) : TER(tefINVARIANT_FAILED); + for (auto txType : {ttAMM_CREATE, ttAMM_DEPOSIT, ttAMM_CLAWBACK, ttAMM_WITHDRAW}) + { + test(txType, deleteAMMAccount, isMPT, tefINVARIANT_FAILED); + test(txType, updateLPTokensBadAmount, isMPT); + test(txType, updateLPTokensBadBalance, isMPT); + } + for (auto txType : {ttAMM_BID, ttAMM_VOTE}) + { + test(txType, updateAMMPool, isMPT, error); + test(txType, updateLPTokensBadAmount, isMPT); + test(txType, updateLPTokensBadBalance, isMPT); + } + for (auto txType : {ttAMM_DELETE, ttCHECK_CASH, ttOFFER_CREATE, ttPAYMENT}) + { + test(txType, updateAMM, isMPT); + } + } } // Test the invariant overwrite fix for both pre- and post-amendment @@ -4116,7 +4627,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}; @@ -4229,8 +4740,8 @@ class Invariants_test : public beast::unit_test::Suite MPTIssue const mpt{makeMptID(1, AccountID(0x4985601))}; auto sleNew = std::make_shared(keylet::mptIssuance(mpt.getMptID())); - // outstanding exceeds kMAX_MP_TOKEN_AMOUNT -> checkAmount sets bad_ - sleNew->setFieldU64(sfOutstandingAmount, kMAX_MP_TOKEN_AMOUNT + 1); + // outstanding exceeds kMaxMpTokenAmount -> checkAmount sets bad_ + sleNew->setFieldU64(sfOutstandingAmount, kMaxMpTokenAmount + 1); // locked is valid and <= outstanding -> must NOT clear bad_ sleNew->setFieldU64(sfLockedAmount, 10); ac.view().insert(sleNew); @@ -4380,22 +4891,20 @@ 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); + testBookDirectoryExchangeRate(); 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/LedgerHistory_test.cpp b/src/test/app/LedgerHistory_test.cpp index 396ec8db2d..3d0e546678 100644 --- a/src/test/app/LedgerHistory_test.cpp +++ b/src/test/app/LedgerHistory_test.cpp @@ -48,9 +48,9 @@ public: { assert(!stx); return std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); } diff --git a/src/test/app/LedgerLoad_test.cpp b/src/test/app/LedgerLoad_test.cpp index 3345f45aa6..ee3bfe5192 100644 --- a/src/test/app/LedgerLoad_test.cpp +++ b/src/test/app/LedgerLoad_test.cpp @@ -40,9 +40,9 @@ class LedgerLoad_test : public beast::unit_test::Suite StartUpType type, std::optional trapTxHash) { - cfg->START_LEDGER = ledger; - cfg->START_UP = type; - cfg->TRAP_TX_HASH = trapTxHash; + cfg->startLedger = ledger; + cfg->startUp = type; + cfg->trapTxHash = trapTxHash; assert(!dbPath.empty()); cfg->legacy("database_path", dbPath); return cfg; @@ -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/LedgerMaster_test.cpp b/src/test/app/LedgerMaster_test.cpp index ee14a93d07..3cf9b3a9d9 100644 --- a/src/test/app/LedgerMaster_test.cpp +++ b/src/test/app/LedgerMaster_test.cpp @@ -27,9 +27,9 @@ class LedgerMaster_test : public beast::unit_test::Suite { using namespace jtx; return envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = networkID; + cfg->networkId = networkID; // This test relies on ledger hash so must lock it to fee 10. - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; }); } diff --git a/src/test/app/LedgerReplay_test.cpp b/src/test/app/LedgerReplay_test.cpp index a96fa2c499..1978d04fe1 100644 --- a/src/test/app/LedgerReplay_test.cpp +++ b/src/test/app/LedgerReplay_test.cpp @@ -291,8 +291,8 @@ public: [[nodiscard]] uint256 const& getClosedLedgerHash() const override { - static uint256 const kHASH{}; - return kHASH; + static uint256 const kHash{}; + return kHash; } [[nodiscard]] bool hasLedger(uint256 const& hash, std::uint32_t seq) const override @@ -445,8 +445,8 @@ struct TestPeerSet : public PeerSet [[nodiscard]] std::set const& getPeerIds() const override { - static std::set const kEMPTY_PEERS; - return kEMPTY_PEERS; + static std::set const kEmptyPeers; + return kEmptyPeers; } LedgerReplayMsgHandler& local; @@ -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); } /** @@ -561,9 +561,9 @@ struct LedgerServer accounts[toIdx], jtx::drops(ledgerMaster.getClosedLedger()->fees().base) + jtx::XRP(param.txAmount)), - jtx::Seq(jtx::kAUTOFILL), - jtx::Fee(jtx::kAUTOFILL), - jtx::Sig(jtx::kAUTOFILL)); + jtx::Seq(jtx::kAutofill), + jtx::Fee(jtx::kAutofill), + jtx::Sig(jtx::kAutofill)); } env.close(); } @@ -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); @@ -1065,7 +1062,7 @@ struct LedgerReplayer_test : public beast::unit_test::Suite testcase("config test"); { Config const c; - BEAST_EXPECT(c.LEDGER_REPLAY == false); + BEAST_EXPECT(c.ledgerReplay == false); } { @@ -1075,7 +1072,7 @@ struct LedgerReplayer_test : public beast::unit_test::Suite 1 )xrpldConfig"); c.loadFromString(toLoad); - BEAST_EXPECT(c.LEDGER_REPLAY == true); + BEAST_EXPECT(c.ledgerReplay == true); } { @@ -1085,7 +1082,7 @@ struct LedgerReplayer_test : public beast::unit_test::Suite 0 )xrpldConfig"); c.loadFromString(toLoad); - BEAST_EXPECT(c.LEDGER_REPLAY == false); + BEAST_EXPECT(c.ledgerReplay == false); } } @@ -1098,17 +1095,16 @@ struct LedgerReplayer_test : public beast::unit_test::Suite http_request_type httpRequest; httpRequest.version(request.version()); httpRequest.base() = request.base(); - bool const serverResult = - peerFeatureEnabled(httpRequest, kFEATURE_LEDGER_REPLAY, server); + bool const serverResult = peerFeatureEnabled(httpRequest, kFeatureLedgerReplay, server); if (serverResult != expecting) return false; beast::IP::Address const addr = boost::asio::ip::make_address("172.1.1.100"); jtx::Env serverEnv(*this); - serverEnv.app().config().LEDGER_REPLAY = server; + serverEnv.app().config().ledgerReplay = server; auto httpResp = xrpl::makeResponse( true, httpRequest, addr, addr, uint256{1}, 1, {1, 0}, serverEnv.app()); - auto const clientResult = peerFeatureEnabled(httpResp, kFEATURE_LEDGER_REPLAY, client); + auto const clientResult = peerFeatureEnabled(httpResp, kFeatureLedgerReplay, client); return clientResult == expecting; }; diff --git a/src/test/app/LendingHelpers_test.cpp b/src/test/app/LendingHelpers_test.cpp index cbfd9da884..af46dd2e0f 100644 --- a/src/test/app/LendingHelpers_test.cpp +++ b/src/test/app/LendingHelpers_test.cpp @@ -7,9 +7,16 @@ #include #include #include +#include +#include +#include +#include +#include +#include #include #include +#include #include #include @@ -17,63 +24,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 +71,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 +84,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 +131,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 +145,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 +193,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 +202,296 @@ 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{ + {.name = "r=5%, n=3", .r = Number{5, -2}, .n = 3}, + {.name = "r=0.1%, n=1000", .r = Number{1, -3}, .n = 1'000}, + {.name = "r=1e-7, n=100 (above threshold by 10x)", .r = Number{1, -7}, .n = 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. + {.name = "bug regime: r~1.9e-10, n=2", + .r = loanPeriodicRate(TenthBips32{1}, 600), + .n = 2}, + {.name = "r=1e-12, n=100", .r = Number{1, -12}, .n = 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{ + {.name = "r=1e-9, n=1", .r = Number{1, -9}, .n = 1}, + {.name = "r=1e-12, n=1000", .r = Number{1, -12}, .n = 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 +857,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 +867,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -697,6 +950,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -706,6 +960,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -790,6 +1045,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -799,6 +1055,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -889,6 +1146,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -898,6 +1156,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -996,6 +1255,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -1005,6 +1265,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -1103,6 +1364,7 @@ class LendingHelpers_test : public beast::unit_test::Suite managementFeeRate); auto const loanProperties = computeLoanProperties( + env.current()->rules(), asset, loanPrincipal, loanInterestRate, @@ -1112,6 +1374,7 @@ class LendingHelpers_test : public beast::unit_test::Suite loanScale); auto const ret = tryOverpayment( + env.current()->rules(), asset, loanScale, overpaymentComponents, @@ -1184,6 +1447,84 @@ class LendingHelpers_test : public beast::unit_test::Suite } public: + void + testCanApplyToBrokerCover() + { + using namespace jtx; + + Account const issuer{"issuer"}; + PrettyAsset const iou = issuer["IOU"]; + + // sfCoverAvailable = Number{10} on an IOU → STAmount exponent = -14, + // so coverScale = -14. The ULP boundary is 5e-15; anything below + // that rounds to zero at cover scale. Number{1,-16} = 1e-16 is our + // representative sub-ULP probe. + struct TestCase + { + std::string name; + Number coverAvailable; + STAmount amount; + TER expected; + }; + + auto const testCases = std::vector{ + { + .name = "Zero amount", + .coverAvailable = Number{10}, + .amount = STAmount{iou, Number{0}}, + .expected = tecPRECISION_LOSS, + }, + { + .name = "Rounds to zero at cover scale", + .coverAvailable = Number{10}, + .amount = STAmount{iou, Number{1, -16}}, + .expected = tecPRECISION_LOSS, + }, + { + .name = "Zero coverAvailable, whole-unit amount", + // coverScale = 0 (zero STAmount exponent); 1 IOU is not + // zero at integer scale → tesSUCCESS. + .coverAvailable = Number{0}, + .amount = STAmount{iou, Number{1}}, + .expected = tesSUCCESS, + }, + { + .name = "Supra-ULP amount", + .coverAvailable = Number{10}, + .amount = STAmount{iou, Number{1, -13}}, + .expected = tesSUCCESS, + }, + }; + + Env const env{*this}; + + for (auto const& tc : testCases) + { + testcase("canApplyToBrokerCover: " + tc.name); + auto sle = std::make_shared(ltLOAN_BROKER, uint256{1u}); + sle->at(sfCoverAvailable) = tc.coverAvailable; + BEAST_EXPECT( + canApplyToBrokerCover(*env.current(), sle, iou, tc.amount, env.journal, "test") == + tc.expected); + } + + // Amendment off → guard is bypassed regardless of amount. + { + testcase("canApplyToBrokerCover: amendment disabled"); + Env const envOff{*this, testableAmendments() - fixCleanup3_2_0}; + auto sle = std::make_shared(ltLOAN_BROKER, uint256{1u}); + sle->at(sfCoverAvailable) = Number{10}; + BEAST_EXPECT( + canApplyToBrokerCover( + *envOff.current(), + sle, + iou, + STAmount{iou, Number{0}}, + envOff.journal, + "test") == tesSUCCESS); + } + } + void run() override { @@ -1199,10 +1540,15 @@ public: testLoanLatePaymentInterest(); testLoanPeriodicPayment(); testLoanPrincipalFromPeriodicPayment(); - testComputeRaisedRate(); + testLoanPrincipalFromPeriodicPaymentNearZeroRate(); testComputePaymentFactor(); + testComputePowerMinusOne(); + testComputePowerMinusOneHybrid(); + testComputeTheoreticalLoanStateNearZeroRate(); + testComputePaymentFactorNearZeroRate(); testComputeOverpaymentComponents(); testComputeInterestAndFeeParts(); + testCanApplyToBrokerCover(); } }; diff --git a/src/test/app/LoadFeeTrack_test.cpp b/src/test/app/LoadFeeTrack_test.cpp index 1122ac4ad6..aba0b35062 100644 --- a/src/test/app/LoadFeeTrack_test.cpp +++ b/src/test/app/LoadFeeTrack_test.cpp @@ -17,9 +17,9 @@ public: { Fees const fees = [&]() { Fees f; - f.base = d.FEES.reference_fee; - f.reserve = 200 * kDROPS_PER_XRP; - f.increment = 50 * kDROPS_PER_XRP; + f.base = d.fees.referenceFee; + f.reserve = 200 * kDropsPerXrp; + f.increment = 50 * kDropsPerXrp; return f; }(); @@ -30,9 +30,9 @@ public: { Fees const fees = [&]() { Fees f; - f.base = d.FEES.reference_fee * 10; - f.reserve = 200 * kDROPS_PER_XRP; - f.increment = 50 * kDROPS_PER_XRP; + f.base = d.fees.referenceFee * 10; + f.reserve = 200 * kDropsPerXrp; + f.increment = 50 * kDropsPerXrp; return f; }(); @@ -43,9 +43,9 @@ public: { Fees const fees = [&]() { Fees f; - f.base = d.FEES.reference_fee; - f.reserve = 200 * kDROPS_PER_XRP; - f.increment = 50 * kDROPS_PER_XRP; + f.base = d.fees.referenceFee; + f.reserve = 200 * kDropsPerXrp; + f.increment = 50 * kDropsPerXrp; return f; }(); diff --git a/src/test/app/LoanBroker_test.cpp b/src/test/app/LoanBroker_test.cpp index 58c925c043..92949256fd 100644 --- a/src/test/app/LoanBroker_test.cpp +++ b/src/test/app/LoanBroker_test.cpp @@ -55,6 +55,7 @@ #include #include #include +#include #include namespace xrpl::test { @@ -99,11 +100,11 @@ class LoanBroker_test : public beast::unit_test::Suite env(coverWithdraw(alice, brokerKeylet.key, asset(1000)), Ter(temDISABLED)); // 3. LoanBrokerCoverClawback env(coverClawback(alice), Ter(temDISABLED)); - env(coverClawback(alice), kLOAN_BROKER_ID(brokerKeylet.key), Ter(temDISABLED)); - env(coverClawback(alice), kAMOUNT(asset(0)), Ter(temDISABLED)); + env(coverClawback(alice), kLoanBrokerId(brokerKeylet.key), Ter(temDISABLED)); + env(coverClawback(alice), kAmount(asset(0)), Ter(temDISABLED)); env(coverClawback(alice), - kLOAN_BROKER_ID(brokerKeylet.key), - kAMOUNT(asset(1000)), + kLoanBrokerId(brokerKeylet.key), + kAmount(asset(1000)), Ter(temDISABLED)); // 4. LoanBrokerDelete env(del(alice, brokerKeylet.key), Ter(temDISABLED)); @@ -166,15 +167,15 @@ class LoanBroker_test : public beast::unit_test::Suite using namespace loanBroker; // Bogus assets to use in test cases - static PrettyAsset const kBAD_MPT_ASSET = [&]() { - MPTTester badMptt{env, evan, kMPT_INIT_NO_FUND}; + static PrettyAsset const kBadMptAsset = [&]() { + MPTTester badMptt{env, evan, kMptInitNoFund}; badMptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); env.close(); return badMptt["BAD"]; }(); - static PrettyAsset const kBAD_IOU_ASSET = evan["BAD"]; - static Account const kNON_EXISTENT{"NonExistent"}; - static PrettyAsset const kGHOST_IOU_ASSET = kNON_EXISTENT["GST"]; + static PrettyAsset const kBadIouAsset = evan["BAD"]; + static Account const kNonExistent{"NonExistent"}; + static PrettyAsset const kGhostIouAsset = kNonExistent["GST"]; PrettyAsset const vaultPseudoIouAsset = vault.pseudoAccount["PSD"]; auto const badKeylet = keylet::loanbroker(alice.id(), env.seq(alice)); @@ -235,7 +236,7 @@ class LoanBroker_test : public beast::unit_test::Suite BEAST_EXPECT( pseudo->at(sfFlags) == (lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth)); BEAST_EXPECT(pseudo->at(sfSequence) == 0); - BEAST_EXPECT(pseudo->at(sfBalance) == beast::kZERO); + BEAST_EXPECT(pseudo->at(sfBalance) == beast::kZero); BEAST_EXPECT(pseudo->at(sfOwnerCount) == (vault.asset.raw().native() ? 0 : 1)); BEAST_EXPECT(!pseudo->isFieldPresent(sfAccountTxnID)); BEAST_EXPECT(!pseudo->isFieldPresent(sfRegularKey)); @@ -300,41 +301,41 @@ class LoanBroker_test : public beast::unit_test::Suite // Test cover clawback failure cases BEFORE depositing any cover // Need one of brokerID or amount env(coverClawback(alice), Ter(temINVALID)); - env(coverClawback(alice), kLOAN_BROKER_ID(uint256(0)), Ter(temINVALID)); - env(coverClawback(alice), kAMOUNT(XRP(1000)), Ter(temBAD_AMOUNT)); - env(coverClawback(alice), kAMOUNT(vault.asset(-10)), Ter(temBAD_AMOUNT)); + env(coverClawback(alice), kLoanBrokerId(uint256(0)), Ter(temINVALID)); + env(coverClawback(alice), kAmount(XRP(1000)), Ter(temBAD_AMOUNT)); + env(coverClawback(alice), kAmount(vault.asset(-10)), Ter(temBAD_AMOUNT)); // Clawbacks with an MPT need to specify the broker ID - env(coverClawback(alice), kAMOUNT(kBAD_MPT_ASSET(1)), Ter(temINVALID)); - env(coverClawback(evan), kLOAN_BROKER_ID(vault.vaultID), Ter(tecNO_ENTRY)); + env(coverClawback(alice), kAmount(kBadMptAsset(1)), Ter(temINVALID)); + env(coverClawback(evan), kLoanBrokerId(vault.vaultID), Ter(tecNO_ENTRY)); // Only the issuer can clawback - env(coverClawback(alice), kLOAN_BROKER_ID(keylet.key), Ter(tecNO_PERMISSION)); + env(coverClawback(alice), kLoanBrokerId(keylet.key), Ter(tecNO_PERMISSION)); if (vault.asset.raw().native()) { // Can not clawback XRP under any circumstances - env(coverClawback(issuer), kLOAN_BROKER_ID(keylet.key), Ter(tecNO_PERMISSION)); + env(coverClawback(issuer), kLoanBrokerId(keylet.key), Ter(tecNO_PERMISSION)); } else { if (vault.asset.raw().holds()) { - // Clawbacks without a kLOAN_BROKER_ID need to specify an IOU + // Clawbacks without a kLoanBrokerId need to specify an IOU // with the broker's pseudo-account as the issuer - env(coverClawback(alice), kAMOUNT(kGHOST_IOU_ASSET(1)), Ter(tecNO_ENTRY)); - env(coverClawback(alice), kAMOUNT(kBAD_IOU_ASSET(1)), Ter(tecOBJECT_NOT_FOUND)); + env(coverClawback(alice), kAmount(kGhostIouAsset(1)), Ter(tecNO_ENTRY)); + env(coverClawback(alice), kAmount(kBadIouAsset(1)), Ter(tecOBJECT_NOT_FOUND)); // Pseudo-account is not for a broker env(coverClawback(alice), - kAMOUNT(vaultPseudoIouAsset(1)), + kAmount(vaultPseudoIouAsset(1)), Ter(tecOBJECT_NOT_FOUND)); // If we specify a pseudo-account as the IOU amount, it // needs to match the loan broker env(coverClawback(issuer), - kLOAN_BROKER_ID(keylet.key), - kAMOUNT(badBrokerPseudoIouAsset(10)), + kLoanBrokerId(keylet.key), + kAmount(badBrokerPseudoIouAsset(10)), Ter(tecWRONG_ASSET)); PrettyAsset const brokerWrongCurrencyAsset = pseudoAccount["WAT"]; env(coverClawback(issuer), - kLOAN_BROKER_ID(keylet.key), - kAMOUNT(brokerWrongCurrencyAsset(10)), + kLoanBrokerId(keylet.key), + kAmount(brokerWrongCurrencyAsset(10)), Ter(tecWRONG_ASSET)); } else @@ -342,13 +343,13 @@ class LoanBroker_test : public beast::unit_test::Suite // Clawbacks with an MPT need to specify the broker ID, even // if the asset is valid BEAST_EXPECT(vault.asset.raw().holds()); - env(coverClawback(alice), kAMOUNT(vault.asset(10)), Ter(temINVALID)); + env(coverClawback(alice), kAmount(vault.asset(10)), Ter(temINVALID)); } // Since no cover has been deposited, there's nothing to claw // back env(coverClawback(issuer), - kLOAN_BROKER_ID(keylet.key), - kAMOUNT(vault.asset(10)), + kLoanBrokerId(keylet.key), + kAmount(vault.asset(10)), Ter(tecINSUFFICIENT_FUNDS)); } env.close(); @@ -371,13 +372,13 @@ class LoanBroker_test : public beast::unit_test::Suite { TER const expected = vault.asset.raw().holds() ? tecNO_AUTH : tecNO_LINE; env(coverWithdraw(alice, keylet.key, vault.asset(1)), - kDESTINATION(bystander), + kDestination(bystander), Ter(expected)); } // Can not withdraw to the zero address env(coverWithdraw(alice, keylet.key, vault.asset(1)), - kDESTINATION(AccountID{}), + kDestination(AccountID{}), Ter(temMALFORMED)); // Withdraw some of the cover amount @@ -392,20 +393,20 @@ class LoanBroker_test : public beast::unit_test::Suite // Withdraw some more. Send it to Evan. Very generous, considering // how much trouble he's been. - env(coverWithdraw(alice, keylet.key, vault.asset(1)), kDESTINATION(evan)); + env(coverWithdraw(alice, keylet.key, vault.asset(1)), kDestination(evan)); env.close(); verifyCoverAmount(7); // Withdraw some more. Send it to Evan. Very generous, considering // how much trouble he's been. - env(coverWithdraw(alice, keylet.key, vault.asset(1)), kDESTINATION(evan), Dtag(3)); + env(coverWithdraw(alice, keylet.key, vault.asset(1)), kDestination(evan), Dtag(3)); env.close(); verifyCoverAmount(6); if (!vault.asset.raw().native()) { // Issuer claws back some of the cover - env(coverClawback(issuer), kLOAN_BROKER_ID(keylet.key), kAMOUNT(vault.asset(2))); + env(coverClawback(issuer), kLoanBrokerId(keylet.key), kAmount(vault.asset(2))); env.close(); verifyCoverAmount(4); @@ -419,32 +420,32 @@ class LoanBroker_test : public beast::unit_test::Suite // defer autofills until submission time env.json( coverClawback(issuer), - kLOAN_BROKER_ID(keylet.key), - Fee(kNONE), - Seq(kNONE), - Sig(kNONE)), + kLoanBrokerId(keylet.key), + Fee(kNone), + Seq(kNone), + Sig(kNone)), env.json( coverClawback(issuer), - kLOAN_BROKER_ID(keylet.key), - kAMOUNT(vault.asset(0)), - Fee(kNONE), - Seq(kNONE), - Sig(kNONE)), + kLoanBrokerId(keylet.key), + kAmount(vault.asset(0)), + Fee(kNone), + Seq(kNone), + Sig(kNone)), env.json( coverClawback(issuer), - kLOAN_BROKER_ID(keylet.key), - kAMOUNT(vault.asset(6)), - Fee(kNONE), - Seq(kNONE), - Sig(kNONE)), + kLoanBrokerId(keylet.key), + kAmount(vault.asset(6)), + Fee(kNone), + Seq(kNone), + Sig(kNone)), // amount will be truncated to what's available env.json( coverClawback(issuer), - kLOAN_BROKER_ID(keylet.key), - kAMOUNT(vault.asset(100)), - Fee(kNONE), - Seq(kNONE), - Sig(kNONE)), + kLoanBrokerId(keylet.key), + kAmount(vault.asset(100)), + Fee(kNone), + Seq(kNone), + Sig(kNone)), }) { // Issuer claws it all back @@ -460,7 +461,7 @@ class LoanBroker_test : public beast::unit_test::Suite } // no-op - env(set(alice, vault.vaultID), kLOAN_BROKER_ID(keylet.key)); + env(set(alice, vault.vaultID), kLoanBrokerId(keylet.key)); env.close(); // Make modifications to the broker @@ -477,9 +478,9 @@ class LoanBroker_test : public beast::unit_test::Suite // Debt maximum: explicit 0 // Data: explicit empty env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kDEBT_MAXIMUM(Number(0)), - kDATA("")); + kLoanBrokerId(broker->key()), + kDebtMaximum(Number(0)), + kData("")); env.close(); // Check the updated fields @@ -504,7 +505,7 @@ class LoanBroker_test : public beast::unit_test::Suite auto const aliceBalance = env.balance(alice, vault.asset); auto const coverFunds = env.balance(pseudoAccount, vault.asset); BEAST_EXPECT(coverFunds.number() == broker->at(sfCoverAvailable)); - BEAST_EXPECT(coverFunds != beast::kZERO); + BEAST_EXPECT(coverFunds != beast::kZero); verifyCoverAmount(6); // delete the broker @@ -530,7 +531,7 @@ class LoanBroker_test : public beast::unit_test::Suite (aliceBalance.value().native() ? STAmount(env.current()->fees().base.value()) : vault.asset(0)); env.require(Balance(alice, expectedBalance)); - env.require(Balance(pseudoAccount, vault.asset(kNONE))); + env.require(Balance(pseudoAccount, vault.asset(kNone))); } } @@ -572,7 +573,7 @@ class LoanBroker_test : public beast::unit_test::Suite env(pay(issuer, alice, iouAsset(100'000))); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); env.close(); PrettyAsset const mptAsset = mptt["MPT"]; @@ -653,58 +654,56 @@ class LoanBroker_test : public beast::unit_test::Suite // field length validation // sfData: good length, bad account env(set(evan, vault.vaultID), - kDATA(std::string(kMAX_DATA_PAYLOAD_LENGTH, 'X')), + kData(std::string(kMaxDataPayloadLength, 'X')), Ter(tecNO_PERMISSION)); // sfData: too long env(set(evan, vault.vaultID), - kDATA(std::string(kMAX_DATA_PAYLOAD_LENGTH + 1, 'Y')), + kData(std::string(kMaxDataPayloadLength + 1, 'Y')), Ter(temINVALID)); // sfManagementFeeRate: good value, bad account env(set(evan, vault.vaultID), - kMANAGEMENT_FEE_RATE(kMAX_MANAGEMENT_FEE_RATE), + kManagementFeeRate(kMaxManagementFeeRate), Ter(tecNO_PERMISSION)); // sfManagementFeeRate: too big env(set(evan, vault.vaultID), - kMANAGEMENT_FEE_RATE(kMAX_MANAGEMENT_FEE_RATE + TenthBips16(10)), + kManagementFeeRate(kMaxManagementFeeRate + TenthBips16(10)), Ter(temINVALID)); // sfCoverRateMinimum and sfCoverRateLiquidation are linked // Cover: good value, bad account env(set(evan, vault.vaultID), - kCOVER_RATE_MINIMUM(kMAX_COVER_RATE), - kCOVER_RATE_LIQUIDATION(kMAX_COVER_RATE), + kCoverRateMinimum(kMaxCoverRate), + kCoverRateLiquidation(kMaxCoverRate), Ter(tecNO_PERMISSION)); // CoverMinimum: too big env(set(evan, vault.vaultID), - kCOVER_RATE_MINIMUM(kMAX_COVER_RATE + 1), - kCOVER_RATE_LIQUIDATION(kMAX_COVER_RATE + 1), + kCoverRateMinimum(kMaxCoverRate + 1), + kCoverRateLiquidation(kMaxCoverRate + 1), Ter(temINVALID)); // CoverLiquidation: too big env(set(evan, vault.vaultID), - kCOVER_RATE_MINIMUM(kMAX_COVER_RATE / 2), - kCOVER_RATE_LIQUIDATION(kMAX_COVER_RATE + 1), + kCoverRateMinimum(kMaxCoverRate / 2), + kCoverRateLiquidation(kMaxCoverRate + 1), Ter(temINVALID)); // Cover: zero min, non-zero liquidation - implicit and // explicit zero values. + env(set(evan, vault.vaultID), kCoverRateLiquidation(kMaxCoverRate), Ter(temINVALID)); env(set(evan, vault.vaultID), - kCOVER_RATE_LIQUIDATION(kMAX_COVER_RATE), - Ter(temINVALID)); - env(set(evan, vault.vaultID), - kCOVER_RATE_MINIMUM(tenthBipsZero), - kCOVER_RATE_LIQUIDATION(kMAX_COVER_RATE), + kCoverRateMinimum(tenthBipsZero), + kCoverRateLiquidation(kMaxCoverRate), Ter(temINVALID)); // Cover: non-zero min, zero liquidation - implicit and // explicit zero values. - env(set(evan, vault.vaultID), kCOVER_RATE_MINIMUM(kMAX_COVER_RATE), Ter(temINVALID)); + env(set(evan, vault.vaultID), kCoverRateMinimum(kMaxCoverRate), Ter(temINVALID)); env(set(evan, vault.vaultID), - kCOVER_RATE_MINIMUM(kMAX_COVER_RATE), - kCOVER_RATE_LIQUIDATION(tenthBipsZero), + kCoverRateMinimum(kMaxCoverRate), + kCoverRateLiquidation(tenthBipsZero), Ter(temINVALID)); // sfDebtMaximum: good value, bad account - env(set(evan, vault.vaultID), kDEBT_MAXIMUM(Number(0)), Ter(tecNO_PERMISSION)); + env(set(evan, vault.vaultID), kDebtMaximum(Number(0)), Ter(tecNO_PERMISSION)); // sfDebtMaximum: overflow - env(set(evan, vault.vaultID), kDEBT_MAXIMUM(Number(1, 100)), Ter(temINVALID)); + env(set(evan, vault.vaultID), kDebtMaximum(Number(1, 100)), Ter(temINVALID)); // sfDebtMaximum: negative - env(set(evan, vault.vaultID), kDEBT_MAXIMUM(Number(-1)), Ter(temINVALID)); + env(set(evan, vault.vaultID), kDebtMaximum(Number(-1)), Ter(temINVALID)); std::string testData; lifecycle( @@ -739,61 +738,57 @@ class LoanBroker_test : public beast::unit_test::Suite // fields that can't be changed // LoanBrokerID - env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(nextKeylet.key), - Ter(tecNO_ENTRY)); + env(set(alice, vault.vaultID), kLoanBrokerId(nextKeylet.key), Ter(tecNO_ENTRY)); // VaultID - env(set(alice, nextKeylet.key), - kLOAN_BROKER_ID(broker->key()), - Ter(tecNO_ENTRY)); + env(set(alice, nextKeylet.key), kLoanBrokerId(broker->key()), Ter(tecNO_ENTRY)); // Owner env(set(evan, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), + kLoanBrokerId(broker->key()), Ter(tecNO_PERMISSION)); // ManagementFeeRate env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kMANAGEMENT_FEE_RATE(kMAX_MANAGEMENT_FEE_RATE), + kLoanBrokerId(broker->key()), + kManagementFeeRate(kMaxManagementFeeRate), Ter(temINVALID)); // CoverRateMinimum env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kCOVER_RATE_MINIMUM(kMAX_MANAGEMENT_FEE_RATE), + kLoanBrokerId(broker->key()), + kCoverRateMinimum(kMaxManagementFeeRate), Ter(temINVALID)); // CoverRateLiquidation env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kCOVER_RATE_LIQUIDATION(kMAX_MANAGEMENT_FEE_RATE), + kLoanBrokerId(broker->key()), + kCoverRateLiquidation(kMaxManagementFeeRate), Ter(temINVALID)); // fields that can be changed testData = "Test Data 1234"; // Bad data: too long env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kDATA(std::string(kMAX_DATA_PAYLOAD_LENGTH + 1, 'W')), + kLoanBrokerId(broker->key()), + kData(std::string(kMaxDataPayloadLength + 1, 'W')), Ter(temINVALID)); // Bad debt maximum env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kDEBT_MAXIMUM(Number(-175, -1)), + kLoanBrokerId(broker->key()), + kDebtMaximum(Number(-175, -1)), Ter(temINVALID)); Number debtMax{175, -1}; if (vault.asset.integral()) { env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kDATA(testData), - kDEBT_MAXIMUM(debtMax), + kLoanBrokerId(broker->key()), + kData(testData), + kDebtMaximum(debtMax), Ter(tecPRECISION_LOSS)); roundToAsset(vault.asset, debtMax); } // Data & Debt maximum env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kDATA(testData), - kDEBT_MAXIMUM(debtMax)); + kLoanBrokerId(broker->key()), + kData(testData), + kDebtMaximum(debtMax)); }, [&](SLE::const_ref broker) { // Check the updated fields @@ -816,15 +811,15 @@ class LoanBroker_test : public beast::unit_test::Suite badVault, [&](jtx::JTx const& jv) { testData = "spam spam spam spam"; - // Finally, create another Loan Broker with kNONE of the + // Finally, create another Loan Broker with kNone of the // values at default return env.jt( jv, - kDATA(testData), - kMANAGEMENT_FEE_RATE(TenthBips16(123)), - kDEBT_MAXIMUM(Number(9)), - kCOVER_RATE_MINIMUM(TenthBips32(100)), - kCOVER_RATE_LIQUIDATION(TenthBips32(200))); + kData(testData), + kManagementFeeRate(TenthBips16(123)), + kDebtMaximum(Number(9)), + kCoverRateMinimum(TenthBips32(100)), + kCoverRateLiquidation(TenthBips32(200))); }, [&](SLE::const_ref broker) { // Extra checks @@ -837,9 +832,9 @@ class LoanBroker_test : public beast::unit_test::Suite [&](SLE::const_ref broker) { // Reset Data & Debt maximum to default values env(set(alice, vault.vaultID), - kLOAN_BROKER_ID(broker->key()), - kDATA(""), - kDEBT_MAXIMUM(Number(0))); + kLoanBrokerId(broker->key()), + kData(""), + kDebtMaximum(Number(0))); }, [&](SLE::const_ref broker) { // Check the updated fields @@ -963,7 +958,7 @@ class LoanBroker_test : public beast::unit_test::Suite // preclaim: tecNO_DST Account const bogus{"bogus"}; env(coverWithdraw(alice, brokerKeylet.key, asset(10)), - kDESTINATION(bogus), + kDestination(bogus), Ter(tecNO_DST)); // preclaim: tecDST_TAG_NEEDED @@ -972,7 +967,7 @@ class LoanBroker_test : public beast::unit_test::Suite env(fset(dest, asfRequireDest)); env.close(); env(coverWithdraw(alice, brokerKeylet.key, asset(10)), - kDESTINATION(dest), + kDestination(dest), Ter(tecDST_TAG_NEEDED)); // preclaim: tecNO_PERMISSION @@ -980,7 +975,7 @@ class LoanBroker_test : public beast::unit_test::Suite env(fset(dest, asfDepositAuth)); env.close(); env(coverWithdraw(alice, brokerKeylet.key, asset(10)), - kDESTINATION(dest), + kDestination(dest), Ter(tecNO_PERMISSION)); // preclaim: tecFROZEN @@ -989,19 +984,19 @@ class LoanBroker_test : public beast::unit_test::Suite env(fset(issuer, asfGlobalFreeze)); env.close(); env(coverWithdraw(alice, brokerKeylet.key, asset(10)), - kDESTINATION(dest), + kDestination(dest), Ter(tecFROZEN)); // preclaim:: tecFROZEN (deep frozen) env(fclear(issuer, asfGlobalFreeze)); env(trust(issuer, asset(1'000), dest, tfSetFreeze | tfSetDeepFreeze)); env(coverWithdraw(alice, brokerKeylet.key, asset(10)), - kDESTINATION(dest), + kDestination(dest), Ter(tecFROZEN)); // preclaim: tecPSEUDO_ACCOUNT env(coverWithdraw(alice, brokerKeylet.key, asset(10)), - kDESTINATION(vaultInfo.pseudoAccount), + kDestination(vaultInfo.pseudoAccount), Ter(tecPSEUDO_ACCOUNT)); } @@ -1011,32 +1006,32 @@ class LoanBroker_test : public beast::unit_test::Suite testZeroBrokerID([&]() { return env.json( coverClawback(alice), - kLOAN_BROKER_ID(brokerKeylet.key), - kAMOUNT(vaultInfo.asset(2))); + kLoanBrokerId(brokerKeylet.key), + kAmount(vaultInfo.asset(2))); }); if (asset.holds()) { // preclaim: AllowTrustLineClawback is not set env(coverClawback(issuer), - kLOAN_BROKER_ID(brokerKeylet.key), - kAMOUNT(vaultInfo.asset(2)), + kLoanBrokerId(brokerKeylet.key), + kAmount(vaultInfo.asset(2)), Ter(tecNO_PERMISSION)); // preclaim: NoFreeze is set env(fset(issuer, asfAllowTrustLineClawback | asfNoFreeze)); env.close(); env(coverClawback(issuer), - kLOAN_BROKER_ID(brokerKeylet.key), - kAMOUNT(vaultInfo.asset(2)), + kLoanBrokerId(brokerKeylet.key), + kAmount(vaultInfo.asset(2)), Ter(tecNO_PERMISSION)); } else { // preclaim: MPTCanClawback is not set or MPTCanLock is not set env(coverClawback(issuer), - kLOAN_BROKER_ID(brokerKeylet.key), - kAMOUNT(vaultInfo.asset(2)), + kLoanBrokerId(brokerKeylet.key), + kAmount(vaultInfo.asset(2)), Ter(tecNO_PERMISSION)); } env.close(); @@ -1078,11 +1073,11 @@ class LoanBroker_test : public beast::unit_test::Suite { // preflight: temINVALID (empty/zero broker id) testZeroBrokerID([&]() { - return env.json(set(alice, vaultInfo.vaultID), kLOAN_BROKER_ID(brokerKeylet.key)); + return env.json(set(alice, vaultInfo.vaultID), kLoanBrokerId(brokerKeylet.key)); }); // preflight: temINVALID (empty/zero vault id) testZeroVaultID([&]() { - return env.json(set(alice, vaultInfo.vaultID), kLOAN_BROKER_ID(brokerKeylet.key)); + return env.json(set(alice, vaultInfo.vaultID), kLoanBrokerId(brokerKeylet.key)); }); if (asset.holds()) @@ -1121,13 +1116,13 @@ class LoanBroker_test : public beast::unit_test::Suite env.fund(XRP(100'000), alice); env.close(); - auto jtx = env.jt(coverClawback(alice), kAMOUNT(usd(100))); + auto jtx = env.jt(coverClawback(alice), kAmount(usd(100))); // holder == account env(jtx, Ter(temINVALID)); // holder == beast::zero - STAmount const bad(Issue{usd.currency, beast::kZERO}, 100); + STAmount const bad(Issue{usd.currency, beast::kZero}, 100); jtx.jv[sfAmount] = bad.getJson(); jtx.stx = env.ust(jtx); Serializer s; @@ -1249,7 +1244,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}; @@ -1287,7 +1282,7 @@ class LoanBroker_test : public beast::unit_test::Suite .env = env, .issuer = issuer, .holders = {alice}, - .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth | tfMPTCanClawback | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTRequireAuth | tfMPTCanClawback | tfMPTCanLock, .authHolder = true, }); @@ -1371,8 +1366,8 @@ class LoanBroker_test : public beast::unit_test::Suite // Issuer can always cover clawback. The holder authorization is n/a. forUnauthAuth([&](bool) { env(coverClawback(issuer), - kLOAN_BROKER_ID(brokerKeylet.key), - kAMOUNT(vaultInfo.asset(1))); + kLoanBrokerId(brokerKeylet.key), + kAmount(vaultInfo.asset(1))); }); } @@ -1391,7 +1386,7 @@ class LoanBroker_test : public beast::unit_test::Suite env.close(); PrettyAsset const asset = [&]() { - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); env.close(); PrettyAsset const mptAsset = mptt["MPT"]; @@ -1445,33 +1440,33 @@ class LoanBroker_test : public beast::unit_test::Suite tx2[sfDebtMaximum] = 0; env(tx2, Ter(tesSUCCESS)); - tx2[sfDebtMaximum] = json::Value::kMAX_INT; + tx2[sfDebtMaximum] = json::Value::kMaxInt; env(tx2, Ter(tesSUCCESS)); { auto const dm = power(2, 64) - 1; - BEAST_EXPECT(dm > kMAX_MP_TOKEN_AMOUNT); + BEAST_EXPECT(dm > kMaxMpTokenAmount); tx2[sfDebtMaximum] = dm; env(tx2, Ter(temINVALID)); } { auto const dm = power(2, 63) - 1; - BEAST_EXPECTS(dm > kMAX_MP_TOKEN_AMOUNT, to_string(dm)); + BEAST_EXPECTS(dm > kMaxMpTokenAmount, to_string(dm)); tx2[sfDebtMaximum] = dm; env(tx2, Ter(temINVALID)); } { auto const dm = power(2, 63) - 3; - BEAST_EXPECTS(dm == kMAX_MP_TOKEN_AMOUNT, to_string(dm)); + BEAST_EXPECTS(dm == kMaxMpTokenAmount, to_string(dm)); tx2[sfDebtMaximum] = dm; env(tx2, Ter(tesSUCCESS)); } { auto const dm = 2 * (power(2, 62) - 1) + 1; - BEAST_EXPECTS(dm == kMAX_MP_TOKEN_AMOUNT, to_string(dm)); + BEAST_EXPECTS(dm == kMaxMpTokenAmount, to_string(dm)); tx2[sfDebtMaximum] = dm; env(tx2, Ter(tesSUCCESS)); } @@ -1533,14 +1528,14 @@ class LoanBroker_test : public beast::unit_test::Suite {2'000, 2'500, 250, tesSUCCESS}, // issuer can issue 500 tokens (250 VaultDeposit + // 250 LoanBrokerCoverDeposit). MaximumAmount is default. - {kMAX_MP_TOKEN_AMOUNT - 500, std::nullopt, 250, tesSUCCESS}, + {kMaxMpTokenAmount - 500, std::nullopt, 250, tesSUCCESS}, // issuer can issue 500, and fails on depositing 1'000 {2'000, 2'500, 1'000, tecINSUFFICIENT_FUNDS}, // issuer has already issued MaximumAmount {2'000, 2'000, 1'000, tecINSUFFICIENT_FUNDS}, // issuer has already issued MaximumAmount. MaximumAmount is // default. - {kMAX_MP_TOKEN_AMOUNT, std::nullopt, 250, tecINSUFFICIENT_FUNDS}, + {kMaxMpTokenAmount, std::nullopt, 250, tecINSUFFICIENT_FUNDS}, }; for (auto const& [pay, max, deposit, err] : mptTests) { @@ -1550,7 +1545,7 @@ class LoanBroker_test : public beast::unit_test::Suite .issuer = issuer, .holders = {holder}, .pay = pay, - .flags = kMPT_DEX_FLAGS, + .flags = kMptDexFlags, .maxAmt = max}); return std::make_tuple(token, token(deposit), err); }); @@ -1582,6 +1577,210 @@ class LoanBroker_test : public beast::unit_test::Suite env(loanBroker::set(lender, vaultKeylet.key), Ter(tecFROZEN)); } + void + testLoanBrokerDeleteLockedMPT(FeatureBitset features) + { + testcase << "LoanBrokerDelete - locked broker pseudo-account MPT"; + using namespace jtx; + using namespace loanBroker; + + Account const issuer("issuer"); + Account const alice("alice"); + + auto const withFix = features[fixCleanup3_2_0]; + Env env(*this, features); + env.fund(XRP(100'000), issuer, alice); + env.close(); + + // Create MPT with locking enabled + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); + + PrettyAsset const mpt{mptt.issuanceID()}; + + // Fund alice + mptt.authorize({.account = alice}); + env.close(); + env(pay(issuer, alice, mpt(100'000))); + env.close(); + + // Create vault + Vault const vault{env}; + auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt}); + env(tx); + env.close(); + + // Deposit into vault + env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(10'000)})); + env.close(); + + // Create loan broker + auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice)); + env(set(alice, vaultKeylet.key)); + env.close(); + + // Deposit cover + env(coverDeposit(alice, brokerKeylet.key, mpt(5'000).value())); + env.close(); + + // Verify cover is deposited + auto const broker = env.le(brokerKeylet); + if (!BEAST_EXPECT(broker)) + return; + BEAST_EXPECT(broker->at(sfCoverAvailable) > 0); + + // Get the broker pseudo-account ID + auto const brokerPseudoID = broker->at(sfAccount); + + // Verify the broker pseudo-account has an MPToken + auto const pseudoMptKey = keylet::mptoken(mptt.issuanceID(), brokerPseudoID); + auto const pseudoMpt = env.le(pseudoMptKey); + if (!BEAST_EXPECT(pseudoMpt)) + return; + + // Issuer locks the broker pseudo-account's individual MPToken + { + json::Value jv; + jv[jss::Account] = issuer.human(); + jv[sfMPTokenIssuanceID] = to_string(mptt.issuanceID()); + jv[jss::Holder] = toBase58(brokerPseudoID); + jv[jss::TransactionType] = jss::MPTokenIssuanceSet; + jv[jss::Flags] = tfMPTLock; + env(jv); + env.close(); + } + + // Verify the pseudo-account's MPToken is now locked + { + auto const sle = env.le(pseudoMptKey); + if (!BEAST_EXPECT(sle)) + return; + BEAST_EXPECT(sle->isFlag(lsfMPTLocked)); + } + + // Record alice's balance before deletion + auto const aliceBalanceBefore = env.balance(alice, mpt); + + // With fixCleanup3_2_0, preclaim() checks the broker pseudo-account's + // freeze/lock state via checkFrozen(), so deletion is blocked. + // Without the fix, the check is missing and the locked cover is + // returned to the owner. + if (withFix) + { + env(del(alice, brokerKeylet.key), Ter(tecLOCKED)); + env.close(); + + // Verify the broker is not deleted + BEAST_EXPECT(env.le(brokerKeylet) != nullptr); + + // Verify alice did not receive the cover despite the lock + auto const aliceBalanceAfter = env.balance(alice, mpt); + BEAST_EXPECT(aliceBalanceAfter == aliceBalanceBefore); + + // Verify the locked MPToken was not deleted + BEAST_EXPECT(env.le(pseudoMptKey) != nullptr); + } + else + { + env(del(alice, brokerKeylet.key), Ter(tesSUCCESS)); + env.close(); + + // Verify the broker is deleted + BEAST_EXPECT(env.le(brokerKeylet) == nullptr); + + // Verify alice received the cover despite the lock + auto const aliceBalanceAfter = env.balance(alice, mpt); + BEAST_EXPECT(aliceBalanceAfter > aliceBalanceBefore); + + // Verify the locked MPToken was deleted + BEAST_EXPECT(env.le(pseudoMptKey) == nullptr); + } + } + + void + testLoanBrokerDeleteFrozenIOU(FeatureBitset features) + { + testcase << "LoanBrokerDelete - frozen broker pseudo-account IOU"; + using namespace jtx; + using namespace loanBroker; + + Account const issuer("issuer"); + Account const alice("alice"); + + auto const withFix = features[fixCleanup3_2_0]; + Env env(*this, features); + env.fund(XRP(100'000), issuer, alice); + env.close(); + + auto const iou = issuer["IOU"]; + + // Set up trust lines and fund alice + env(trust(alice, iou(1'000'000))); + env.close(); + env(pay(issuer, alice, iou(100'000))); + env.close(); + + // Create vault + Vault const vault{env}; + auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = iou.asset()}); + env(tx); + env.close(); + + // Deposit into vault + env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = iou(10'000)})); + env.close(); + + // Create loan broker + auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice)); + env(set(alice, vaultKeylet.key)); + env.close(); + + // Deposit cover + env(coverDeposit(alice, brokerKeylet.key, iou(5'000))); + env.close(); + + // Verify cover is deposited + auto const broker = env.le(brokerKeylet); + if (!BEAST_EXPECT(broker)) + return; + BEAST_EXPECT(broker->at(sfCoverAvailable) > 0); + + // Get the broker pseudo-account + auto const brokerPseudoID = broker->at(sfAccount); + auto const brokerPseudo = Account("BrokerPseudo", brokerPseudoID); + + // Issuer freezes the broker pseudo-account's trust line + env(trust(issuer, brokerPseudo["IOU"](0), tfSetFreeze)); + env.close(); + + // Record alice's balance before deletion attempt + auto const aliceBalanceBefore = env.balance(alice, iou); + + // With fixCleanup3_2_0, preclaim() checks the broker + // pseudo-account's freeze state via checkFrozen(), so + // deletion is blocked early with tecFROZEN. + // Without the fix, preclaim() does not check the pseudo-account, + // but the TransfersNotFrozen invariant catches the frozen transfer + // in doApply() and fails with tecINVARIANT_FAILED. + // Either way, the broker survives and alice's balance is unchanged. + if (withFix) + { + env(del(alice, brokerKeylet.key), Ter(tecFROZEN)); + } + else + { + env(del(alice, brokerKeylet.key), Ter(tecINVARIANT_FAILED)); + } + env.close(); + + // Broker still exists + BEAST_EXPECT(env.le(brokerKeylet) != nullptr); + + // Alice's balance unchanged + auto const aliceBalanceAfter = env.balance(alice, iou); + BEAST_EXPECT(aliceBalanceAfter == aliceBalanceBefore); + } + void testRIPD4274IOU() { @@ -1666,7 +1865,7 @@ class LoanBroker_test : public beast::unit_test::Suite env.close(); env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}), - loanBroker::kDESTINATION(dest), + loanBroker::kDestination(dest), Ter(std::ignore)); BEAST_EXPECT(env.ter() == tecNO_LINE); env.close(); @@ -1683,7 +1882,7 @@ class LoanBroker_test : public beast::unit_test::Suite env.close(); env(loanBroker::coverWithdraw(broker, brokerKeylet.key, token(100)), - loanBroker::kDESTINATION(dest), + loanBroker::kDestination(dest), Ter(std::ignore)); BEAST_EXPECT(env.ter() == tecNO_LINE); env.close(); @@ -1695,7 +1894,7 @@ class LoanBroker_test : public beast::unit_test::Suite env.close(); env(loanBroker::coverWithdraw(broker, brokerKeylet.key, token(100)), - loanBroker::kDESTINATION(dest), + loanBroker::kDestination(dest), Ter(std::ignore)); BEAST_EXPECT(env.ter() == tecNO_LINE); env.close(); @@ -1740,7 +1939,7 @@ class LoanBroker_test : public beast::unit_test::Suite .issuer = issuer, .holders = {broker, dest}, .pay = 2'000, - .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth, + .flags = kMptDexFlags | tfMPTRequireAuth, .authHolder = true, .maxAmt = 5'000}); // unauthorize dest @@ -1754,7 +1953,7 @@ class LoanBroker_test : public beast::unit_test::Suite .issuer = issuer, .holders = {broker, dest}, .pay = 2'000, - .flags = kMPT_DEX_FLAGS, + .flags = kMptDexFlags, .maxAmt = 4'000}); BEAST_EXPECT(env.balance(issuer, tester) == tester(-4'000)); return tester; @@ -1765,7 +1964,7 @@ class LoanBroker_test : public beast::unit_test::Suite .issuer = issuer, .holders = {broker}, .pay = 2'000, - .flags = kMPT_DEX_FLAGS, + .flags = kMptDexFlags, .maxAmt = 4'000}); } default: @@ -1787,7 +1986,7 @@ class LoanBroker_test : public beast::unit_test::Suite env.close(); env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}), - loanBroker::kDESTINATION(dest), + loanBroker::kDestination(dest), Ter(std::ignore)); // Shouldn't fail if at MaximumAmount since no new tokens are issued @@ -1811,7 +2010,7 @@ class LoanBroker_test : public beast::unit_test::Suite env.close(); env(loanBroker::coverWithdraw(broker, brokerKeylet.key, token(100)), - loanBroker::kDESTINATION(dest), + loanBroker::kDestination(dest), Ter(std::ignore)); BEAST_EXPECT(env.ter() == err); env.close(); @@ -1829,10 +2028,221 @@ class LoanBroker_test : public beast::unit_test::Suite testRIPD4274MPT(); } + // Exercises canApplyToBrokerCover (fixCleanup3_2_0): a deposit, withdraw, + // or clawback whose amount rounds to zero at sfCoverAvailable's precision + // scale must be rejected with tecPRECISION_LOSS once the amendment is on, + // and must silently succeed without changing sfCoverAvailable when off. + void + testCoverPrecisionGuard() + { + using namespace jtx; + using namespace loanBroker; + + Account const issuer{"issuer"}; + Account const alice{"alice"}; + + // sfCoverAvailable = 10 IOU → STAmount exponent = -14. + // Anything < 5e-15 rounds to zero at that scale. + // 1e-16 is the representative sub-ULP probe amount. + + // Shared setup: funds accounts, creates a vault + broker with 10 IOU + // cover, and returns {brokerKeylet, iou}. + auto const setup = [&](Env& env) -> std::pair { + Vault const vault{env}; + + env.fund(XRP(100'000), issuer, alice); + env.close(); + env(fset(issuer, asfAllowTrustLineClawback)); + env.close(); + + PrettyAsset const iou = issuer["IOU"]; + env(trust(alice, iou(1'000'000))); + env.close(); + env(pay(issuer, alice, iou(1'000))); + env.close(); + + auto [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = iou}); + env(createTx); + env.close(); + + auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice)); + env(set(alice, vaultKeylet.key)); + env.close(); + + env(coverDeposit(alice, brokerKeylet.key, iou(10))); + env.close(); + + return {brokerKeylet, iou}; + }; + + auto runTestCases = [&](FeatureBitset features) { + TER const expected = + features[fixCleanup3_2_0] ? TER{tecPRECISION_LOSS} : TER{tesSUCCESS}; + + { + testcase("Cover precision guard: Deposit zero-at-scale"); + Env env{*this, features}; + auto const [brokerKeylet, iou] = setup(env); + PrettyAmount const subUlpAmt = iou(Number{1, -16}); + auto const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable); + env(coverDeposit(alice, brokerKeylet.key, subUlpAmt), Ter(expected)); + env.close(); + if (expected == tesSUCCESS) + { + if (auto const broker = env.le(brokerKeylet); BEAST_EXPECT(broker)) + BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore); + } + } + + { + testcase("Cover precision guard: Deposit rounds down"); + // Both cases succeed; post-fix the amount is rounded DOWN to + // cover scale first, so the delta differs from pre-fix + // Input: 1.8e-14 IOU (sub-scale at cover scale -14) + // Pre-fix: 10 + 1.8e-14 → round-to-nearest → + // 10.00000000000002 → delta 2e-14 + // Post-fix: roundToScale(1.8e-14, -14, Downward) = 1e-14; + // 10 + 1e-14 = 10.00000000000001 → delta 1e-14 + Env env{*this, features}; + auto const [brokerKeylet, iou] = setup(env); + PrettyAmount const subUlpAmt = iou(Number{18, -15}); + auto const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable); + env(coverDeposit(alice, brokerKeylet.key, subUlpAmt), Ter(tesSUCCESS)); + env.close(); + auto const brokerAfter = env.le(brokerKeylet); + if (!BEAST_EXPECT(brokerAfter)) + return; + + Number const delta = features[fixCleanup3_2_0] ? Number{1, -14} : Number{2, -14}; + BEAST_EXPECT(brokerAfter->at(sfCoverAvailable) - coverBefore == delta); + } + + // Property: post-fix, when the user deposits `x` and cover + // gains `x'`, we always have 0 <= x - x' < 1 ULP at cover + // scale (cover holds 10 IOU → ULP = 1e-14). Pre-fix uses + // STAmount's default round-to-nearest during `+=`, which can + // over-deposit (x' > x), so the property only holds with + // fixCleanup3_2_0 enabled. + if (features[fixCleanup3_2_0]) + { + testcase("Cover precision guard: Deposit rounding bound"); + Env env{*this, features}; + auto const [brokerKeylet, iou] = setup(env); + Number const oneUlp{1, -14}; + // Each requested amount lies strictly between 1·ULP and + // 2·ULP at cover scale; post-fix `roundDown` credits + // exactly `oneUlp` and leaves a strictly-positive, + // strictly-sub-ULP residual. + for (Number const requested : {Number{11, -15}, Number{15, -15}, Number{19, -15}}) + { + auto const broker = env.le(brokerKeylet); + if (!BEAST_EXPECT(broker)) + return; + Number const coverBefore = broker->at(sfCoverAvailable); + env(coverDeposit(alice, brokerKeylet.key, iou(requested)), Ter(tesSUCCESS)); + env.close(); + auto const brokerAfter = env.le(brokerKeylet); + if (!BEAST_EXPECT(brokerAfter)) + return; + Number const coverAfter = brokerAfter->at(sfCoverAvailable); + Number const actual = coverAfter - coverBefore; + Number const lost = requested - actual; + BEAST_EXPECT(lost >= Number{0}); + BEAST_EXPECT(lost < oneUlp); + } + } + + { + testcase("Cover precision guard: Withdraw"); + Env env{*this, features}; + auto const [brokerKeylet, iou] = setup(env); + PrettyAmount const subUlpAmt = iou(Number{1, -16}); + auto const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable); + auto const aliceBalanceBefore = env.balance(alice, iou); + env(coverWithdraw(alice, brokerKeylet.key, subUlpAmt), Ter(expected)); + env.close(); + if (expected == tesSUCCESS) + { + if (auto const broker = env.le(brokerKeylet); BEAST_EXPECT(broker)) + BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore); + BEAST_EXPECT(env.balance(alice, iou) == aliceBalanceBefore); + } + } + + { + testcase("Cover precision guard: Clawback"); + Env env{*this, features}; + auto const [brokerKeylet, iou] = setup(env); + PrettyAmount const subUlpAmt = iou(Number{1, -16}); + auto const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable); + env(coverClawback(issuer), + kLoanBrokerId(brokerKeylet.key), + kAmount(subUlpAmt), + Ter(expected)); + env.close(); + if (expected == tesSUCCESS) + { + if (auto const broker = env.le(brokerKeylet); BEAST_EXPECT(broker)) + BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore); + } + } + + // MPT amounts are integers; scale is 0; the guard never rejects a + // positive integer amount. Verify all three callsites pass with amendment on. + { + testcase("Cover precision guard: MPT min amount passes"); + Env env{*this, all_}; + + env.fund(XRP(100'000), issuer, alice); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); + env.close(); + + PrettyAsset const mptAsset = mptt["MPT"]; + mptt.authorize({.account = alice}); + env.close(); + + env(pay(issuer, alice, mptAsset(100))); + env.close(); + + Vault const vault{env}; + auto [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = mptAsset}); + env(createTx); + env.close(); + + auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice)); + env(set(alice, vaultKeylet.key)); + env.close(); + + env(coverDeposit(alice, brokerKeylet.key, mptAsset(10))); + env.close(); + + env(coverDeposit(alice, brokerKeylet.key, mptAsset(1)), Ter(tesSUCCESS)); + env.close(); + + env(coverWithdraw(alice, brokerKeylet.key, mptAsset(1)), Ter(tesSUCCESS)); + env.close(); + + env(coverClawback(issuer), + kLoanBrokerId(brokerKeylet.key), + kAmount(mptAsset(1)), + Ter(tesSUCCESS)); + env.close(); + } + }; + + runTestCases(all_); + runTestCases(all_ - fixCleanup3_2_0); + } + public: void run() override { + testCoverPrecisionGuard(); + testLoanBrokerSetDebtMaximum(); testLoanBrokerCoverDepositNullVault(); @@ -1850,6 +2260,12 @@ public: testRIPD4274(); + testLoanBrokerDeleteLockedMPT(all_); + testLoanBrokerDeleteLockedMPT(all_ - fixCleanup3_2_0); + + testLoanBrokerDeleteFrozenIOU(all_); + testLoanBrokerDeleteFrozenIOU(all_ - fixCleanup3_2_0); + // TODO: Write clawback failure tests with an issuer / MPT that doesn't // have the right flags set. } diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp index f189196a82..c380655563 100644 --- a/src/test/app/Loan_test.cpp +++ b/src/test/app/Loan_test.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -25,6 +26,8 @@ #include #include +#include + #include #include #include @@ -66,6 +69,7 @@ #include #include #include +#include #include #include #include @@ -87,8 +91,25 @@ class Loan_test : public beast::unit_test::Suite protected: // Ensure that all the features needed for Lending Protocol are included, // even if they are set to unsupported. + FeatureBitset const all_{jtx::testableAmendments()}; + // All 2^N permutations of `all_` with each subset of the given features + // excluded. The first entry is always `all_` itself (empty exclusion); + // the last excludes every feature in the list. + std::vector + amendmentCombinations(std::initializer_list features) const + { + std::vector result{all_}; + for (auto const& f : features) + { + auto const n = result.size(); + for (std::size_t i = 0; i < n; ++i) + result.push_back(result[i] - f); + } + return result; + } + std::string const iouCurrency_{"IOU"}; void @@ -148,12 +169,16 @@ protected: TenthBips32 coverRateLiquidation = percentageToTenthBips(25); std::string data = {}; // NOLINT(readability-redundant-member-init) std::uint32_t flags = 0; + // If set, the vault is created with this sfScale value. Useful for + // tests that need finer loanScale to exercise rounding edge cases. + std::optional vaultScale = + std::nullopt; // NOLINT(readability-redundant-member-init) [[nodiscard]] Number maxCoveredLoanValue(Number const& currentDebt) const { NumberRoundModeGuard const mg(Number::RoundingMode::Downward); - auto debtLimit = coverDeposit * kTENTH_BIPS_PER_UNITY.value() / coverRateMin.value(); + auto debtLimit = coverDeposit * kTenthBipsPerUnity.value() / coverRateMin.value(); return debtLimit - currentDebt; } @@ -161,8 +186,8 @@ protected: static BrokerParameters const& defaults() { - static BrokerParameters const kRESULT{}; - return kRESULT; + static BrokerParameters const kResult{}; + return kResult; } // TODO: create an operator() which returns a transaction similar to @@ -253,31 +278,31 @@ protected: Fee{setFee.value_or(env.current()->fees().base * 2)}(env, jt); if (counterpartyExplicit) - kCOUNTERPARTY(counter)(env, jt); + kCounterparty(counter)(env, jt); if (originationFee) - kLOAN_ORIGINATION_FEE(broker.asset(*originationFee).number())(env, jt); + kLoanOriginationFee(broker.asset(*originationFee).number())(env, jt); if (serviceFee) - kLOAN_SERVICE_FEE(broker.asset(*serviceFee).number())(env, jt); + kLoanServiceFee(broker.asset(*serviceFee).number())(env, jt); if (lateFee) - kLATE_PAYMENT_FEE(broker.asset(*lateFee).number())(env, jt); + kLatePaymentFee(broker.asset(*lateFee).number())(env, jt); if (closeFee) - kCLOSE_PAYMENT_FEE(broker.asset(*closeFee).number())(env, jt); + kClosePaymentFee(broker.asset(*closeFee).number())(env, jt); if (overFee) - kOVERPAYMENT_FEE (*overFee)(env, jt); + kOverpaymentFee (*overFee)(env, jt); if (interest) - kINTEREST_RATE (*interest)(env, jt); + kInterestRate (*interest)(env, jt); if (lateInterest) - kLATE_INTEREST_RATE (*lateInterest)(env, jt); + kLateInterestRate (*lateInterest)(env, jt); if (closeInterest) - kCLOSE_INTEREST_RATE (*closeInterest)(env, jt); + kCloseInterestRate (*closeInterest)(env, jt); if (overpaymentInterest) - kOVERPAYMENT_INTEREST_RATE (*overpaymentInterest)(env, jt); + kOverpaymentInterestRate (*overpaymentInterest)(env, jt); if (payTotal) - kPAYMENT_TOTAL (*payTotal)(env, jt); + kPaymentTotal (*payTotal)(env, jt); if (payInterval) - kPAYMENT_INTERVAL (*payInterval)(env, jt); + kPaymentInterval (*payInterval)(env, jt); if (gracePd) - kGRACE_PERIOD (*gracePd)(env, jt); + kGracePeriod (*gracePd)(env, jt); return env.jt(jt, fN...); } @@ -294,8 +319,8 @@ protected: static PaymentParameters const& defaults() { - static PaymentParameters const kRESULT{}; - return kRESULT; + static PaymentParameters const kResult{}; + return kResult; } }; @@ -368,16 +393,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); } } @@ -402,7 +422,7 @@ protected: env.balance(account, broker.asset) - (balanceBefore - balanceChangeAmount), borrowerScale); env.test.expect( - roundToScale(difference, loanScale) >= beast::kZERO, + roundToScale(difference, loanScale) >= beast::kZero, "Balance before: " + to_string(balanceBefore.value()) + ", expected change: " + to_string(balanceChangeAmount) + ", difference (balance after - expected): " + to_string(difference), @@ -506,6 +526,8 @@ protected: auto const coverRateMinValue = params.coverRateMin; auto [tx, vaultKeylet] = vault.create({.owner = lender, .asset = asset}); + if (params.vaultScale) + tx[sfScale] = *params.vaultScale; env(tx); env.close(); BEAST_EXPECT(env.le(vaultKeylet)); @@ -521,13 +543,13 @@ protected: using namespace loanBroker; env(set(lender, vaultKeylet.key, params.flags), - kDATA(params.data), - kMANAGEMENT_FEE_RATE(params.managementFeeRate), - kDEBT_MAXIMUM(debtMaximumValue), - kCOVER_RATE_MINIMUM(coverRateMinValue), - kCOVER_RATE_LIQUIDATION(TenthBips32(params.coverRateLiquidation))); + kData(params.data), + kManagementFeeRate(params.managementFeeRate), + kDebtMaximum(debtMaximumValue), + kCoverRateMinimum(coverRateMinValue), + kCoverRateLiquidation(TenthBips32(params.coverRateLiquidation))); - if (coverDepositValue != beast::kZERO) + if (coverDepositValue != beast::kZero) env(coverDeposit(lender, keylet.key, coverDepositValue)); env.close(); @@ -673,7 +695,7 @@ protected: if (!env.le(keylet::account(borrower))) env.fund(env.current()->fees().accountReserve(10) * 10, noripple(borrower)); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); // Scale the MPT asset so interest is interesting PrettyAsset const asset{mptt.issuanceID(), 10'000}; @@ -709,10 +731,11 @@ protected: auto const asset = createAsset(env, assetType, brokerParams, issuer, lender, borrower); auto const principal = asset(loanParams.principalRequest).number(); auto const interest = loanParams.interest.value_or(TenthBips32{}); - auto const interval = loanParams.payInterval.value_or(LoanSet::kDEFAULT_PAYMENT_INTERVAL); - auto const total = loanParams.payTotal.value_or(LoanSet::kDEFAULT_PAYMENT_TOTAL); + auto const interval = loanParams.payInterval.value_or(LoanSet::kDefaultPaymentInterval); + auto const total = loanParams.payTotal.value_or(LoanSet::kDefaultPaymentTotal); auto const feeRate = brokerParams.managementFeeRate; auto const props = computeLoanProperties( + env.current()->rules(), asset, principal, interest, @@ -736,8 +759,8 @@ protected: BEAST_EXPECT(!checkLoanGuards( asset, asset(loanParams.principalRequest).number(), - loanParams.interest.value_or(TenthBips32{}) != beast::kZERO, - loanParams.payTotal.value_or(LoanSet::kDEFAULT_PAYMENT_TOTAL), + loanParams.interest.value_or(TenthBips32{}) != beast::kZero, + loanParams.payTotal.value_or(LoanSet::kDefaultPaymentTotal), props, env.journal)); } @@ -844,7 +867,7 @@ protected: auto const shortage = totalNeeded - borrowerBalance.number(); - if (shortage > beast::kZERO && (broker.asset.native() || issuer != borrower)) + if (shortage > beast::kZero && (broker.asset.native() || issuer != borrower)) { env( pay((broker.asset.native() ? env.master : issuer), @@ -918,6 +941,7 @@ protected: state.totalValue, state.principalOutstanding, state.managementFeeOutstanding); { auto const raw = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -961,6 +985,7 @@ protected: std::size_t totalPaymentsMade = 0; xrpl::LoanState currentTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -971,7 +996,7 @@ protected: return; auto const totalSpent = (totalPaid.trackedValueDelta + totalFeesPaid + - (broker.asset.native() ? Number(baseFee) * totalPaymentsMade : kNUM_ZERO)); + (broker.asset.native() ? Number(baseFee) * totalPaymentsMade : kNumZero)); BEAST_EXPECT( env.balance(borrower, broker.asset).number() == borrowerInitialBalance - totalSpent); @@ -990,6 +1015,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 +1036,7 @@ protected: paymentComponents.trackedManagementFeeDelta); xrpl::LoanState const nextTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining - 1, @@ -1053,13 +1080,13 @@ protected: Number const diff = totalDue - totalDueAmount; BEAST_EXPECT( paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final || - diff == beast::kZERO || - (diff > beast::kZERO && + diff == beast::kZero || + (diff > beast::kZero && ((broker.asset.integral() && (static_cast(diff) < 3)) || (state.loanScale - diff.exponent() > 13)))); BEAST_EXPECT( - paymentComponents.trackedPrincipalDelta >= beast::kZERO && + paymentComponents.trackedPrincipalDelta >= beast::kZero && paymentComponents.trackedPrincipalDelta <= state.principalOutstanding); BEAST_EXPECT( paymentComponents.specialCase != xrpl::detail::PaymentSpecialCase::Final || @@ -1198,7 +1225,8 @@ protected: runLoan( AssetType assetType, BrokerParameters const& brokerParams, - LoanParameters const& loanParams) + LoanParameters const& loanParams, + FeatureBitset features) { using namespace jtx; @@ -1206,7 +1234,7 @@ protected: Account const lender("lender"); Account const borrower("borrower"); - Env env(*this, all_); + Env env(*this, features); auto loanResult = createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower); @@ -1407,6 +1435,7 @@ protected: auto state = getCurrentState(env, broker, keylet, verifyLoanStatus); auto const loanProperties = computeLoanProperties( + env.current()->rules(), broker.asset.raw(), state.principalOutstanding, state.interestRate, @@ -1506,8 +1535,8 @@ protected: // Delete the loan // Either the borrower or the lender can delete the loan. Alternate // between who does it across tests. - static unsigned kDELETE_COUNTER = 0; - auto const deleter = ((++kDELETE_COUNTER % 2) != 0u) ? lender : borrower; + static unsigned kDeleteCounter = 0; + auto const deleter = ((++kDeleteCounter % 2) != 0u) ? lender : borrower; env(del(deleter, keylet.key)); env.close(); @@ -1626,13 +1655,13 @@ protected: // sfData: good length, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kDATA(std::string(kMAX_DATA_PAYLOAD_LENGTH, 'X')), + kData(std::string(kMaxDataPayloadLength, 'X')), loanSetFee, Ter(tefBAD_AUTH)); // sfData: too long env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kDATA(std::string(kMAX_DATA_PAYLOAD_LENGTH + 1, 'Y')), + kData(std::string(kMaxDataPayloadLength + 1, 'Y')), loanSetFee, Ter(temINVALID)); @@ -1640,148 +1669,148 @@ protected: // sfOverpaymentFee: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kOVERPAYMENT_FEE(kMAX_OVERPAYMENT_FEE), + kOverpaymentFee(kMaxOverpaymentFee), loanSetFee, Ter(tefBAD_AUTH)); // sfOverpaymentFee: too big env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kOVERPAYMENT_FEE(kMAX_OVERPAYMENT_FEE + 1), + kOverpaymentFee(kMaxOverpaymentFee + 1), loanSetFee, Ter(temINVALID)); // sfInterestRate: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kINTEREST_RATE(kMAX_INTEREST_RATE), + kInterestRate(kMaxInterestRate), loanSetFee, Ter(tefBAD_AUTH)); env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kINTEREST_RATE(TenthBips32(0)), + kInterestRate(TenthBips32(0)), loanSetFee, Ter(tefBAD_AUTH)); // sfInterestRate: too big env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kINTEREST_RATE(kMAX_INTEREST_RATE + 1), + kInterestRate(kMaxInterestRate + 1), loanSetFee, Ter(temINVALID)); // sfInterestRate: too small env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kINTEREST_RATE(TenthBips32(-1)), + kInterestRate(TenthBips32(-1)), loanSetFee, Ter(temINVALID)); // sfLateInterestRate: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kLATE_INTEREST_RATE(kMAX_LATE_INTEREST_RATE), + kLateInterestRate(kMaxLateInterestRate), loanSetFee, Ter(tefBAD_AUTH)); env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kLATE_INTEREST_RATE(TenthBips32(0)), + kLateInterestRate(TenthBips32(0)), loanSetFee, Ter(tefBAD_AUTH)); // sfLateInterestRate: too big env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kLATE_INTEREST_RATE(kMAX_LATE_INTEREST_RATE + 1), + kLateInterestRate(kMaxLateInterestRate + 1), loanSetFee, Ter(temINVALID)); // sfLateInterestRate: too small env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kLATE_INTEREST_RATE(TenthBips32(-1)), + kLateInterestRate(TenthBips32(-1)), loanSetFee, Ter(temINVALID)); // sfCloseInterestRate: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kCLOSE_INTEREST_RATE(kMAX_CLOSE_INTEREST_RATE), + kCloseInterestRate(kMaxCloseInterestRate), loanSetFee, Ter(tefBAD_AUTH)); env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kCLOSE_INTEREST_RATE(TenthBips32(0)), + kCloseInterestRate(TenthBips32(0)), loanSetFee, Ter(tefBAD_AUTH)); // sfCloseInterestRate: too big env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kCLOSE_INTEREST_RATE(kMAX_CLOSE_INTEREST_RATE + 1), + kCloseInterestRate(kMaxCloseInterestRate + 1), loanSetFee, Ter(temINVALID)); env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kCLOSE_INTEREST_RATE(TenthBips32(-1)), + kCloseInterestRate(TenthBips32(-1)), loanSetFee, Ter(temINVALID)); // sfOverpaymentInterestRate: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kOVERPAYMENT_INTEREST_RATE(kMAX_OVERPAYMENT_INTEREST_RATE), + kOverpaymentInterestRate(kMaxOverpaymentInterestRate), loanSetFee, Ter(tefBAD_AUTH)); env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kOVERPAYMENT_INTEREST_RATE(TenthBips32(0)), + kOverpaymentInterestRate(TenthBips32(0)), loanSetFee, Ter(tefBAD_AUTH)); // sfOverpaymentInterestRate: too big env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kOVERPAYMENT_INTEREST_RATE(kMAX_OVERPAYMENT_INTEREST_RATE + 1), + kOverpaymentInterestRate(kMaxOverpaymentInterestRate + 1), loanSetFee, Ter(temINVALID)); env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kOVERPAYMENT_INTEREST_RATE(TenthBips32(-1)), + kOverpaymentInterestRate(TenthBips32(-1)), loanSetFee, Ter(temINVALID)); // sfPaymentTotal: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kPAYMENT_TOTAL(LoanSet::kMIN_PAYMENT_TOTAL), + kPaymentTotal(LoanSet::kMinPaymentTotal), loanSetFee, Ter(tefBAD_AUTH)); // sfPaymentTotal: too small (there is no max) env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kPAYMENT_TOTAL(LoanSet::kMIN_PAYMENT_TOTAL - 1), + kPaymentTotal(LoanSet::kMinPaymentTotal - 1), loanSetFee, Ter(temINVALID)); // sfPaymentInterval: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kPAYMENT_INTERVAL(LoanSet::kMIN_PAYMENT_INTERVAL), + kPaymentInterval(LoanSet::kMinPaymentInterval), loanSetFee, Ter(tefBAD_AUTH)); // sfPaymentInterval: too small (there is no max) env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kPAYMENT_INTERVAL(LoanSet::kMIN_PAYMENT_INTERVAL - 1), + kPaymentInterval(LoanSet::kMinPaymentInterval - 1), loanSetFee, Ter(temINVALID)); // sfGracePeriod: good value, bad account env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, borrower), - kPAYMENT_INTERVAL(LoanSet::kMIN_PAYMENT_INTERVAL * 2), - kGRACE_PERIOD(LoanSet::kMIN_PAYMENT_INTERVAL * 2), + kPaymentInterval(LoanSet::kMinPaymentInterval * 2), + kGracePeriod(LoanSet::kMinPaymentInterval * 2), loanSetFee, Ter(tefBAD_AUTH)); // sfGracePeriod: larger than paymentInterval env(set(evan, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), - kPAYMENT_INTERVAL(LoanSet::kMIN_PAYMENT_INTERVAL * 2), - kGRACE_PERIOD(LoanSet::kMIN_PAYMENT_INTERVAL * 3), + kPaymentInterval(LoanSet::kMinPaymentInterval * 2), + kGracePeriod(LoanSet::kMinPaymentInterval * 3), loanSetFee, Ter(temINVALID)); @@ -1793,30 +1822,30 @@ protected: env(signers(lender, 2, {{evan, 1}, {borrower, 1}})); env(signers(borrower, 2, {{evan, 1}, {lender, 1}})); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Msig(evan, lender), Msig(sfCounterpartySignature, evan, borrower), Fee(env.current()->fees().base * 5 - 1), Ter(telINSUF_FEE_P)); // Bad multisign signatures for borrower (Account) env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Msig(alice, issuer), Msig(sfCounterpartySignature, evan, borrower), Fee(env.current()->fees().base * 5), Ter(tefBAD_SIGNATURE)); // Bad multisign signatures for issuer (Counterparty) env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Msig(evan, lender), Msig(sfCounterpartySignature, alice, issuer), Fee(env.current()->fees().base * 5 - 1), Ter(tefBAD_SIGNATURE)); - env(signers(lender, kNONE)); - env(signers(borrower, kNONE)); + env(signers(lender, kNone)); + env(signers(borrower, kNone)); // multisign sufficient fee, but no signers set up env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Msig(evan, lender), Msig(sfCounterpartySignature, evan, borrower), Fee(env.current()->fees().base * 5), @@ -1829,7 +1858,7 @@ protected: Ter(tefBAD_AUTH)); // not the broker owner, counterparty is borrower env(set(evan, broker.brokerID, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Sig(sfCounterpartySignature, borrower), loanSetFee, Ter(tecNO_PERMISSION)); @@ -1840,13 +1869,13 @@ protected: Ter(temBAD_SIGNER)); // not a LoanBroker object, counterparty is valid env(set(lender, badKeylet.key, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Sig(sfCounterpartySignature, borrower), loanSetFee, Ter(tecNO_ENTRY)); // borrower doesn't exist env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(alice), + kCounterparty(alice), Sig(sfCounterpartySignature, alice), loanSetFee, Ter(terNO_ACCOUNT)); @@ -2134,24 +2163,25 @@ protected: // If the loan does not allow overpayments, send a payment that // tries to make an overpayment. Do not include `txFlags`, so we // don't end up duplicating the next test transaction. - env(pay(borrower, - loanKeylet.key, - STAmount{broker.asset, state.periodicPayment * Number{15, -1}}, - tfLoanOverpayment), - Fee(XRPAmount{ - baseFee * (Number{15, -1} / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}), - Ter(tecNO_PERMISSION)); + // + // fixCleanup3_1_3 gates tfLoanOverpayment as a valid flag: + // with fix on → preflight passes, apply returns tecNO_PERMISSION; + // with fix off → preflight rejects the flag, returns temINVALID_FLAG. + bool const hasFix313 = env.current()->rules().enabled(fixCleanup3_1_3); + STAmount const overpayAmount{broker.asset, state.periodicPayment * Number{15, -1}}; + XRPAmount const overpayFee{ + baseFee * (Number{15, -1} / kLoanPaymentsPerFeeIncrement + 1)}; + env(pay(borrower, loanKeylet.key, overpayAmount, tfLoanOverpayment), + Fee(overpayFee), + Ter(hasFix313 ? TER{tecNO_PERMISSION} : TER{temINVALID_FLAG})); + if (hasFix313) { - env.disableFeature(fixSecurity3_1_3); - env(pay(borrower, - loanKeylet.key, - STAmount{broker.asset, state.periodicPayment * Number{15, -1}}, - tfLoanOverpayment), - Fee(XRPAmount{ - baseFee * (Number{15, -1} / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}), + env.disableFeature(fixCleanup3_1_3); + env(pay(borrower, loanKeylet.key, overpayAmount, tfLoanOverpayment), + Fee(overpayFee), Ter(temINVALID_FLAG)); - env.enableFeature(fixSecurity3_1_3); + env.enableFeature(fixCleanup3_1_3); } } // Try to send a payment marked as multiple mutually exclusive @@ -2202,7 +2232,7 @@ protected: XRPAmount const badFee{ baseFee * (borrowerBalanceBeforePayment.number() * 2 / state.periodicPayment / - kLOAN_PAYMENTS_PER_FEE_INCREMENT + + kLoanPaymentsPerFeeIncrement + 1)}; env(pay(borrower, loanKeylet.key, @@ -2211,7 +2241,7 @@ protected: Fee(badFee), Ter(tecINSUFFICIENT_FUNDS)); - XRPAmount const goodFee{baseFee * (numPayments / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; + XRPAmount const goodFee{baseFee * (numPayments / kLoanPaymentsPerFeeIncrement + 1)}; env(pay(borrower, loanKeylet.key, transactionAmount, txFlags), Fee(goodFee)); env.close(); @@ -2261,7 +2291,7 @@ protected: // to verify they're working correctly The numbers in // the below BEAST_EXPECTs may not hold across assets. Number const interval = state.paymentInterval; - auto const periodicRate = interval * Number(12, -2) / kSECONDS_IN_YEAR; + auto const periodicRate = interval * Number(12, -2) / kSecondsInYear; BEAST_EXPECT( periodicRate == Number(2283105022831050228ULL, -24, Number::Normalized{})); STAmount const principalOutstanding{broker.asset, state.principalOutstanding}; @@ -2501,7 +2531,7 @@ protected: // to verify they're working correctly The numbers in // the below BEAST_EXPECTs may not hold across assets. Number const interval = state.paymentInterval; - auto const periodicRate = interval * Number(12, -2) / kSECONDS_IN_YEAR; + auto const periodicRate = interval * Number(12, -2) / kSecondsInYear; BEAST_EXPECT( periodicRate == Number(2283105022831050228, -24, Number::Normalized{})); STAmount const roundedPeriodicPayment{ @@ -2540,6 +2570,7 @@ protected: { auto const raw = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -2577,6 +2608,7 @@ protected: std::size_t totalPaymentsMade = 0; xrpl::LoanState currentTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining, @@ -2586,6 +2618,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 +2636,7 @@ protected: ", periodic payment: " + to_string(roundedPeriodicPayment)); xrpl::LoanState const nextTrueState = computeTheoreticalLoanState( + env.current()->rules(), state.periodicPayment, periodicRate, state.paymentRemaining - 1, @@ -2637,8 +2671,8 @@ protected: Number const diff = totalDue - totalDueAmount; BEAST_EXPECT( paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final || - diff == beast::kZERO || - (diff > beast::kZERO && + diff == beast::kZero || + (diff > beast::kZero && ((broker.asset.integral() && (static_cast(diff) < 3)) || (state.loanScale - diff.exponent() > 13)))); @@ -2664,7 +2698,7 @@ protected: state.loanScale, Number::RoundingMode::Upward)); BEAST_EXPECT( - paymentComponents.trackedPrincipalDelta >= beast::kZERO && + paymentComponents.trackedPrincipalDelta >= beast::kZero && paymentComponents.trackedPrincipalDelta <= state.principalOutstanding); BEAST_EXPECT( paymentComponents.specialCase != xrpl::detail::PaymentSpecialCase::Final || @@ -2797,8 +2831,8 @@ protected: pseudoAcct, tfLoanOverpayment, [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) { - // Estimate optimal values for loanPaymentsPerFeeIncrement and - // loanMaximumPaymentsPerTransaction. + // Estimate optimal values for kLoanPaymentsPerFeeIncrement and + // kLoanMaximumPaymentsPerTransaction. using namespace loan; auto const state = getCurrentState(env, broker, verifyLoanStatus.keylet); @@ -2816,7 +2850,7 @@ 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 / kLoanPaymentsPerFeeIncrement + 1)}; time("ten payments", [&]() { env(pay(borrower, loanKeylet.key, bigPayment), Fee(bigFee)); }); @@ -2889,7 +2923,7 @@ protected: } void - testLoanSet() + testLoanSet(FeatureBitset features) { using namespace jtx; @@ -2908,7 +2942,7 @@ protected: std::function mptTest, std::function iouTest, CaseArgs args = {}) { - Env env(*this, all_); + Env env(*this, features); env.fund(XRP(args.initialXRP), issuer, lender, borrower); env.close(); if (args.requireAuth) @@ -2919,12 +2953,12 @@ protected: // We need two different asset types, MPT and IOU. Prepare MPT // first - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; - auto const kNONE = LedgerSpecificFlags(0); + auto const kNone = LedgerSpecificFlags(0); mptt.create( {.flags = tfMPTCanTransfer | tfMPTCanLock | - (args.requireAuth ? tfMPTRequireAuth : kNONE)}); + (args.requireAuth ? tfMPTRequireAuth : kNone)}); env.close(); PrettyAsset const mptAsset = mptt.issuanceID(); mptt.authorize({.account = lender}); @@ -2985,13 +3019,13 @@ protected: testcase("MPT issuer is borrower, issuer submits"); env(set(issuer, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); testcase("MPT issuer is borrower, lender submits"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(issuer), + kCounterparty(issuer), Sig(sfCounterpartySignature, issuer), Fee(env.current()->fees().base * 5)); }, @@ -3001,13 +3035,13 @@ protected: testcase("IOU issuer is borrower, issuer submits"); env(set(issuer, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); testcase("IOU issuer is borrower, lender submits"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(issuer), + kCounterparty(issuer), Sig(sfCounterpartySignature, issuer), Fee(env.current()->fees().base * 5)); }, @@ -3020,14 +3054,14 @@ protected: testcase("MPT unauthorized borrower, borrower submits"); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecNO_AUTH}); testcase("MPT unauthorized borrower, lender submits"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Sig(sfCounterpartySignature, borrower), Fee(env.current()->fees().base * 5), Ter{tecNO_AUTH}); @@ -3038,14 +3072,14 @@ protected: testcase("IOU unauthorized borrower, borrower submits"); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecNO_AUTH}); testcase("IOU unauthorized borrower, lender submits"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Sig(sfCounterpartySignature, borrower), Fee(env.current()->fees().base * 5), Ter{tecNO_AUTH}); @@ -3055,8 +3089,8 @@ protected: auto const [acctReserve, incReserve] = [this]() -> std::pair { Env const env{*this, testableAmendments()}; return { - env.current()->fees().accountReserve(0).drops() / kDROPS_PER_XRP.drops(), - env.current()->fees().increment.drops() / kDROPS_PER_XRP.drops()}; + env.current()->fees().accountReserve(0).drops() / kDropsPerXrp.drops(), + env.current()->fees().increment.drops() / kDropsPerXrp.drops()}; }(); testCase( @@ -3080,7 +3114,7 @@ protected: // Cannot create loan, not enough reserve to create MPToken env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecINSUFFICIENT_RESERVE}); @@ -3090,7 +3124,7 @@ protected: env(pay(issuer, borrower, XRP(incReserve))); env.close(); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); env.close(); @@ -3126,7 +3160,7 @@ protected: // Cannot create loan, not enough reserve to create trust line env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecNO_LINE_INSUF_RESERVE}); @@ -3136,7 +3170,7 @@ protected: env(pay(issuer, borrower, XRP(incReserve))); env.close(); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); env.close(); @@ -3173,8 +3207,8 @@ protected: // Cannot create loan, not enough reserve to create MPToken env(set(borrower, broker.brokerID, principalRequest), - kLOAN_ORIGINATION_FEE(broker.asset(1).value()), - kCOUNTERPARTY(lender), + kLoanOriginationFee(broker.asset(1).value()), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecINSUFFICIENT_RESERVE}); @@ -3184,8 +3218,8 @@ protected: env(pay(issuer, lender, XRP(incReserve))); env.close(); env(set(borrower, broker.brokerID, principalRequest), - kLOAN_ORIGINATION_FEE(broker.asset(1).value()), - kCOUNTERPARTY(lender), + kLoanOriginationFee(broker.asset(1).value()), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); env.close(); @@ -3224,8 +3258,8 @@ protected: // Cannot create loan, not enough reserve to create trust line env(set(borrower, broker.brokerID, principalRequest), - kLOAN_ORIGINATION_FEE(broker.asset(1).value()), - kCOUNTERPARTY(lender), + kLoanOriginationFee(broker.asset(1).value()), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecNO_LINE_INSUF_RESERVE}); @@ -3235,8 +3269,8 @@ protected: env(pay(issuer, lender, XRP(incReserve))); env.close(); env(set(borrower, broker.brokerID, principalRequest), - kLOAN_ORIGINATION_FEE(broker.asset(1).value()), - kCOUNTERPARTY(lender), + kLoanOriginationFee(broker.asset(1).value()), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); env.close(); @@ -3267,8 +3301,8 @@ protected: // Cannot create loan, lender not authorized to receive fee env(set(borrower, broker.brokerID, principalRequest), - kLOAN_ORIGINATION_FEE(broker.asset(1).value()), - kCOUNTERPARTY(lender), + kLoanOriginationFee(broker.asset(1).value()), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecNO_AUTH}); @@ -3276,7 +3310,7 @@ protected: // Cannot create loan, even without an origination fee env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter{tecNO_AUTH}); @@ -3296,7 +3330,7 @@ protected: testcase("MPT authorized borrower, borrower submits"); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); }, @@ -3306,7 +3340,7 @@ protected: testcase("IOU authorized borrower, borrower submits"); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5)); }, @@ -3319,7 +3353,7 @@ protected: testcase("MPT authorized borrower, lender submits"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Sig(sfCounterpartySignature, borrower), Fee(env.current()->fees().base * 5)); }, @@ -3329,7 +3363,7 @@ protected: testcase("IOU authorized borrower, lender submits"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Sig(sfCounterpartySignature, borrower), Fee(env.current()->fees().base * 5)); }, @@ -3353,7 +3387,7 @@ protected: "MPT authorized borrower, borrower submits, lender " "multisign"); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Msig(sfCounterpartySignature, alice, bella), Fee(env.current()->fees().base * 5)); }, @@ -3366,7 +3400,7 @@ protected: "IOU authorized borrower, borrower submits, lender " "multisign"); env(set(borrower, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), + kCounterparty(lender), Msig(sfCounterpartySignature, alice, bella), Fee(env.current()->fees().base * 5)); }, @@ -3382,7 +3416,7 @@ protected: "MPT authorized borrower, lender submits, borrower " "multisign"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Msig(sfCounterpartySignature, alice, bella), Fee(env.current()->fees().base * 5)); }, @@ -3395,7 +3429,7 @@ protected: "IOU authorized borrower, lender submits, borrower " "multisign"); env(set(lender, broker.brokerID, principalRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Msig(sfCounterpartySignature, alice, bella), Fee(env.current()->fees().base * 5)); }, @@ -3413,8 +3447,8 @@ protected: testcase("Vault at maximum value"); env(set(issuer, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), - kINTEREST_RATE(TenthBips32(10'000)), + kCounterparty(lender), + kInterestRate(TenthBips32(10'000)), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), Ter(tecLIMIT_EXCEEDED)); @@ -3434,26 +3468,26 @@ protected: testcase("Vault maximum value exceeded"); env(set(issuer, broker.brokerID, principalRequest), - kCOUNTERPARTY(lender), - kINTEREST_RATE(TenthBips32(100'000)), + kCounterparty(lender), + kInterestRate(TenthBips32(100'000)), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 5), - kPAYMENT_TOTAL(2), - kPAYMENT_INTERVAL(3600 * 24), + kPaymentTotal(2), + kPaymentInterval(3600 * 24), Ter(tecLIMIT_EXCEEDED)); }, nullptr); } void - testLifecycle() + testLifecycle(FeatureBitset features) { testcase("Lifecycle"); using namespace jtx; // Create 3 loan brokers: one for XRP, one for an IOU, and one for // an MPT. That'll require three corresponding SAVs. - Env env(*this, all_); + Env env(*this, features); Account const issuer{"issuer"}; // For simplicity, lender will be the sole actor for the vault & @@ -3483,7 +3517,7 @@ protected: env(pay(issuer, borrower, iouAsset(10'000))); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); // Scale the MPT asset a little bit so we can get some interest PrettyAsset const mptAsset{mptt.issuanceID(), 100}; @@ -3540,7 +3574,7 @@ protected: } void - testSelfLoan() + testSelfLoan(FeatureBitset features) { testcase << "Self Loan"; @@ -3548,7 +3582,7 @@ protected: using namespace std::chrono_literals; // Create 3 loan brokers: one for XRP, one for an IOU, and one for // an MPT. That'll require three corresponding SAVs. - Env env(*this, all_); + Env env(*this, features); Account const issuer{"issuer"}; // For simplicity, lender will be the sole actor for the vault & @@ -3579,7 +3613,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 +3631,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 +3663,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)); @@ -3675,18 +3709,18 @@ protected: } void - testBatchBypassCounterparty() + testBatchBypassCounterparty(FeatureBitset features) { // From FIND-001 testcase << "Batch Bypass Counterparty"; bool const lendingBatchEnabled = !std::ranges::any_of( - Batch::kDISABLED_TX_TYPES, + Batch::kDisabledTxTypes, [](auto const& disabled) { return disabled == ttLOAN_BROKER_SET; }); using namespace jtx; using namespace std::chrono_literals; - Env env(*this, all_); + Env env(*this, features); Account const lender{"lender"}; Account const borrower{"borrower"}; @@ -3706,9 +3740,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 +3766,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)); @@ -3742,14 +3776,14 @@ protected: } void - testWrongMaxDebtBehavior() + testWrongMaxDebtBehavior(FeatureBitset features) { // From FIND-003 testcase << "Wrong Max Debt Behavior"; using namespace jtx; using namespace std::chrono_literals; - Env env(*this, all_); + Env env(*this, features); Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -3775,7 +3809,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))) @@ -3788,7 +3822,7 @@ protected: } void - testLoanPayComputePeriodicPaymentValidRateInvariant() + testLoanPayComputePeriodicPaymentValidRateInvariant(FeatureBitset features) { // From FIND-012 testcase << "LoanPay xrpl::detail::computePeriodicPayment : " @@ -3796,7 +3830,7 @@ protected: using namespace jtx; using namespace std::chrono_literals; - Env env(*this, all_); + Env env(*this, features); Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -3820,9 +3854,9 @@ protected: auto createJson = env.json( set(borrower, broker.brokerID, principalRequest), Fee(loanSetFee), - kLOAN_SERVICE_FEE(serviceFee), - kPAYMENT_TOTAL(numPayments), - Json(sfCounterpartySignature, json::ObjectValue)); + kLoanServiceFee(serviceFee), + kPaymentTotal(numPayments), + Json(sfCounterpartySignature, json::ValueType::Object)); createJson["CloseInterestRate"] = 55374; createJson["ClosePaymentFee"] = "3825205248"; @@ -3856,7 +3890,7 @@ protected: } void - testRPC() + testRPC(FeatureBitset features) { // This will expand as more test cases are added. Some functionality // is tested in other test functions. @@ -3864,7 +3898,7 @@ protected: using namespace jtx; - Env env(*this, all_); + Env env(*this, features); auto lowerFee = [&]() { // Run the local fee back down. @@ -3891,12 +3925,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; @@ -3919,18 +3953,18 @@ protected: jSubmit[jss::result][jss::engine_result].asString() == "tesSUCCESS"); lowerFee(); - env(jtx.jv, Sig(kNONE), Seq(kNONE), Fee(kNONE), Ter(tefPAST_SEQ)); + env(jtx.jv, Sig(kNone), Seq(kNone), Fee(kNone), Ter(tefPAST_SEQ)); } { 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 +3982,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 +3999,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 +4031,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 +4089,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 +4106,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 +4137,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"; @@ -4206,8 +4240,8 @@ protected: env(set(borrower, brokerInfo.brokerID, 10'000), Sig(sfCounterpartySignature, broker), - kLOAN_SERVICE_FEE(iou(100).value()), - kPAYMENT_INTERVAL(100), + kLoanServiceFee(iou(100).value()), + kPaymentInterval(100), Fee(XRP(100))); env.close(); @@ -4258,9 +4292,9 @@ protected: env.fund(XRP(1'000), issuer, lender); - std::int64_t constexpr kISSUER_BALANCE = 10'000'000; + static constexpr std::int64_t kIssuerBalance = 10'000'000; MPTTester const asset( - {.env = env, .issuer = issuer, .holders = {lender}, .pay = kISSUER_BALANCE}); + {.env = env, .issuer = issuer, .holders = {lender}, .pay = kIssuerBalance}); BrokerParameters const brokerParams{ .debtMax = 200, @@ -4273,13 +4307,13 @@ protected: // Issuer should not create MPToken BEAST_EXPECT(!env.le(keylet::mptoken(asset.issuanceID(), issuer))); // Issuer "borrowed" 200, OutstandingAmount decreased by 200 - BEAST_EXPECT(env.balance(issuer, asset) == asset(-kISSUER_BALANCE + 200)); + BEAST_EXPECT(env.balance(issuer, asset) == asset(-kIssuerBalance + 200)); // Pay Loan auto const loanKeylet = keylet::loan(broker.brokerID, 1); env(pay(borrower, loanKeylet.key, asset(200))); env.close(); // Issuer "re-payed" 200, OutstandingAmount increased by 200 - BEAST_EXPECT(env.balance(issuer, asset) == asset(-kISSUER_BALANCE)); + BEAST_EXPECT(env.balance(issuer, asset) == asset(-kIssuerBalance)); } void @@ -4295,7 +4329,7 @@ protected: Env env(*this); env.fund(XRP(1'000), alice); env.close(); - env(del(alice, beast::kZERO), Ter(temINVALID)); + env(del(alice, beast::kZero), Ter(temINVALID)); } } @@ -4312,7 +4346,7 @@ protected: Env env(*this); env.fund(XRP(1'000), alice); env.close(); - env(manage(alice, beast::kZERO, tfLoanDefault), Ter(temINVALID)); + env(manage(alice, beast::kZero, tfLoanDefault), Ter(temINVALID)); } } @@ -4428,22 +4462,22 @@ protected: // zero grace period env(set(borrower, brokerInfo.brokerID, debtMaximumRequest), Sig(sfCounterpartySignature, lender), - kGRACE_PERIOD(0), + kGracePeriod(0), loanSetFee, Ter(temINVALID)); // grace period less than default minimum env(set(borrower, brokerInfo.brokerID, debtMaximumRequest), Sig(sfCounterpartySignature, lender), - kGRACE_PERIOD(LoanSet::kDEFAULT_GRACE_PERIOD - 1), + kGracePeriod(LoanSet::kDefaultGracePeriod - 1), loanSetFee, Ter(temINVALID)); // grace period greater than payment interval env(set(borrower, brokerInfo.brokerID, debtMaximumRequest), Sig(sfCounterpartySignature, lender), - kPAYMENT_INTERVAL(120), - kGRACE_PERIOD(121), + kPaymentInterval(120), + kGracePeriod(121), loanSetFee, Ter(temINVALID)); } @@ -4535,7 +4569,7 @@ protected: } void - testAccountSendMptMinAmountInvariant() + testAccountSendMptMinAmountInvariant(FeatureBitset features) { // (From FIND-006) testcase << "LoanSet trigger xrpl::accountSendMPT : minimum amount " @@ -4543,7 +4577,7 @@ protected: using namespace jtx; using namespace std::chrono_literals; - Env env(*this, all_); + Env env(*this, features); Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -4552,7 +4586,7 @@ protected: env.fund(XRP(1'000'000), issuer, lender, borrower); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); PrettyAsset const mptAsset = mptt.issuanceID(); mptt.authorize({.account = lender}); @@ -4571,7 +4605,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"; @@ -4595,7 +4629,7 @@ protected: } void - testLoanPayDebtDecreaseInvariant() + testLoanPayDebtDecreaseInvariant(FeatureBitset features) { // From FIND-007 testcase << "LoanPay xrpl::LoanPay::doApply : debtDecrease " @@ -4604,7 +4638,7 @@ protected: 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"}; @@ -4635,7 +4669,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; @@ -4671,7 +4705,7 @@ protected: Number const payment{3'269'349'176'470'588, -12}; XRPAmount const payFee{ baseFee * - ((payment / originalState.periodicPayment) / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; + ((payment / originalState.periodicPayment) / kLoanPaymentsPerFeeIncrement + 1)}; auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, payment}), Fee(payFee)); BEAST_EXPECT(to_string(payment) == "3269.349176470588"); @@ -4688,14 +4722,14 @@ protected: } void - testLoanPayComputePeriodicPaymentValidTotalInterestInvariant() + testLoanPayComputePeriodicPaymentValidTotalInterestInvariant(FeatureBitset features) { // From FIND-010 testcase << "xrpl::loanComputePaymentParts : valid total interest"; using namespace jtx; using namespace std::chrono_literals; - Env env(*this, all_); + Env env(*this, features); Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -4725,7 +4759,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 +4787,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 +4806,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,56 +4820,116 @@ 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), + kClosePaymentFee(0), + kGracePeriod(60), + kInterestRate(TenthBips32(20930)), + kLateInterestRate(TenthBips32(77049)), + kLatePaymentFee(0), + kLoanServiceFee(0), + kOverpaymentFee(TenthBips32(7)), + kOverpaymentInterestRate(TenthBips32(66653)), + kPaymentInterval(60), + kPaymentTotal(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 > kLoanMaximumPaymentsPerTransaction); - 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 > kLoanMaximumPaymentsPerTransaction); + + 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(kLoanMaximumPaymentsPerTransaction, payFactor) + : 0; + + auto const stateAfter = getCurrentState(env, broker, keylet); + BEAST_EXPECT( + stateAfter.paymentRemaining == stateBefore.paymentRemaining - expectedChange); + }; + + static constexpr std::int64_t kMaxFeeIncrements = + kLoanMaximumPaymentsPerTransaction / kLoanPaymentsPerFeeIncrement; + + 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, kMaxFeeIncrements, failWithoutFix); + + // * Amount exactly at threshold -> capped fee + test(kLoanMaximumPaymentsPerTransaction, kMaxFeeIncrements); + // More fee is always ok + test(kLoanMaximumPaymentsPerTransaction, kMaxFeeIncrements + 10); + + // * Amount below threshold -> normal calculation + test(1, 1); + test(kLoanPaymentsPerFeeIncrement * 2, 2); + test(0, 0, temBAD_AMOUNT); + test(0, 1, temBAD_AMOUNT); + // Fee difference rounds evenly + test( + kLoanMaximumPaymentsPerTransaction - 10, + ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement) - 1, + telINSUF_FEE_P); + test( + kLoanMaximumPaymentsPerTransaction - 10, + ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement)); + // More fee is always ok + test( + kLoanMaximumPaymentsPerTransaction - 10, + ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement) + 3); + // Fee rounds up + for (int under = 1; under < kLoanPaymentsPerFeeIncrement; ++under) + { + test(kLoanMaximumPaymentsPerTransaction - under, kMaxFeeIncrements - 1, telINSUF_FEE_P); + test(kLoanMaximumPaymentsPerTransaction - under, kMaxFeeIncrements); + } + // Only when you get one less fee increment can you pay less + test( + kLoanMaximumPaymentsPerTransaction - kLoanPaymentsPerFeeIncrement, + kMaxFeeIncrements - 1); + // And again, more fee is always ok. + test(kLoanMaximumPaymentsPerTransaction - kLoanPaymentsPerFeeIncrement, kMaxFeeIncrements); } void - testLoanPayComputePeriodicPaymentValidTotalPrincipalPaidInvariant() + testLoanPayComputePeriodicPaymentValidTotalPrincipalPaidInvariant(FeatureBitset features) { // From FIND-009 testcase << "xrpl::loanComputePaymentParts : totalPrincipalPaid " @@ -4840,7 +4938,7 @@ protected: 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"}; @@ -4870,7 +4968,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; @@ -4900,7 +4998,7 @@ protected: BEAST_EXPECT(to_string(amount) == "3074.745058823529"); XRPAmount const payFee{ baseFee * - (amount / stateBefore.periodicPayment / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; + (amount / stateBefore.periodicPayment / kLoanPaymentsPerFeeIncrement + 1)}; loanPayTx["Amount"]["value"] = to_string(amount); env(loanPayTx, Fee(payFee), Ter(tesSUCCESS)); env.close(); @@ -4912,7 +5010,7 @@ protected: BEAST_EXPECT(to_string(amount) == "6732.118170944051"); XRPAmount const payFee{ baseFee * - (amount / stateBefore.periodicPayment / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; + (amount / stateBefore.periodicPayment / kLoanPaymentsPerFeeIncrement + 1)}; loanPayTx["Amount"]["value"] = to_string(amount); env(loanPayTx, Fee(payFee), Ter(tesSUCCESS)); env.close(); @@ -4933,7 +5031,7 @@ protected: } void - testLoanPayComputePeriodicPaymentValidTotalInterestPaidInvariant() + testLoanPayComputePeriodicPaymentValidTotalInterestPaidInvariant(FeatureBitset features) { // From FIND-008 testcase << "xrpl::loanComputePaymentParts : loanValueChange rounded"; @@ -4941,7 +5039,7 @@ protected: 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"}; @@ -4976,7 +5074,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; @@ -5000,14 +5098,13 @@ protected: auto const stateBefore = getCurrentState(env, broker, keylet); BEAST_EXPECT(stateBefore.paymentRemaining == 5678); - BEAST_EXPECT(stateBefore.paymentRemaining > kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION); + BEAST_EXPECT(stateBefore.paymentRemaining > kLoanMaximumPaymentsPerTransaction); auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}})); Number const amount{9924'81, -2}; BEAST_EXPECT(to_string(amount) == "9924.81"); XRPAmount const payFee{ - baseFee * - (amount / stateBefore.periodicPayment / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; + baseFee * (amount / stateBefore.periodicPayment / kLoanPaymentsPerFeeIncrement + 1)}; loanPayTx["Amount"]["value"] = to_string(amount); env(loanPayTx, Fee(payFee), Ter(tesSUCCESS)); env.close(); @@ -5015,11 +5112,11 @@ protected: auto const stateAfter = getCurrentState(env, broker, keylet); BEAST_EXPECT( stateAfter.paymentRemaining == - stateBefore.paymentRemaining - kLOAN_MAXIMUM_PAYMENTS_PER_TRANSACTION); + stateBefore.paymentRemaining - kLoanMaximumPaymentsPerTransaction); } void - testLoanNextPaymentDueDateOverflow() + testLoanNextPaymentDueDateOverflow(FeatureBitset features) { // For FIND-013 testcase << "Prevent nextPaymentDueDate overflow"; @@ -5027,7 +5124,7 @@ protected: 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"}; @@ -5056,20 +5153,20 @@ protected: using timeType = decltype(sfNextPaymentDueDate)::type::value_type; static_assert(std::is_same_v); - timeType constexpr kMAX_TIME = std::numeric_limits::max(); - static_assert(kMAX_TIME == 4'294'967'295); + constexpr timeType kMaxTime = std::numeric_limits::max(); + static_assert(kMaxTime == 4'294'967'295); auto const baseJson = [&]() { auto createJson = env.json( set(borrower, broker.brokerID, Number{55524'81, -2}), Fee(loanSetFee), - kCLOSE_PAYMENT_FEE(0), - kGRACE_PERIOD(LoanSet::kDEFAULT_GRACE_PERIOD), - kINTEREST_RATE(TenthBips32(12833)), - kLATE_INTEREST_RATE(TenthBips32(77048)), - kLATE_PAYMENT_FEE(0), - kLOAN_ORIGINATION_FEE(218), - Json(sfCounterpartySignature, json::ObjectValue)); + kClosePaymentFee(0), + kGracePeriod(LoanSet::kDefaultGracePeriod), + kInterestRate(TenthBips32(12833)), + kLateInterestRate(TenthBips32(77048)), + kLatePaymentFee(0), + kLoanOriginationFee(218), + Json(sfCounterpartySignature, json::ValueType::Object)); createJson.removeMember(sfSequence.getJsonName()); @@ -5086,15 +5183,14 @@ protected: BEAST_EXPECT(startDate >= 50); - return kMAX_TIME - startDate; + return kMaxTime - startDate; }; { // straight-up overflow: interval auto const interval = maxLoanTime() + 1; auto const total = 1; - auto createJson = - env.json(baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total)); + auto createJson = env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED)); env.close(); @@ -5104,8 +5200,7 @@ protected: // min interval is 60 auto const interval = 60; auto const total = maxLoanTime() + 1; - auto createJson = - env.json(baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total)); + auto createJson = env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED)); env.close(); @@ -5117,7 +5212,7 @@ protected: auto const total = 1; auto const grace = interval; auto createJson = env.json( - baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total), kGRACE_PERIOD(grace)); + baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace)); // The grace period can't be larger than the interval. env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED)); @@ -5127,8 +5222,7 @@ protected: // Overflow with multiplication of a few large intervals auto const interval = 1'000'000'000; auto const total = 10; - auto createJson = - env.json(baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total)); + auto createJson = env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED)); env.close(); @@ -5138,8 +5232,7 @@ protected: // min interval is 60 auto const interval = 60; auto const total = 1'000'000'000; - auto createJson = - env.json(baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total)); + auto createJson = env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED)); env.close(); @@ -5151,7 +5244,7 @@ protected: auto const interval = (maxLoanTime() - total) / total; auto const grace = interval; auto createJson = env.json( - baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total), kGRACE_PERIOD(grace)); + baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED)); env.close(); @@ -5166,7 +5259,7 @@ protected: auto const interval = maxLoanTime() - grace; auto const total = 1; auto createJson = env.json( - baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total), kGRACE_PERIOD(grace)); + baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tesSUCCESS)); env.close(); @@ -5189,12 +5282,12 @@ protected: auto const loanSequence = brokerStateBefore->at(sfLoanSequence); auto const keylet = keylet::loan(broker.brokerID, loanSequence); - auto const closeStartDate = (parentCloseTime() / 10 + 1) * 10; + auto const closeStartDate = ((parentCloseTime() / 10) + 1) * 10; auto const grace = 5'000; - auto const interval = kMAX_TIME - closeStartDate - grace; + auto const interval = kMaxTime - closeStartDate - grace; auto const total = 1; auto createJson = env.json( - baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total), kGRACE_PERIOD(grace)); + baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tesSUCCESS)); env.close(); @@ -5208,7 +5301,7 @@ protected: // This loan exists auto const afterState = getCurrentState(env, broker, keylet); - BEAST_EXPECT(afterState.nextPaymentDate == kMAX_TIME - grace); + BEAST_EXPECT(afterState.nextPaymentDate == kMaxTime - grace); BEAST_EXPECT(afterState.previousPaymentDate == 0); BEAST_EXPECT(afterState.paymentRemaining == 1); } @@ -5218,9 +5311,9 @@ protected: env(pay(issuer, borrower, iouAsset(Number{1'055'524'81, -2}))); // Start date when the ledger is closed will be larger - auto const closeStartDate = (parentCloseTime() / 10 + 1) * 10; + auto const closeStartDate = ((parentCloseTime() / 10) + 1) * 10; auto const grace = 5'000; - auto const maxLoanTime = kMAX_TIME - closeStartDate - grace; + auto const maxLoanTime = kMaxTime - closeStartDate - grace; auto const total = [&]() { if (maxLoanTime % 5 == 0) return 5; @@ -5240,7 +5333,7 @@ protected: auto const interval = maxLoanTime / total; auto createJson = env.json( - baseJson, kPAYMENT_INTERVAL(interval), kPAYMENT_TOTAL(total), kGRACE_PERIOD(grace)); + baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace)); env(createJson, Sig(sfCounterpartySignature, lender), Ter(tesSUCCESS)); env.close(); @@ -5256,8 +5349,7 @@ protected: { NumberRoundModeGuard const mg{Number::RoundingMode::Upward}; Number const payment = beforeState.periodicPayment * (total - 1); - XRPAmount const payFee{ - baseFee * ((total - 1) / kLOAN_PAYMENTS_PER_FEE_INCREMENT + 1)}; + XRPAmount const payFee{baseFee * ((total - 1) / kLoanPaymentsPerFeeIncrement + 1)}; STAmount const paymentAmount = roundToScale(STAmount{broker.asset, payment}, beforeState.loanScale); auto loanPayTx = env.json(pay(borrower, keylet.key, paymentAmount), Fee(payFee)); @@ -5268,8 +5360,8 @@ protected: // The loan is on the last payment auto const afterState = getCurrentState(env, broker, keylet); BEAST_EXPECT(afterState.paymentRemaining == 1); - BEAST_EXPECT(afterState.nextPaymentDate == kMAX_TIME - grace); - BEAST_EXPECT(afterState.previousPaymentDate == kMAX_TIME - grace - interval); + BEAST_EXPECT(afterState.nextPaymentDate == kMaxTime - grace); + BEAST_EXPECT(afterState.previousPaymentDate == kMaxTime - grace - interval); } } @@ -5291,7 +5383,7 @@ protected: .env = env, .issuer = issuer, .holders = {lender, borrower}, - .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth | tfMPTCanClawback | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTRequireAuth | tfMPTCanClawback | tfMPTCanLock, .authHolder = true, }); @@ -5320,8 +5412,8 @@ protected: err); }); - std::uint32_t constexpr kLOAN_SEQUENCE = 1; - auto const loanKeylet = keylet::loan(brokerInfo.brokerID, kLOAN_SEQUENCE); + static constexpr std::uint32_t kLoanSequence = 1; + auto const loanKeylet = keylet::loan(brokerInfo.brokerID, kLoanSequence); // Can't loan pay if the borrower is not authorized forUnauthAuth([&](bool authorized) { @@ -5333,7 +5425,7 @@ protected: void testCoverDepositWithdrawNonTransferableMPT(FeatureBitset feature) { - testcase("CoverDeposit and CoverWithdraw reject MPT without CanTransfer"); + testcase("CoverDeposit blocked, CoverWithdraw allowed when CanTransfer cleared"); using namespace jtx; using namespace loanBroker; @@ -5345,19 +5437,14 @@ protected: env.fund(XRP(100'000), issuer, alice); env.close(); - MPTTester mpt{env, issuer, kMPT_INIT_NO_FUND}; - - mpt.create({.flags = tfMPTCanTransfer, .mutableFlags = tmfMPTCanMutateCanTransfer}); - - env.close(); - + MPTTester mpt( + {.env = env, + .issuer = issuer, + .holders = {alice}, + .pay = 100, + .flags = tfMPTCanTransfer, + .mutableFlags = tmfMPTCanMutateCanTransfer}); PrettyAsset const asset = mpt["MPT"]; - mpt.authorize({.account = alice}); - env.close(); - - // Issuer can fund the holder even if CanTransfer is not set. - env(pay(issuer, alice, asset(100))); - env.close(); Vault const vault{env}; auto const [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = asset}); @@ -5374,30 +5461,9 @@ protected: Account const pseudoAccount{"Loan Broker pseudo-account", brokerSle->at(sfAccount)}; - // Remove CanTransfer after the broker is set up. - mpt.set({.mutableFlags = tmfMPTClearCanTransfer}); - env.close(); - - // Standard Payment path should forbid third-party transfers. - auto const err = feature[featureMPTokensV2] ? tecNO_PERMISSION : tecNO_AUTH; - env(pay(alice, pseudoAccount, asset(1)), Ter(err)); - env.close(); - - // Cover cannot be transferred to broker account + // First, deposit some cover while CanTransfer is set so we have an + // existing position to withdraw from after the governance action. auto const depositAmount = asset(1); - env(coverDeposit(alice, brokerKeylet.key, depositAmount), Ter{tecNO_AUTH}); - env.close(); - - if (auto const refreshed = env.le(brokerKeylet); BEAST_EXPECT(refreshed)) - { - BEAST_EXPECT(refreshed->at(sfCoverAvailable) == 0); - env.require(Balance(pseudoAccount, asset(0))); - } - - // Set CanTransfer again and transfer some deposit - mpt.set({.mutableFlags = tmfMPTSetCanTransfer}); - env.close(); - env(coverDeposit(alice, brokerKeylet.key, depositAmount)); env.close(); @@ -5407,38 +5473,189 @@ protected: env.require(Balance(pseudoAccount, depositAmount)); } - // Remove CanTransfer after the deposit + // Issuer governance: clear CanTransfer. mpt.set({.mutableFlags = tmfMPTClearCanTransfer}); env.close(); - // Cover cannot be transferred from broker account - env(coverWithdraw(alice, brokerKeylet.key, depositAmount), Ter{tecNO_AUTH}); + // Standard Payment path still forbids third-party transfers. + auto const err = feature[featureMPTokensV2] ? tecNO_PERMISSION : tecNO_AUTH; + env(pay(alice, pseudoAccount, asset(1)), Ter(err)); env.close(); - // Set CanTransfer again and withdraw - mpt.set({.mutableFlags = tmfMPTSetCanTransfer}); - env.close(); - - env(coverWithdraw(alice, brokerKeylet.key, depositAmount)); + // New cover deposits are blocked - this would create new exposure. + env(coverDeposit(alice, brokerKeylet.key, depositAmount), Ter{tecNO_AUTH}); env.close(); if (auto const refreshed = env.le(brokerKeylet); BEAST_EXPECT(refreshed)) { - BEAST_EXPECT(refreshed->at(sfCoverAvailable) == 0); - env.require(Balance(pseudoAccount, asset(0))); + BEAST_EXPECT(refreshed->at(sfCoverAvailable) == 1); + env.require(Balance(pseudoAccount, depositAmount)); } + + bool const postAmendment = feature[fixCleanup3_2_0]; + if (postAmendment) + { + // Post-fixCleanup3_2_0: existing cover can always be withdrawn + // even when CanTransfer is cleared, so the broker is not trapped. + env(coverWithdraw(alice, brokerKeylet.key, depositAmount)); + env.close(); + + if (auto const refreshed = env.le(brokerKeylet); BEAST_EXPECT(refreshed)) + { + BEAST_EXPECT(refreshed->at(sfCoverAvailable) == 0); + env.require(Balance(pseudoAccount, asset(0))); + } + } + else + { + // Pre-fixCleanup3_2_0 regression: cover withdraw was blocked, + // trapping the broker's first-loss capital. + env(coverWithdraw(alice, brokerKeylet.key, depositAmount), Ter{tecNO_AUTH}); + env.close(); + + if (auto const refreshed = env.le(brokerKeylet); BEAST_EXPECT(refreshed)) + { + BEAST_EXPECT(refreshed->at(sfCoverAvailable) == 1); + env.require(Balance(pseudoAccount, depositAmount)); + } + } + } + + void + testLoanSetBlockedLoanPayAllowedWhenCanTransferCleared() + { + testcase("LoanSet blocked, LoanPay allowed when CanTransfer cleared"); + using namespace jtx; + using namespace loan; + + 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(); + + MPTTester mpt( + {.env = env, + .issuer = issuer, + .holders = {lender, borrower}, + .flags = tfMPTCanTransfer | tfMPTCanLock, + .mutableFlags = tmfMPTCanMutateCanTransfer}); + PrettyAsset const asset = mpt.issuanceID(); + env(pay(issuer, lender, asset(10'000'000))); + // Fund the borrower with enough to cover principal+interest+fees + env(pay(issuer, borrower, asset(100'000))); + env.close(); + + // Create vault and broker while CanTransfer is set. + auto const broker = createVaultAndBroker(env, asset, lender); + + auto const loanSetFee = Fee(env.current()->fees().base * 2); + + // Create an existing loan while CanTransfer is set. + env(set(borrower, broker.brokerID, 1'000), + Sig(sfCounterpartySignature, lender), + loanSetFee); + env.close(); + auto const loanKeylet = keylet::loan(broker.brokerID, 1); + BEAST_EXPECT(env.le(loanKeylet)); + + // Issuer governance: clear CanTransfer. + mpt.set({.mutableFlags = tmfMPTClearCanTransfer}); + env.close(); + + // Issuing a NEW loan is blocked - it would create new exposure into + // a pool the issuer is restricting. + env(set(borrower, broker.brokerID, 1'000), + Sig(sfCounterpartySignature, lender), + loanSetFee, + Ter{tecNO_AUTH}); + env.close(); + + // Repaying an existing loan is always allowed - blocking it would + // create irrecoverable bad debt and trap SAV depositor principal. + env(pay(borrower, loanKeylet.key, asset(1'000))); + env.close(); + } + + void + testLendingCanTradeClearedNoImpact() + { + testcase("Lending: CanTrade cleared has no impact"); + using namespace jtx; + using namespace loan; + using namespace loanBroker; + + 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(); + + MPTTester mpt( + {.env = env, + .issuer = issuer, + .holders = {lender, borrower}, + .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanLock, + .mutableFlags = tmfMPTCanMutateCanTrade}); + PrettyAsset const asset = mpt.issuanceID(); + env(pay(issuer, lender, asset(10'000'000))); + env(pay(issuer, borrower, asset(100'000))); + env.close(); + + auto const broker = createVaultAndBroker(env, asset, lender); + + // Sanity: while CanTrade is set, the asset can be placed on the DEX. + env(offer(lender, XRP(1), asset(10))); + env.close(); + + // Issuer governance: clear CanTrade. Loan origination and repayment + // are not trades: nothing in the Lending Protocol should be impacted. + mpt.set({.mutableFlags = tmfMPTClearCanTrade}); + env.close(); + + // Control: clearing CanTrade is observable on the DEX path. + env(offer(lender, XRP(1), asset(10)), Ter{tecNO_PERMISSION}); + env.close(); + + auto const loanSetFee = Fee(env.current()->fees().base * 2); + + // New cover deposits still work. + env(coverDeposit(lender, broker.brokerID, asset(100))); + env.close(); + + // New loan issuance still works. + env(loan::set(borrower, broker.brokerID, 1'000), + Sig(sfCounterpartySignature, lender), + loanSetFee); + env.close(); + auto const loanKeylet = keylet::loan(broker.brokerID, 1); + BEAST_EXPECT(env.le(loanKeylet)); + + // Repayment still works. + env(pay(borrower, loanKeylet.key, asset(1'000))); + env.close(); + + // Cover withdrawal still works. + env(coverWithdraw(lender, broker.brokerID, asset(100))); + env.close(); } #if LOAN_TODO void - testLoanPayLateFullPaymentBypassesPenalties() + testLoanPayLateFullPaymentBypassesPenalties(FeatureBitset features) { testcase("LoanPay full payment skips late penalties"); using namespace jtx; using namespace loan; using namespace std::chrono_literals; - Env env(*this, all); + Env env(*this, features); Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -5472,15 +5689,15 @@ protected: env(set(borrower, broker.brokerID, principal), Sig(sfCounterpartySignature, lender), - kLOAN_SERVICE_FEE(serviceFee), - kLATE_PAYMENT_FEE(lateFee), - kCLOSE_PAYMENT_FEE(closeFee), - kINTEREST_RATE(percentageToTenthBips(12)), - kLATE_INTEREST_RATE(percentageToTenthBips(24) / 10), - kCLOSE_INTEREST_RATE(percentageToTenthBips(5)), - kPAYMENT_TOTAL(12), - kPAYMENT_INTERVAL(600), - kGRACE_PERIOD(0), + kLoanServiceFee(serviceFee), + kLatePaymentFee(lateFee), + kClosePaymentFee(closeFee), + kInterestRate(percentageToTenthBips(12)), + kLateInterestRate(percentageToTenthBips(24) / 10), + kCloseInterestRate(percentageToTenthBips(5)), + kPaymentTotal(12), + kPaymentInterval(600), + kGracePeriod(0), Fee(loanSetFee)); env.close(); @@ -5516,7 +5733,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 = @@ -5580,7 +5801,7 @@ protected: } void - testLoanCoverMinimumRoundingExploit() + testLoanCoverMinimumRoundingExploit(FeatureBitset features) { auto testLoanCoverMinimumRoundingExploit = [&, this](Number const& principalRequest) { testcase << "LoanBrokerCoverClawback drains cover via rounding" @@ -5590,7 +5811,7 @@ protected: using namespace loan; using namespace loanBroker; - Env env(*this, all); + Env env(*this, features); Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -5618,9 +5839,9 @@ protected: set(borrower, broker.brokerID, principalRequest), Sig(sfCounterpartySignature, lender), loanSetFee, - kPAYMENT_INTERVAL(600), - kPAYMENT_TOTAL(1), - kGRACE_PERIOD(60)); + kPaymentInterval(600), + kPaymentTotal(1), + kGracePeriod(60)); env(createTx); env.close(); @@ -5666,7 +5887,7 @@ protected: #endif void - testPoCUnsignedUnderflowOnFullPayAfterEarlyPeriodic() + testPoCUnsignedUnderflowOnFullPayAfterEarlyPeriodic(FeatureBitset features) { // --- PoC Summary ---------------------------------------------------- // Scenario: Borrower makes one periodic payment early (before next due) @@ -5688,7 +5909,7 @@ protected: using namespace loan; using namespace std::chrono_literals; - Env env(*this, all_); + Env env{*this, features}; Account const lender{"poc_lender4"}; Account const borrower{"poc_borrower4"}; @@ -5719,18 +5940,18 @@ protected: auto createJtx = env.jt( set(borrower, broker.brokerID, principalRequest, 0), Sig(sfCounterpartySignature, lender), - kLOAN_ORIGINATION_FEE(originationFee), - kLOAN_SERVICE_FEE(serviceFee), - kLATE_PAYMENT_FEE(lateFee), - kCLOSE_PAYMENT_FEE(closeFee), - kOVERPAYMENT_FEE(percentageToTenthBips(5) / 10), - kINTEREST_RATE(interest), - kLATE_INTEREST_RATE(lateInterest), - kCLOSE_INTEREST_RATE(closeInterest), - kOVERPAYMENT_INTEREST_RATE(overpaymentInterest), - kPAYMENT_TOTAL(total), - kPAYMENT_INTERVAL(interval), - kGRACE_PERIOD(grace), + kLoanOriginationFee(originationFee), + kLoanServiceFee(serviceFee), + kLatePaymentFee(lateFee), + kClosePaymentFee(closeFee), + kOverpaymentFee(percentageToTenthBips(5) / 10), + kInterestRate(interest), + kLateInterestRate(lateInterest), + kCloseInterestRate(closeInterest), + kOverpaymentInterestRate(overpaymentInterest), + kPaymentTotal(total), + kPaymentInterval(interval), + kGracePeriod(grace), Fee(loanSetFee)); auto const brokerSle = env.le(keylet::loanbroker(broker.brokerID)); @@ -5745,6 +5966,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 +6000,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 +6036,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, @@ -5884,13 +6112,13 @@ protected: } void - testDustManipulation() + testDustManipulation(FeatureBitset features) { testcase("Dust manipulation"); using namespace jtx; using namespace std::chrono_literals; - Env env(*this, all_); + Env env{*this, features}; // Setup: Create accounts Account const issuer{"issuer"}; @@ -6024,7 +6252,7 @@ protected: } void - testRIPD3831() + testRIPD3831(FeatureBitset features) { using namespace jtx; @@ -6051,7 +6279,7 @@ protected: auto const assetType = AssetType::XRP; - Env env(*this, all_); + Env env{*this, features}; auto loanResult = createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower); @@ -6097,7 +6325,7 @@ protected: } void - testRIPD3459() + testRIPD3459(FeatureBitset features) { testcase("RIPD-3459 - LoanBroker incorrect debt total"); @@ -6122,7 +6350,7 @@ protected: auto const assetType = AssetType::MPT; - Env env(*this, all_); + Env env{*this, features}; auto loanResult = createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower); @@ -6160,7 +6388,7 @@ protected: if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle)) { BEAST_EXPECT(brokerSle->at(sfDebtTotal) == loanSle->at(sfTotalValueOutstanding)); - BEAST_EXPECT(brokerSle->at(sfDebtTotal) == beast::kZERO); + BEAST_EXPECT(brokerSle->at(sfDebtTotal) == beast::kZero); } } } @@ -6202,9 +6430,9 @@ protected: env(set(borrower, brokerKeyLet.key, debtMaximumRequest), Sig(sfCounterpartySignature, lender), - kINTEREST_RATE(TenthBips32(50'000)), - kPAYMENT_TOTAL(2), - kPAYMENT_INTERVAL(150), + kInterestRate(TenthBips32(50'000)), + kPaymentTotal(2), + kPaymentInterval(150), Txflags(tfLoanOverpayment), txFee); env.close(); @@ -6222,14 +6450,14 @@ protected: } void - testRoundingAllowsUndercoverage() + testRoundingAllowsUndercoverage(FeatureBitset features) { testcase("Minimum cover rounding allows undercoverage (XRP)"); using namespace jtx; using namespace loanBroker; - Env env(*this, all_); + Env env{*this, features}; Account const lender{"lender"}; Account const borrower{"borrower"}; @@ -6258,7 +6486,7 @@ protected: // Create a loan with principal 804 XRP and 0% interest (so // DebtTotal increases by exactly 804) env(loan::set(borrower, brokerInfo.brokerID, xrpAsset(804).value()), - loan::kINTEREST_RATE(TenthBips32(0)), + loan::kInterestRate(TenthBips32(0)), Sig(sfCounterpartySignature, lender), Fee(env.current()->fees().base * 2)); BEAST_EXPECT(env.ter() == tesSUCCESS); @@ -6301,7 +6529,7 @@ protected: } void - testRIPD3902() + testRIPD3902(FeatureBitset features) { testcase("RIPD-3902 - 1 IOU loan payments"); @@ -6328,7 +6556,7 @@ protected: auto const assetType = AssetType::IOU; - Env env(*this, all_); + Env env{*this, features}; auto loanResult = createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower); @@ -6404,10 +6632,10 @@ protected: auto const serviceFee = 101; env(set(broker, brokerKeylet.key, debtMaximumRequest), - kCOUNTERPARTY(borrower), + kCounterparty(borrower), Sig(sfCounterpartySignature, borrower), - kLOAN_SERVICE_FEE(serviceFee), - kPAYMENT_TOTAL(10), + kLoanServiceFee(serviceFee), + kPaymentTotal(10), txFee); env.close(); @@ -6472,7 +6700,7 @@ protected: } void - testIssuerIsBorrower() + testIssuerIsBorrower(FeatureBitset features) { testcase("RIPD-4096 - Issuer as borrower"); @@ -6492,7 +6720,7 @@ protected: auto const assetType = AssetType::IOU; - Env env(*this, all_); + Env env{*this, features}; auto loanResult = createLoan(env, assetType, brokerParams, loanParams, issuer, lender, issuer); @@ -6548,7 +6776,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); @@ -6589,14 +6817,14 @@ protected: } void - testOverpaymentManagementFee() + testOverpaymentManagementFee(FeatureBitset features) { testcase("testOverpaymentManagementFee"); using namespace jtx; using namespace loan; - Env env(*this, all_); + Env env{*this, features}; Account const lender{"lender"}, borrower{"borrower"}; @@ -6621,9 +6849,9 @@ protected: env(loan::set( borrower, result.brokerKeylet().key, asset(10'000).value(), tfLoanOverpayment), Sig(sfCounterpartySignature, lender), - loan::kPAYMENT_INTERVAL(86400 * 30), - loan::kPAYMENT_TOTAL(3), - loan::kOVERPAYMENT_INTEREST_RATE(TenthBips32(percentageToTenthBips(20))), + loan::kPaymentInterval(86400 * 30), + loan::kPaymentTotal(3), + loan::kOverpaymentInterestRate(TenthBips32(percentageToTenthBips(20))), loanSetFee); // From calculator @@ -6642,7 +6870,7 @@ protected: } void - testLoanPayBrokerOwnerMissingTrustline() + testLoanPayBrokerOwnerMissingTrustline(FeatureBitset features) { testcase << "LoanPay Broker Owner Missing Trustline (PoC)"; using namespace jtx; @@ -6651,7 +6879,7 @@ protected: Account const borrower("borrower"); Account const broker("broker"); auto const iou = issuer["IOU"]; - Env env(*this, all_); + Env env(*this, features); env.fund(XRP(20'000), issuer, broker, borrower); env.close(); // Set up trustlines and fund accounts @@ -6666,8 +6894,8 @@ protected: auto const keylet = keylet::loan(brokerInfo.brokerID, 1); env(set(borrower, brokerInfo.brokerID, 10'000), Sig(sfCounterpartySignature, broker), - kLOAN_SERVICE_FEE(iou(100).value()), - kPAYMENT_INTERVAL(100), + kLoanServiceFee(iou(100).value()), + kPaymentInterval(100), Fee(XRP(100))); env.close(); // Ensure broker has sufficient cover so brokerPayee == brokerOwner @@ -6710,7 +6938,7 @@ protected: } void - testLoanPayBrokerOwnerUnauthorizedMPT() + testLoanPayBrokerOwnerUnauthorizedMPT(FeatureBitset features) { testcase << "LoanPay Broker Owner MPT unauthorized"; using namespace jtx; @@ -6720,11 +6948,11 @@ protected: Account const borrower("borrower"); Account const broker("broker"); - Env env(*this, all_); + Env env{*this, features}; env.fund(XRP(20'000), issuer, broker, borrower); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); PrettyAsset const mpt{mptt.issuanceID()}; @@ -6746,8 +6974,8 @@ protected: auto const keylet = keylet::loan(brokerInfo.brokerID, 1); env(set(borrower, brokerInfo.brokerID, 10'000), Sig(sfCounterpartySignature, broker), - kLOAN_SERVICE_FEE(mpt(100).value()), - kPAYMENT_INTERVAL(100), + kLoanServiceFee(mpt(100).value()), + kPaymentInterval(100), Fee(XRP(100))); env.close(); // Ensure broker has sufficient cover so brokerPayee == brokerOwner @@ -6791,7 +7019,7 @@ protected: } void - testLoanPayBrokerOwnerNoPermissionedDomainMPT() + testLoanPayBrokerOwnerNoPermissionedDomainMPT(FeatureBitset features) { testcase << "LoanPay Broker Owner without permissioned domain of the MPT"; using namespace jtx; @@ -6801,13 +7029,13 @@ protected: Account const borrower("borrower"); Account const broker("broker"); - Env env(*this, all_); + Env env{*this, features}; env.fund(XRP(20'000), issuer, broker, borrower); env.close(); auto credType = "credential1"; - pdomain::Credentials const credentials1{{issuer, credType}}; + pdomain::Credentials const credentials1 = {{.issuer = issuer, .credType = credType}}; env(pdomain::setTx(issuer, credentials1)); env.close(); @@ -6821,7 +7049,7 @@ protected: env(credentials::accept(borrower, issuer, credType)); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({ .flags = tfMPTCanClawback | tfMPTRequireAuth | tfMPTCanTransfer | tfMPTCanLock, .domainID = domainID, @@ -6846,8 +7074,8 @@ protected: auto const keylet = keylet::loan(brokerInfo.brokerID, 1); env(set(borrower, brokerInfo.brokerID, 10'000), Sig(sfCounterpartySignature, broker), - kLOAN_SERVICE_FEE(mpt(100).value()), - kPAYMENT_INTERVAL(100), + kLoanServiceFee(mpt(100).value()), + kPaymentInterval(100), Fee(XRP(100))); env.close(); // Ensure broker has sufficient cover so brokerPayee == brokerOwner @@ -6894,7 +7122,7 @@ protected: } void - testLoanSetBrokerOwnerNoPermissionedDomainMPT() + testLoanSetBrokerOwnerNoPermissionedDomainMPT(FeatureBitset features) { testcase << "LoanSet Broker Owner without permissioned domain of the MPT"; using namespace jtx; @@ -6904,13 +7132,13 @@ protected: Account const borrower("borrower"); Account const broker("broker"); - Env env(*this, all_); + Env env{*this, features}; env.fund(XRP(20'000), issuer, broker, borrower); env.close(); auto credType = "credential1"; - pdomain::Credentials const credentials1{{issuer, credType}}; + pdomain::Credentials const credentials1{{.issuer = issuer, .credType = credType}}; env(pdomain::setTx(issuer, credentials1)); env.close(); @@ -6925,7 +7153,7 @@ protected: env(credentials::accept(borrower, issuer, credType)); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({ .flags = tfMPTCanClawback | tfMPTRequireAuth | tfMPTCanTransfer | tfMPTCanLock, .domainID = domainID, @@ -6958,15 +7186,15 @@ protected: // Create a loan, this should fail for tecNO_AUTH env(set(borrower, brokerInfo.brokerID, 10'000), Sig(sfCounterpartySignature, broker), - kLOAN_SERVICE_FEE(mpt(100).value()), - kPAYMENT_INTERVAL(100), + kLoanServiceFee(mpt(100).value()), + kPaymentInterval(100), Fee(XRP(100)), Ter(tecNO_AUTH)); env.close(); } void - testSequentialFLCDepletion() + testSequentialFLCDepletion(FeatureBitset features) { testcase << "First-Loss Capital Depletion on Sequential Defaults"; @@ -6974,7 +7202,7 @@ protected: using namespace loan; using namespace loanBroker; - Env env(*this, all_); + Env env{*this, features}; Account const issuer{"issuer"}; Account const lender{"lender"}; @@ -7015,10 +7243,10 @@ protected: auto loanATx = env.jt( set(borrowerA, brokerKeylet.key, principalAmount), Sig(sfCounterpartySignature, lender), - kINTEREST_RATE(TenthBips32(500)), // 5% - kPAYMENT_TOTAL(12), - loan::kPAYMENT_INTERVAL(loanPaymentInterval), - loan::kGRACE_PERIOD(loanGracePeriod), + kInterestRate(TenthBips32(500)), // 5% + kPaymentTotal(12), + loan::kPaymentInterval(loanPaymentInterval), + loan::kGracePeriod(loanGracePeriod), Fee(XRP(10))); // Sufficient fee for multi-sig transaction env(loanATx); env.close(); @@ -7029,10 +7257,10 @@ protected: auto loanBTx = env.jt( set(borrowerB, brokerKeylet.key, principalAmount), Sig(sfCounterpartySignature, lender), - kINTEREST_RATE(TenthBips32(500)), // 5% - kPAYMENT_TOTAL(12), - loan::kPAYMENT_INTERVAL(loanPaymentInterval), - loan::kGRACE_PERIOD(loanGracePeriod), + kInterestRate(TenthBips32(500)), // 5% + kPaymentTotal(12), + loan::kPaymentInterval(loanPaymentInterval), + loan::kGracePeriod(loanGracePeriod), Fee(XRP(10))); // Sufficient fee for multi-sig transaction env(loanBTx); env.close(); @@ -7084,11 +7312,149 @@ 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::kInterestRate(interestRate), + loan::kPaymentInterval(paymentInterval), + loan::kPaymentTotal(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. void - testWithdrawReflectsUnrealizedLoss() + testWithdrawReflectsUnrealizedLoss(FeatureBitset features) { using namespace jtx; using namespace loan; @@ -7097,17 +7463,17 @@ protected: testcase("Vault withdraw reflects sfLossUnrealized"); // Test constants - static constexpr std::int64_t kINITIAL_FUNDING = 1'000'000; - static constexpr std::int64_t kLENDER_INITIAL_IOU = 5'000'000; - static constexpr std::int64_t kDEPOSITOR_INITIAL_IOU = 1'000'000; - static constexpr std::int64_t kBORROWER_INITIAL_IOU = 100'000; - static constexpr std::int64_t kDEPOSIT_AMOUNT = 5'000; - static constexpr std::int64_t kPRINCIPAL_AMOUNT = 99; - static constexpr std::uint64_t kEXPECTED_SHARES_PER_DEPOSITOR = 5'000'000'000; - static constexpr std::uint32_t kLOCAL_PAYMENT_INTERVAL = 600; - static constexpr std::uint32_t kLOCAL_PAYMENT_TOTAL = 2; + static constexpr std::int64_t kInitialFunding = 1'000'000; + static constexpr std::int64_t kLenderInitialIou = 5'000'000; + static constexpr std::int64_t kDepositorInitialIou = 1'000'000; + static constexpr std::int64_t kBorrowerInitialIou = 100'000; + static constexpr std::int64_t kDepositAmount = 5'000; + static constexpr std::int64_t kPrincipalAmount = 99; + static constexpr std::uint64_t kExpectedSharesPerDepositor = 5'000'000'000; + static constexpr std::uint32_t kLocalPaymentInterval = 600; + static constexpr std::uint32_t kLocalPaymentTotal = 2; - Env env(*this, all_); + Env env{*this, features}; // Setup accounts Account const issuer{"issuer"}; @@ -7116,7 +7482,7 @@ protected: Account const depositorB{"lpB"}; Account const borrower{"borrowerA"}; - env.fund(XRP(kINITIAL_FUNDING), issuer, lender, depositorA, depositorB, borrower); + env.fund(XRP(kInitialFunding), issuer, lender, depositorA, depositorB, borrower); env.close(); // Setup trust lines @@ -7128,10 +7494,10 @@ protected: env.close(); // Fund accounts with IOUs - env(pay(issuer, lender, iouAsset(kLENDER_INITIAL_IOU))); - env(pay(issuer, depositorA, iouAsset(kDEPOSITOR_INITIAL_IOU))); - env(pay(issuer, depositorB, iouAsset(kDEPOSITOR_INITIAL_IOU))); - env(pay(issuer, borrower, iouAsset(kBORROWER_INITIAL_IOU))); + env(pay(issuer, lender, iouAsset(kLenderInitialIou))); + env(pay(issuer, depositorA, iouAsset(kDepositorInitialIou))); + env(pay(issuer, depositorB, iouAsset(kDepositorInitialIou))); + env(pay(issuer, borrower, iouAsset(kBorrowerInitialIou))); env.close(); // Create vault and broker, then add deposits from two depositors @@ -7141,13 +7507,13 @@ protected: env(v.deposit({ .depositor = depositorA, .id = broker.vaultKeylet().key, - .amount = iouAsset(kDEPOSIT_AMOUNT), + .amount = iouAsset(kDepositAmount), }), Ter(tesSUCCESS)); env(v.deposit({ .depositor = depositorB, .id = broker.vaultKeylet().key, - .amount = iouAsset(kDEPOSIT_AMOUNT), + .amount = iouAsset(kDepositAmount), }), Ter(tesSUCCESS)); env.close(); @@ -7159,10 +7525,10 @@ protected: auto const loanKeylet = keylet::loan(broker.brokerID, sleBroker->at(sfLoanSequence)); - env(set(borrower, broker.brokerID, kPRINCIPAL_AMOUNT), + env(set(borrower, broker.brokerID, kPrincipalAmount), Sig(sfCounterpartySignature, lender), - kPAYMENT_TOTAL(kLOCAL_PAYMENT_TOTAL), - kPAYMENT_INTERVAL(kLOCAL_PAYMENT_INTERVAL), + kPaymentTotal(kLocalPaymentTotal), + kPaymentInterval(kLocalPaymentInterval), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); env.close(); @@ -7177,7 +7543,7 @@ protected: return; BEAST_EXPECT( - vaultAfterImpair->at(sfLossUnrealized) == broker.asset(kPRINCIPAL_AMOUNT).value()); + vaultAfterImpair->at(sfLossUnrealized) == broker.asset(kPrincipalAmount).value()); // Helper to get share balance for a depositor auto const shareAsset = vaultAfterImpair->at(sfShareMPTID); @@ -7189,8 +7555,8 @@ protected: // Verify both depositors have equal shares auto const sharesLpA = getShareBalance(depositorA); auto const sharesLpB = getShareBalance(depositorB); - BEAST_EXPECT(sharesLpA == kEXPECTED_SHARES_PER_DEPOSITOR); - BEAST_EXPECT(sharesLpB == kEXPECTED_SHARES_PER_DEPOSITOR); + BEAST_EXPECT(sharesLpA == kExpectedSharesPerDepositor); + BEAST_EXPECT(sharesLpB == kExpectedSharesPerDepositor); BEAST_EXPECT(sharesLpA == sharesLpB); // Helper to attempt withdrawal @@ -7214,62 +7580,854 @@ protected: attemptWithdrawShares(depositorB, sharesLpB, tesSUCCESS); } + // An overpayment whose residual amount has more precision than loanScale + // fires the isRounded(asset, overpayment, loanScale) assertion in + // computeOverpaymentComponents (and a downstream "interest paid agrees" + // assertion in doOverpayment). fixCleanup3_2_0 rounds the residual down + // to loanScale before passing it in. The pre-amendment path can't be + // tested here because the assertion fires in Debug builds and aborts + // the test process — see the PR description for context. + void + testBugOverpayUnroundedAmount() + { + testcase("bug: computeOverpaymentComponents isRounded assertion"); + + using namespace jtx; + using namespace loan; + Env env(*this, all_); + + Account const issuer{"issuer"}; + Account const lender{"vaultOwner"}; + Account const borrower{"borrower"}; + + env.fund(XRP(1'000'000), issuer, lender, borrower); + env(fset(issuer, asfDefaultRipple)); + env.close(); + + PrettyAsset const iouAsset = issuer["USD"]; + STAmount const iouLimit{iouAsset.raw(), Number{9'999'999'999'999'999LL}}; + env(trust(lender, iouLimit)); + env(trust(borrower, iouLimit)); + env(pay(issuer, lender, iouAsset(1'000'000))); + env(pay(issuer, borrower, iouAsset(1'000'000))); + env.close(); + + auto const broker = createVaultAndBroker( + env, + iouAsset, + lender, + {.vaultDeposit = 100'000, + .debtMax = 5000, + .managementFeeRate = TenthBips16{1000}, + .vaultScale = 1}); + + auto const sleBroker = env.le(broker.brokerKeylet()); + if (!BEAST_EXPECT(sleBroker)) + return; + auto const loanSequence = sleBroker->at(sfLoanSequence); + auto const loanKeylet = keylet::loan(broker.brokerID, loanSequence); + + using namespace loan; + env(set(borrower, broker.brokerID, Number{1000}, tfLoanOverpayment), + Sig(sfCounterpartySignature, lender), + kInterestRate(TenthBips32{10000}), + kPaymentTotal(12), + kPaymentInterval(60), + kGracePeriod(60), + kOverpaymentFee(TenthBips32{1000}), + kOverpaymentInterestRate(TenthBips32{1000}), + Fee(env.current()->fees().base * 2), + Ter(tesSUCCESS)); + env.close(); + + // periodic * 1.5 at 15-sig-digit precision: 125.000154585042. This + // has too many digits to round cleanly to loanScale=-10, so the + // overpayment residual fails the isRounded check. + STAmount const payAmount{iouAsset.raw(), Number{125'000'154'585'042LL, -12}}; + env(pay(borrower, loanKeylet.key, payAmount), Txflags(tfLoanOverpayment), Ter(tesSUCCESS)); + env.close(); + } + + // Regression for the dual-rounding fix at coarse (integer-MPT) scale. + // + // Loan: P=1, r=50% (50000 tenth-bips), n=3, yearly interval. The + // amortization schedule produces a fractional principal + // (~0.47) which under round-to-nearest collapses to 0 in a single + // step, causing `doPayment`'s strict `>` assertion on principal to + // fire mid-loan. With fixCleanup3_2_0 enabled, principal is rounded + // upward (sticks at 1 across the first two periods) and only clears + // in the final payment. + // + // The test pays one period at a time across three LoanPay + // transactions and verifies the loan completes (paymentRemaining=0) + // with totals matching the loan's economics (1 principal + 2 interest). + void + testIntegerScalePrincipalSticks(FeatureBitset features) + { + // Without fixCleanup3_2_0, this behavior will abort the server, so + // don't run without it. + if (!features[fixCleanup3_2_0]) + return; + + testcase("edge: integer MPT principal stuck mid-loan completes via final"); + + using namespace jtx; + Env env(*this, features); + + Account const issuer{"issuer"}; + Account const lender{"lender"}; + Account const borrower{"borrower"}; + + env.fund(XRP(100'000), issuer, lender, borrower); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.maxAmt = 100'000, .flags = tfMPTCanTransfer}); + PrettyAsset const asset{mptt.issuanceID()}; + + mptt.authorize({.account = lender}); + mptt.authorize({.account = borrower}); + + env(pay(issuer, lender, asset(10'000))); + env(pay(issuer, borrower, asset(10'000))); + env.close(); + + Vault const vault{env}; + auto [vaultTx, vaultKeylet] = vault.create({.owner = lender, .asset = asset}); + env(vaultTx); + env.close(); + + env(vault.deposit({.depositor = lender, .id = vaultKeylet.key, .amount = asset(5'000)})); + env.close(); + + auto const brokerKeylet = keylet::loanbroker(lender.id(), env.seq(lender)); + env(loanBroker::set(lender, vaultKeylet.key), + loanBroker::kDebtMaximum(Number{100}), + Fee(env.current()->fees().base * 2)); + env.close(); + + auto const brokerStateBefore = env.le(brokerKeylet); + if (!BEAST_EXPECT(brokerStateBefore)) + return; + auto const loanSequence = brokerStateBefore->at(sfLoanSequence); + auto const loanKeylet = keylet::loan(brokerKeylet.key, loanSequence); + + env(loan::set(borrower, brokerKeylet.key, Number{1}), + Sig(sfCounterpartySignature, lender), + loan::kInterestRate(TenthBips32{50'000}), + loan::kPaymentTotal(3), + loan::kPaymentInterval(31'536'000), + Fee(env.current()->fees().base * 2)); + env.close(); + + auto const borrowerStart = env.balance(borrower, asset).value(); + + // Three separate periodic payments of 1 each. Expected per-period + // evolution at integer MPT scale (TVO = PO + interestDue + + // managementFeeDue): + // start: PO=1, TVO=3, paymentRemaining=3 + // after pay #1: PO=1, TVO=2, paymentRemaining=2 (principal sticks) + // after pay #2: PO=1, TVO=1, paymentRemaining=1 (principal sticks) + // after pay #3: PO=0, TVO=0, paymentRemaining=0 (final clears) + std::array const expectedPO{Number{1}, Number{1}, Number{0}}; + std::array const expectedTVO{Number{2}, Number{1}, Number{0}}; + std::array const expectedRemaining{2, 1, 0}; + + for (int i = 0; i < 3; ++i) + { + env(loan::pay(borrower, loanKeylet.key, asset(1)), Ter(tesSUCCESS)); + env.close(); + + auto const sle = env.le(loanKeylet); + if (!BEAST_EXPECT(sle)) + return; + BEAST_EXPECT(sle->at(sfPrincipalOutstanding) == expectedPO[i]); + BEAST_EXPECT(sle->at(sfTotalValueOutstanding) == expectedTVO[i]); + BEAST_EXPECT(sle->at(sfPaymentRemaining) == expectedRemaining[i]); + } + + // Borrower paid 3 total regardless of fee split (1 principal + 2 + // interest+fee, matching loan economics). + auto const borrowerEnd = env.balance(borrower, asset).value(); + BEAST_EXPECT(borrowerStart - borrowerEnd == asset(3).value()); + } + + // 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)); + } + + // Verify that LoanPay, LoanBrokerCoverWithdraw, and LoanSet all use the + // same vault-scale minimum cover when fixCleanup3_2_0 is enabled. + // Before the amendment, each transactor computed its minimum cover at a + // different precision (loanScale, debtScale, or the raw unrounded + // tenthBipsOfValue), which could lead to inconsistent decisions for the + // same broker state. After the amendment all three use + // minimumBrokerCover at vaultScale. + void + testMinimumBrokerCoverConsistency(FeatureBitset features) + { + using namespace jtx; + using namespace loan; + using namespace loanBroker; + + bool const withAmendment = features[fixCleanup3_2_0]; + + struct Ctx + { + jtx::Account issuer; + jtx::Account lender; + jtx::Account borrower; + jtx::PrettyAsset iou; + BrokerInfo broker; + BrokerParameters brokerParams; + }; + + // Shared setup, parametrized by vaultDeposit (the only varying setup + // field across the three scenarios). Each call runs in its own Env + // so multiple invocations within one scenario cannot interfere. + // The caller is responsible for invoking testcase(...) before the + // first runTest call of each scenario. + auto runTest = [&](Number vaultDeposit, auto&& body) { + Env env(*this, features); + + Account const issuer{"issuer"}; + Account const lender{"lender"}; + Account const borrower{"borrower"}; + + env.fund(XRP(1'000'000'000), issuer, lender, borrower); + env.close(); + + // Enable clawback on the issuer *before* any trust lines exist + // (asfAllowTrustLineClawback requires an empty owner directory). + env(fset(issuer, asfAllowTrustLineClawback)); + env.close(); + + PrettyAsset const iou = issuer[iouCurrency_]; + env(trust(lender, iou(1'000'000'000))); + env(trust(borrower, iou(1'000'000'000))); + env.close(); + env(pay(issuer, lender, iou(100'000'000))); + env(pay(issuer, borrower, iou(100'000'000))); + env.close(); + + // 13.37% — non-round rate produces a messier minimum. + BrokerParameters const brokerParams{ + .vaultDeposit = vaultDeposit, + .debtMax = 0, + .coverRateMin = TenthBips32{13'370}, + .coverDeposit = 5'000, + .managementFeeRate = TenthBips16{500}}; + + BrokerInfo const broker = createVaultAndBroker(env, iou, lender, brokerParams); + + body( + env, + Ctx{.issuer = issuer, + .lender = lender, + .borrower = borrower, + .iou = iou, + .broker = broker, + .brokerParams = brokerParams}); + }; + + // Scenario 1 — LoanPay + // + // Verify that LoanPay's minimum cover check uses vault scale (not + // loan scale). Before the amendment, different loans could produce + // different fee routing decisions for the same broker-level state. + // Small vault deposit => vaultScale = -12. + testcase("LoanPay minimum cover scale consistency"); + { + struct LoanKeylets + { + Keylet tiny; + Keylet big; + }; + + // Create the tiny + big loans and reduce cover via clawback so + // that subsequent LoanPay calls hit the minimum-cover boundary. + // Used by the two pay-and-check sub-tests below so each can run + // in its own Env. + auto setupLoansAndClawback = [&](Env& env, Ctx const& c) -> std::optional { + Asset const asset{c.iou}; + + // Create the TINY loan first (while vaultScale is still + // small). principal 0.01, 0% interest, 1 payment => + // loanScale = vaultScale. + auto const brokerSle1 = env.le(keylet::loanbroker(c.broker.brokerID)); + if (!BEAST_EXPECT(brokerSle1)) + return std::nullopt; + auto const tinyLoanSeq = brokerSle1->at(sfLoanSequence); + auto const tinyLoanKeylet = keylet::loan(c.broker.brokerID, tinyLoanSeq); + + env(set(c.borrower, c.broker.brokerID, Number{1, -2}), + Sig(sfCounterpartySignature, c.lender), + kInterestRate(TenthBips32{0}), + kPaymentTotal(1), + kPaymentInterval(86400 * 365), + Fee(XRP(10))); + env.close(); + + // Create the BIG loan second. 100% annual interest over 20 + // payments pushes totalValueOutstanding high enough that + // loanScale > vaultScale. + auto const brokerSle2 = env.le(keylet::loanbroker(c.broker.brokerID)); + if (!BEAST_EXPECT(brokerSle2)) + return std::nullopt; + auto const bigLoanSeq = brokerSle2->at(sfLoanSequence); + auto const bigLoanKeylet = keylet::loan(c.broker.brokerID, bigLoanSeq); + + env(set(c.borrower, c.broker.brokerID, Number{500}), + Sig(sfCounterpartySignature, c.lender), + kInterestRate(TenthBips32{100'000}), + kPaymentTotal(20), + kPaymentInterval(86400 * 365), + Fee(XRP(10))); + env.close(); + + // The tiny loan's scale is frozen at the vault's pre-big-loan + // scale, so it is strictly smaller than the big loan's. + // After the big loan is created the vault absorbs its value, + // pushing vaultScale up to match bigLoanScale. + auto const tinyLoanSle = env.le(tinyLoanKeylet); + auto const bigLoanSle = env.le(bigLoanKeylet); + auto const vaultSle = env.le(keylet::vault(c.broker.vaultID)); + if (!BEAST_EXPECT(tinyLoanSle) || !BEAST_EXPECT(bigLoanSle) || + !BEAST_EXPECT(vaultSle)) + return std::nullopt; + if (!BEAST_EXPECT(tinyLoanSle->at(sfLoanScale) == -12) || + !BEAST_EXPECT(bigLoanSle->at(sfLoanScale) == -11) || + !BEAST_EXPECT(getAssetsTotalScale(vaultSle) == -11)) + return std::nullopt; + + // Use issuer clawback to reduce cover to the minimum the + // clawback transactor allows. Compute the amount as + // initialCover - expectedCoverAfter so we exercise the exact + // clawback rather than relying on the transactor to clip + // down. + // + // Before the amendment the clawback minimum is the + // *unrounded* tenthBipsOfValue — strictly less than the + // rounded-at-vaultScale minimum LoanPay uses for the big + // loan. After the amendment both clawback and LoanPay use + // the same rounded minimum (via minimumBrokerCover), so + // cover lands exactly at that threshold. + Number const expectedCoverAfter = withAmendment ? Number{1330651855688460000, -15} + : Number{1330651855688458000, -15}; + Number const clawbackAmount = + Number{c.brokerParams.coverDeposit} - expectedCoverAfter; + + env(coverClawback(c.issuer), + kLoanBrokerId(c.broker.brokerID), + kAmount(STAmount{asset, clawbackAmount})); + env.close(); + + auto const brokerSle = env.le(keylet::loanbroker(c.broker.brokerID)); + if (!BEAST_EXPECT(brokerSle) || + !BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == expectedCoverAfter)) + return std::nullopt; + + return LoanKeylets{.tiny = tinyLoanKeylet, .big = bigLoanKeylet}; + }; + + // Pay one loan and report whether the fee went to the broker's + // pseudo account (the fallback when cover < minimum) rather + // than to the owner. + auto feeGoesToPseudo = [&](Env& env, Ctx const& c, Keylet const& loanKeylet) -> bool { + Asset const asset{c.iou}; + auto const brokerSle = env.le(keylet::loanbroker(c.broker.brokerID)); + if (!BEAST_EXPECT(brokerSle)) + return false; + auto const pseudoAcct = Account("pseudo", brokerSle->at(sfAccount)); + auto const pseudoBefore = env.balance(pseudoAcct, c.iou); + + auto const payLoan = env.le(loanKeylet); + if (!BEAST_EXPECT(payLoan)) + return false; + auto const periodicPayment = payLoan->at(sfPeriodicPayment); + auto const serviceFee = payLoan->at(sfLoanServiceFee); + std::int32_t const loanScale = payLoan->at(sfLoanScale); + + auto const payment = roundPeriodicPayment(asset, periodicPayment, loanScale); + auto const payAmt = STAmount{asset, payment + serviceFee}; + + env(loan::pay(c.borrower, loanKeylet.key, payAmt), Fee(XRP(10))); + env.close(); + + auto const pseudoAfter = env.balance(pseudoAcct, c.iou); + return pseudoAfter.number() > pseudoBefore.number(); + }; + + // Pay the BIG loan in its own Env so its outcome cannot affect + // the TINY-loan check. With the fix, LoanPay and clawback use + // the same vaultScale minimum (cover == minAtVaultScale => + // fee to owner). Without the fix, LoanPay uses bigLoanScale=-11, + // rounds up to a larger minimum than what clawback used => + // cover < min => fee to pseudo. + runTest(/*vaultDeposit=*/1'000, [&](Env& env, Ctx const& c) { + auto const loans = setupLoansAndClawback(env, c); + if (!loans) + return; + BEAST_EXPECT(feeGoesToPseudo(env, c, loans->big) == !withAmendment); + }); + + // Pay the TINY loan in its own Env. Fee goes to the owner + // either way: + // - With the fix: LoanPay uses vaultScale=-11 (same as + // clawback) => owner. + // - Without the fix: LoanPay uses tinyLoanScale=-12, rounds + // up at -12 (a no-op) => min == cover => owner. + runTest(/*vaultDeposit=*/1'000, [&](Env& env, Ctx const& c) { + auto const loans = setupLoansAndClawback(env, c); + if (!loans) + return; + BEAST_EXPECT(!feeGoesToPseudo(env, c, loans->tiny)); + }); + } + + // Scenario 2 — LoanBrokerCoverWithdraw + // + // Verify that CoverWithdraw's minimum cover check uses vault scale + // (not scale(debtTotal, asset)). Before the amendment, CoverWithdraw + // used: + // roundToAsset(asset, tenthBipsOfValue(debt, rate), scale(debt, asset)) + // which could disagree with LoanPay's minimum (which used loanScale). + // + // Use a large vault deposit so that vaultScale (from AssetsTotal) is + // strictly larger than debtScale (from DebtTotal). With + // vaultDeposit = 100,000: after the big loan + // AssetsTotal ≈ 109,500 → vaultScale = -10 + // DebtTotal ≈ 10,000 → debtScale = -11 + // The one-order-of-magnitude gap makes roundToAsset at -10 truncate + // more aggressively than at -11, exposing the bug. + testcase("CoverWithdraw minimum cover scale consistency"); + runTest( + /*vaultDeposit=*/100'000, [&](Env& env, Ctx const& c) { + Asset const asset{c.iou}; + + // Create only the big loan to push DebtTotal up to ~10,000 + // while AssetsTotal stays around 109,500 (dominated by the + // large vault deposit). + env(set(c.borrower, c.broker.brokerID, Number{500}), + Sig(sfCounterpartySignature, c.lender), + kInterestRate(TenthBips32{100'000}), + kPaymentTotal(20), + kPaymentInterval(86400 * 365), + Fee(XRP(10))); + env.close(); + + // Read broker state and compute both old and new minimums. + auto const brokerSle = env.le(keylet::loanbroker(c.broker.brokerID)); + auto const vaultSle = env.le(keylet::vault(c.broker.vaultID)); + if (!BEAST_EXPECT(brokerSle) || !BEAST_EXPECT(vaultSle)) + return; + + auto const coverAvail = brokerSle->at(sfCoverAvailable); + auto const debtTotal = brokerSle->at(sfDebtTotal); + auto const vaultScale = getAssetsTotalScale(vaultSle); + auto const debtScale = scale(debtTotal, asset); + + // Sanity: debt scale differs from vault scale for this setup. + BEAST_EXPECT(debtScale < vaultScale); + + auto const oldMin = [&]() { + NumberRoundModeGuard const mg(Number::RoundingMode::Upward); + return roundToAsset( + asset, + tenthBipsOfValue(debtTotal, TenthBips32{c.brokerParams.coverRateMin}), + debtScale); + }(); + auto const newMin = minimumBrokerCover( + debtTotal, TenthBips32{c.brokerParams.coverRateMin}, vaultSle); + + // The new (vaultScale) minimum must be strictly larger than + // the old (debtScale) minimum — that is the gap the amendment + // closes. + Number const expectedNewMin{1330650518688500000, -15}; + Number const expectedOldMin{1330650518688472000, -15}; + BEAST_EXPECT(newMin == expectedNewMin); + BEAST_EXPECT(oldMin == expectedOldMin); + + // Try to withdraw so that remaining cover lands between the + // two minimums: oldMin < target < newMin. + auto const target = oldMin + (newMin - oldMin) / 2; + auto const withdrawAmount = STAmount{asset, coverAvail - target}; + + if (withAmendment) + { + // CoverWithdraw now uses vaultScale: target < newMin + // => FAILS. + env(coverWithdraw(c.lender, c.broker.brokerID, withdrawAmount), + Ter(tecINSUFFICIENT_FUNDS)); + } + else + { + // Old CoverWithdraw uses debtScale: target > oldMin + // => SUCCEEDS. + env(coverWithdraw(c.lender, c.broker.brokerID, withdrawAmount)); + } + env.close(); + }); + + // Scenario 3 — LoanSet + // + // Verify that LoanSet's minimum cover check uses vault scale (not the + // raw unrounded tenthBipsOfValue). Before the amendment, LoanSet + // used tenthBipsOfValue(newDebtTotal, coverRateMinimum) (no + // roundToAsset), while clawback/withdraw used different formulas. + // After the amendment all use minimumBrokerCover at vaultScale, and + // rounding at a coarser scale can absorb a tiny debt increase — + // allowing a loan that would otherwise be rejected. + testcase("LoanSet minimum cover scale consistency"); + runTest( + /*vaultDeposit=*/1'000, [&](Env& env, Ctx const& c) { + // Create the tiny loan (scale -12) AND the big loan (scale + // -11). Both loans are needed so that DebtTotal has a full + // 16-digit mantissa — a "messy" value where roundToAsset at + // vaultScale actually truncates digits and produces a + // different result from the raw tenthBipsOfValue. With only + // the big loan, DebtTotal has ~4 significant digits and + // rounding at scale -11 is a no-op, masking the amendment's + // effect. + env(set(c.borrower, c.broker.brokerID, Number{1, -2}), + Sig(sfCounterpartySignature, c.lender), + kInterestRate(TenthBips32{0}), + kPaymentTotal(1), + kPaymentInterval(86400 * 365), + Fee(XRP(10))); + env.close(); + + env(set(c.borrower, c.broker.brokerID, Number{500}), + Sig(sfCounterpartySignature, c.lender), + kInterestRate(TenthBips32{100'000}), + kPaymentTotal(20), + kPaymentInterval(86400 * 365), + Fee(XRP(10))); + env.close(); + + // Clawback to reduce cover to the clawback transactor's + // minimum. Pass the exact amount rather than relying on the + // transactor to clip down; the setup matches Scenario 1 so + // the same residual-cover values apply. + Number const expectedCoverAfter = withAmendment ? Number{1330651855688460000, -15} + : Number{1330651855688458000, -15}; + Number const clawbackAmount = + Number{c.brokerParams.coverDeposit} - expectedCoverAfter; + env(coverClawback(c.issuer), + kLoanBrokerId(c.broker.brokerID), + kAmount(c.iou(clawbackAmount))); + env.close(); + + // Verify scales. + auto const vaultSle = env.le(keylet::vault(c.broker.vaultID)); + if (!BEAST_EXPECT(vaultSle)) + return; + auto const vaultScale = getAssetsTotalScale(vaultSle); + BEAST_EXPECT(vaultScale == -11); + + // Now try to create a tiny additional loan. Principal is + // 1e-11 (the smallest value that survives the precision + // check at loanScale = vaultScale = -11), with 0% interest + // and 1 payment. + // + // The tiny debt increase adds ~1.337e-12 to the unrounded + // minimum. + // - Without the amendment: the old LoanSet formula rounds + // up during tenthBipsOfValue (16-digit Number + // normalisation), pushing the minimum past the cover left + // by clawback => tecINSUFFICIENT_FUNDS. + // - With the amendment: minimumBrokerCover rounds at + // vaultScale=-11, which absorbs the tiny increase — the + // rounded minimum stays the same => tesSUCCESS. + auto const tinyPrincipal = Number{1, -11}; + + if (withAmendment) + { + env(set(c.borrower, c.broker.brokerID, tinyPrincipal), + Sig(sfCounterpartySignature, c.lender), + kInterestRate(TenthBips32{0}), + kPaymentTotal(1), + kPaymentInterval(86400 * 365), + Fee(XRP(10))); + } + else + { + env(set(c.borrower, c.broker.brokerID, tinyPrincipal), + Sig(sfCounterpartySignature, c.lender), + kInterestRate(TenthBips32{0}), + kPaymentTotal(1), + kPaymentInterval(86400 * 365), + Fee(XRP(10)), + Ter(tecINSUFFICIENT_FUNDS)); + } + env.close(); + }); + } + + void + runAmendmentIndependent() + { + testDisabled(); + testInvalidLoanSet(); + testInvalidLoanDelete(); + testInvalidLoanManage(); + testInvalidLoanPay(); + testIssuerLoan(); + testServiceFeeOnBrokerDeepFreeze(); + testRequireAuth(); + testRIPD3901(); + testBorrowerIsBroker(); + testLimitExceeded(); + testLoanSetBlockedLoanPayAllowedWhenCanTransferCleared(); + testLendingCanTradeClearedNoImpact(); + testBugOverpayUnroundedAmount(); + + for (auto const flags : {0u, tfLoanOverpayment}) + testYieldTheftRounding(flags); + testBugInterestDueDeltaCrash(); + testFullLifecycleVaultPnLNearZeroRate(); + } + + // Tests run under each entry in amendmentCombinations(). + void + runAmendmentSensitive(FeatureBitset features) + { +#if LOAN_TODO + testLoanPayLateFullPaymentBypassesPenalties(features); + testLoanCoverMinimumRoundingExploit(features); +#endif + // Lifecycle + testLifecycle(features); + testLoanSet(features); + testDosLoanPay(features); + testSelfLoan(features); + + // Payment paths + testWithdrawReflectsUnrealizedLoss(features); + testPoCUnsignedUnderflowOnFullPayAfterEarlyPeriodic(features); + testBatchBypassCounterparty(features); + testLoanNextPaymentDueDateOverflow(features); + testCoverDepositWithdrawNonTransferableMPT(features); + testSequentialFLCDepletion(features); + + // Invariants + testLoanPayComputePeriodicPaymentValidRateInvariant(features); + testAccountSendMptMinAmountInvariant(features); + testLoanPayDebtDecreaseInvariant(features); + testWrongMaxDebtBehavior(features); + testLoanPayComputePeriodicPaymentValidTotalInterestInvariant(features); + testLoanPayComputePeriodicPaymentValidTotalPrincipalPaidInvariant(features); + testLoanPayComputePeriodicPaymentValidTotalInterestPaidInvariant(features); + + // RPC + testRPC(features); + + // Edge / rounding + testDustManipulation(features); + testRoundingAllowsUndercoverage(features); + testOverpaymentManagementFee(features); + testIssuerIsBorrower(features); + testIntegerScalePrincipalSticks(features); + testMinimumBrokerCoverConsistency(features); + + // RIPD regressions + testRIPD3831(features); + testRIPD3459(features); + testRIPD3902(features); + + // Broker-owner permissions + testLoanPayBrokerOwnerMissingTrustline(features); + testLoanPayBrokerOwnerUnauthorizedMPT(features); + testLoanPayBrokerOwnerNoPermissionedDomainMPT(features); + testLoanSetBrokerOwnerNoPermissionedDomainMPT(features); + } + public: void run() override { -#if LOAN_TODO - testLoanPayLateFullPaymentBypassesPenalties(); - testLoanCoverMinimumRoundingExploit(); -#endif - testWithdrawReflectsUnrealizedLoss(); - testInvalidLoanSet(); - - auto const all = jtx::testableAmendments(); - testCoverDepositWithdrawNonTransferableMPT(all); - testCoverDepositWithdrawNonTransferableMPT(all - featureMPTokensV2); - testPoCUnsignedUnderflowOnFullPayAfterEarlyPeriodic(); - - testDisabled(); - testSelfLoan(); - testIssuerLoan(); - testLoanSet(); - testLifecycle(); - testServiceFeeOnBrokerDeepFreeze(); - - testRPC(); - testInvalidLoanDelete(); - testInvalidLoanManage(); - testInvalidLoanPay(); - - testBatchBypassCounterparty(); - testLoanPayComputePeriodicPaymentValidRateInvariant(); - testAccountSendMptMinAmountInvariant(); - testLoanPayDebtDecreaseInvariant(); - testWrongMaxDebtBehavior(); - testLoanPayComputePeriodicPaymentValidTotalInterestInvariant(); - testDosLoanPay(); - testLoanPayComputePeriodicPaymentValidTotalPrincipalPaidInvariant(); - testLoanPayComputePeriodicPaymentValidTotalInterestPaidInvariant(); - testLoanNextPaymentDueDateOverflow(); - - testRequireAuth(); - testDustManipulation(); - - testRIPD3831(); - testRIPD3459(); - testRIPD3901(); - testRIPD3902(); - testRoundingAllowsUndercoverage(); - testBorrowerIsBroker(); - testIssuerIsBorrower(); - testLimitExceeded(); - testOverpaymentManagementFee(); - testLoanPayBrokerOwnerMissingTrustline(); - testLoanPayBrokerOwnerUnauthorizedMPT(); - testLoanPayBrokerOwnerNoPermissionedDomainMPT(); - testLoanSetBrokerOwnerNoPermissionedDomainMPT(); - testSequentialFLCDepletion(); + runAmendmentIndependent(); + for (auto const& features : + amendmentCombinations({fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2})) + runAmendmentSensitive(features); } }; @@ -7334,7 +8492,7 @@ protected: .payInterval = payInterval, }; - runLoan(assetType, brokerParams, loanParams); + runLoan(assetType, brokerParams, loanParams, all_); } public: @@ -7393,7 +8551,7 @@ class LoanArbitrary_test : public LoanBatch_test .payTotal = 2, .payInterval = 200}; - runLoan(AssetType::XRP, brokerParams, loanParams); + runLoan(AssetType::XRP, brokerParams, loanParams, all_); } }; diff --git a/src/test/app/MPToken_test.cpp b/src/test/app/MPToken_test.cpp index a9c36d93d2..3d6cff0885 100644 --- a/src/test/app/MPToken_test.cpp +++ b/src/test/app/MPToken_test.cpp @@ -25,14 +25,18 @@ #include #include #include +#include #include #include #include #include +#include +#include #include #include #include +#include #include #include #include @@ -47,6 +51,7 @@ #include #include #include +#include #include #include #include @@ -55,13 +60,17 @@ #include #include +#include #include #include #include +#include +#include #include #include #include #include +#include #include #include #include @@ -148,7 +157,7 @@ class MPToken_test : public beast::unit_test::Suite mptAlice.create( {.maxAmt = 100, .assetScale = 0, - .transferFee = kMAX_TRANSFER_FEE + 1, + .transferFee = kMaxTransferFee + 1, .metadata = "test", .flags = tfMPTCanTransfer, .err = temBAD_TRANSFER_FEE}); @@ -157,7 +166,7 @@ class MPToken_test : public beast::unit_test::Suite mptAlice.create( {.maxAmt = 100, .assetScale = 0, - .transferFee = kMAX_TRANSFER_FEE, + .transferFee = kMaxTransferFee, .metadata = "test", .err = temMALFORMED}); @@ -185,12 +194,28 @@ class MPToken_test : public beast::unit_test::Suite .metadata = "test", .err = temMALFORMED}); mptAlice.create( - {.maxAmt = kMAX_MP_TOKEN_AMOUNT + 1, // 9'223'372'036'854'775'808 + {.maxAmt = kMaxMpTokenAmount + 1, // 9'223'372'036'854'775'808 .assetScale = 0, .transferFee = 0, .metadata = "test", .err = temMALFORMED}); } + + // sfReferenceHolding is populated internally only by VaultCreate. + // A user-submitted MPTokenIssuanceCreate carrying the field must be + // rejected at preflight under fixCleanup3_2_0. + if (features[fixCleanup3_2_0]) + { + Env env{*this, features}; + env.fund(XRP(1'000), alice); + env.close(); + + json::Value jv; + jv[sfAccount] = alice.human(); + jv[sfTransactionType] = jss::MPTokenIssuanceCreate; + jv[sfReferenceHolding] = to_string(uint256{1}); + env(jv, Ter(temMALFORMED)); + } } void @@ -207,7 +232,7 @@ class MPToken_test : public beast::unit_test::Suite Env env{*this, features}; MPTTester mptAlice(env, alice); mptAlice.create( - {.maxAmt = kMAX_MP_TOKEN_AMOUNT, // 9'223'372'036'854'775'807 + {.maxAmt = kMaxMpTokenAmount, // 9'223'372'036'854'775'807 .assetScale = 1, .transferFee = 10, .metadata = "123", @@ -216,7 +241,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"); @@ -236,13 +262,13 @@ 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()); }(); MPTTester mptAlice(env, alice); mptAlice.create({ - .maxAmt = kMAX_MP_TOKEN_AMOUNT, // 9'223'372'036'854'775'807 + .maxAmt = kMaxMpTokenAmount, // 9'223'372'036'854'775'807 .assetScale = 1, .transferFee = 10, .metadata = "123", @@ -254,7 +280,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"); @@ -818,7 +844,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()); }(); }(); @@ -832,7 +858,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()); }(); }(); @@ -1095,7 +1121,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()); }(); }(); @@ -1137,7 +1163,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()); }(); }(); @@ -1194,7 +1220,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()); }(); }(); @@ -1206,7 +1232,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()); }(); }(); @@ -1516,7 +1542,7 @@ class MPToken_test : public beast::unit_test::Suite mptAlice.authorize({.account = bob}); // issuer sends holder the default max amount allowed - mptAlice.pay(alice, bob, kMAX_MP_TOKEN_AMOUNT); + mptAlice.pay(alice, bob, kMaxMpTokenAmount); // issuer tries to exceed max amount auto const err = mpTokensV2 ? tecPATH_DRY : tecPATH_PARTIAL; @@ -1532,7 +1558,7 @@ class MPToken_test : public beast::unit_test::Suite json::Value jv; jv[jss::secret] = alice.name(); jv[jss::tx_json] = pay(alice, bob, mpt); - jv[jss::tx_json][jss::Amount][jss::value] = std::to_string(kMAX_MP_TOKEN_AMOUNT + 1); + jv[jss::tx_json][jss::Amount][jss::value] = std::to_string(kMaxMpTokenAmount + 1); auto const jrr = env.rpc("json", "submit", to_string(jv)); BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams"); } @@ -1561,7 +1587,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] @@ -1590,7 +1617,7 @@ class MPToken_test : public beast::unit_test::Suite MPTTester mptAlice(env, alice, {.holders = {bob, carol}}); mptAlice.create( - {.maxAmt = kMAX_MP_TOKEN_AMOUNT, + {.maxAmt = kMaxMpTokenAmount, .ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer}); @@ -1600,14 +1627,14 @@ class MPToken_test : public beast::unit_test::Suite mptAlice.authorize({.account = carol}); // issuer sends holder the max amount allowed - mptAlice.pay(alice, bob, kMAX_MP_TOKEN_AMOUNT); - BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(kMAX_MP_TOKEN_AMOUNT)); + mptAlice.pay(alice, bob, kMaxMpTokenAmount); + BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(kMaxMpTokenAmount)); // payment between the holders - mptAlice.pay(bob, carol, kMAX_MP_TOKEN_AMOUNT); - BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(kMAX_MP_TOKEN_AMOUNT)); + mptAlice.pay(bob, carol, kMaxMpTokenAmount); + BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(kMaxMpTokenAmount)); // holder pays back to the issuer - mptAlice.pay(carol, alice, kMAX_MP_TOKEN_AMOUNT); + mptAlice.pay(carol, alice, kMaxMpTokenAmount); BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(0)); } @@ -1775,7 +1802,7 @@ class MPToken_test : public beast::unit_test::Suite env.close(); // Bob authorize credentials - env(deposit::authCredentials(bob, {{dpIssuer, credType}})); + env(deposit::authCredentials(bob, {{.issuer = dpIssuer, .credType = credType}})); env.close(); // alice try to send 100 MPT to bob, not authorized @@ -1911,7 +1938,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()); @@ -1922,7 +1949,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. @@ -1969,7 +1996,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 @@ -1978,7 +2005,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 @@ -1987,7 +2014,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 @@ -1996,7 +2023,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 @@ -2004,7 +2031,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 @@ -2013,7 +2040,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 @@ -2022,7 +2049,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); @@ -2054,7 +2081,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); } } @@ -2063,7 +2090,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); } } @@ -2076,9 +2103,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}; @@ -2095,6 +2122,864 @@ class MPToken_test : public beast::unit_test::Suite BEAST_EXPECT(txWithAmounts.empty()); } + void + testNonCanonicalMPTAmountCleanup(FeatureBitset features) + { + using namespace test::jtx; + using namespace std::literals; + FeatureBitset const withoutFix = features - fixCleanup3_2_0; + FeatureBitset const withFix = features | fixCleanup3_2_0; + FeatureBitset const withoutFixAndV2 = withoutFix - featureMPTokensV2; + FeatureBitset const withFixAndWithoutV2 = withFix - featureMPTokensV2; + + Account const alice{"alice"}; + Account const bob{"bob"}; + Account const gw{"gw"}; + + using MPTValue = MPTAmount::value_type; + MPTValue const mptMin = std::numeric_limits::min(); + MPTValue const mptMax = std::numeric_limits::max(); + std::uint64_t const u64Max = std::numeric_limits::max(); + std::uint64_t const firstInvalidMPTMantissa = static_cast(mptMax) + 1; + MPTValue const alice0 = 10'000; + MPTValue const gw0 = -20'000; + TER const success = tesSUCCESS; + TER const invariantFailed = tecINVARIANT_FAILED; + TER const pathPartial = tecPATH_PARTIAL; + TER const badAmountTer = temBAD_AMOUNT; + + struct BadMPTAmount + { + std::string_view name; + std::uint64_t mantissa; + bool negative; + MPTValue mptValue; + TER issuerToHolderPreFixTer; + TER holderSourcePreFixTer; + MPTValue issuerToHolderAliceAfterPreFix; + MPTValue issuerToHolderIssuerAfterPreFix; + MPTValue issuerToHolderAliceAfterPostFix; + MPTValue issuerToHolderIssuerAfterPostFix; + }; + // clang-format off + std::array const badMPTAmounts = {{ + { .name="INT64_MAX + 1", .mantissa=firstInvalidMPTMantissa, .negative=false, .mptValue=mptMin, .issuerToHolderPreFixTer=invariantFailed, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0, .issuerToHolderIssuerAfterPreFix=gw0, .issuerToHolderAliceAfterPostFix=alice0 - 1, .issuerToHolderIssuerAfterPostFix=gw0 + 1}, + { .name="INT64_MAX + 10", .mantissa=firstInvalidMPTMantissa + 9, .negative=false, .mptValue=mptMin + 9, .issuerToHolderPreFixTer=invariantFailed, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0, .issuerToHolderIssuerAfterPreFix=gw0, .issuerToHolderAliceAfterPostFix=alice0 - 1, .issuerToHolderIssuerAfterPostFix=gw0 + 1}, + { .name="UINT64_MAX - 9998", .mantissa=u64Max - 9'998, .negative=false, .mptValue=MPTValue{-9'999}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 9'999, .issuerToHolderIssuerAfterPreFix=gw0 + 9'999, .issuerToHolderAliceAfterPostFix=alice0 - 10'000, .issuerToHolderIssuerAfterPostFix=gw0 + 10'000}, + { .name="UINT64_MAX - 9", .mantissa=u64Max - 9, .negative=false, .mptValue=MPTValue{-10}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 10, .issuerToHolderIssuerAfterPreFix=gw0 + 10, .issuerToHolderAliceAfterPostFix=alice0 - 11, .issuerToHolderIssuerAfterPostFix=gw0 + 11}, + { .name="UINT64_MAX - 1", .mantissa=u64Max - 1, .negative=false, .mptValue=MPTValue{-2}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 2, .issuerToHolderIssuerAfterPreFix=gw0 + 2, .issuerToHolderAliceAfterPostFix=alice0 - 3, .issuerToHolderIssuerAfterPostFix=gw0 + 3}, + { .name="UINT64_MAX", .mantissa=u64Max, .negative=false, .mptValue=MPTValue{-1}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 1, .issuerToHolderIssuerAfterPreFix=gw0 + 1, .issuerToHolderAliceAfterPostFix=alice0 - 2, .issuerToHolderIssuerAfterPostFix=gw0 + 2}, + { .name="-2", .mantissa=std::uint64_t{2}, .negative=true, .mptValue=MPTValue{-2}, .issuerToHolderPreFixTer=badAmountTer, .holderSourcePreFixTer=badAmountTer, .issuerToHolderAliceAfterPreFix=alice0, .issuerToHolderIssuerAfterPreFix=gw0, .issuerToHolderAliceAfterPostFix=alice0 - 1, .issuerToHolderIssuerAfterPostFix=gw0 + 1} + }}; + // clang-format on + auto const badMPTAmount = [&](MPTIssue const& issue, BadMPTAmount const& bad) { + return STAmount{issue, bad.mantissa, 0, bad.negative, STAmount::Unchecked{}}; + }; + auto const makeIssue = [&](Env& env) { + MPTTester const mpt{ + {.env = env, + .issuer = gw, + .holders = {alice, bob}, + .pay = 10'000, + .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanEscrow | tfMPTCanClawback}}; + return MPTIssue{mpt.issuanceID()}; + }; + auto const withNonCanonicalMPTAmount = + [](JTx jt, SField const& field, STAmount const& amount, Account const& signer) { + STTx tx{*jt.stx}; + tx.setFieldAmount(field, amount); + tx.sign(signer.pk(), signer.sk()); + jt.stx = std::make_shared(tx); + return jt; + }; + auto const roundTrip = [](STTx const& tx) { + Serializer s; + tx.add(s); + SerialIter sit{s.slice()}; + return STTx{sit}; + }; + auto const expectRoundTripBadMPT = + [&](JTx const& jt, SField const& field, BadMPTAmount const& bad) { + auto const roundTripped = roundTrip(*jt.stx); + auto const persisted = roundTripped.getFieldAmount(field); + BEAST_EXPECT(persisted.holds()); + BEAST_EXPECT(persisted.mantissa() == bad.mantissa); + BEAST_EXPECT(persisted.exponent() == 0); + BEAST_EXPECT(persisted.negative() == bad.negative); + BEAST_EXPECT(persisted.mpt().value() == bad.mptValue); + if (!bad.negative) + BEAST_EXPECT(persisted.mantissa() > kMaxMpTokenAmount); + }; + + for (auto const& bad : badMPTAmounts) + { + testcase("fixCleanup3_2_0 rejects non-canonical MPT Payment amounts"); + { + Env env{*this, withoutFixAndV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto malformedHolderToHolder = withNonCanonicalMPTAmount( + env.jt(pay(alice, bob, STAmount{issue, std::uint64_t{1}})), + sfAmount, + badAmount, + alice); + expectRoundTripBadMPT(malformedHolderToHolder, sfAmount, bad); + malformedHolderToHolder.ter = bad.holderSourcePreFixTer; + env.submit(malformedHolderToHolder); + env.close(); + BEAST_EXPECT( + (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue})); + + env.enableFeature(fixCleanup3_2_0); + env.close(); + env(env.jt(pay(bob, alice, STAmount{issue, std::uint64_t{1}})), Ter{tesSUCCESS}); + env.close(); + BEAST_EXPECT( + (env.balance(alice, issue).value() == STAmount{MPTAmount{10'001}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{9'999}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue})); + } + { + Env env{*this, envconfig(), withoutFixAndV2, nullptr, beast::Severity::Disabled}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto malformedIssuerToHolder = withNonCanonicalMPTAmount( + env.jt(pay(gw, alice, STAmount{issue, std::uint64_t{1}})), + sfAmount, + badAmount, + gw); + expectRoundTripBadMPT(malformedIssuerToHolder, sfAmount, bad); + malformedIssuerToHolder.ter = bad.issuerToHolderPreFixTer; + env.submit(malformedIssuerToHolder); + env.close(); + BEAST_EXPECT( + (env.balance(alice, issue).value() == + STAmount{MPTAmount{bad.issuerToHolderAliceAfterPreFix}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == + STAmount{MPTAmount{bad.issuerToHolderIssuerAfterPreFix}, issue})); + + env.enableFeature(fixCleanup3_2_0); + env.close(); + env(env.jt(pay(alice, gw, STAmount{issue, std::uint64_t{1}})), Ter{tesSUCCESS}); + env.close(); + BEAST_EXPECT( + (env.balance(alice, issue).value() == + STAmount{MPTAmount{bad.issuerToHolderAliceAfterPostFix}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == + STAmount{MPTAmount{bad.issuerToHolderIssuerAfterPostFix}, issue})); + } + { + Env env{*this, withoutFixAndV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto malformedHolderToIssuer = withNonCanonicalMPTAmount( + env.jt(pay(alice, gw, STAmount{issue, std::uint64_t{1}})), + sfAmount, + badAmount, + alice); + expectRoundTripBadMPT(malformedHolderToIssuer, sfAmount, bad); + malformedHolderToIssuer.ter = bad.holderSourcePreFixTer; + env.submit(malformedHolderToIssuer); + env.close(); + BEAST_EXPECT( + (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue})); + + env.enableFeature(fixCleanup3_2_0); + env.close(); + env(env.jt(pay(gw, alice, STAmount{issue, std::uint64_t{1}})), Ter{tesSUCCESS}); + env.close(); + BEAST_EXPECT( + (env.balance(alice, issue).value() == STAmount{MPTAmount{10'001}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'001}, issue})); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(pay(alice, bob, STAmount{issue, std::uint64_t{1}})), + sfAmount, + badAmount, + alice); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(pay(gw, alice, STAmount{issue, std::uint64_t{1}})), + sfAmount, + badAmount, + gw); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(pay(alice, gw, STAmount{issue, std::uint64_t{1}})), + sfAmount, + badAmount, + alice); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + + testcase("fixCleanup3_2_0 rejects non-canonical MPT Check amounts"); + { + Env env{*this, envconfig(), withoutFix, nullptr, beast::Severity::Disabled}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badSendMax = badMPTAmount(issue, bad); + auto const checkSeq = env.seq(alice); + auto tx = withNonCanonicalMPTAmount( + env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})), + sfSendMax, + badSendMax, + alice); + tx.ter = bad.negative ? TER{temBAD_AMOUNT} : TER{tesSUCCESS}; + env.submit(tx); + env.close(); + + auto const checkKeylet = keylet::check(alice.id(), checkSeq); + auto const sleCheck = env.le(checkKeylet); + BEAST_EXPECT((sleCheck != nullptr) == !bad.negative); + if (sleCheck && !bad.negative) + { + auto const persisted = sleCheck->getFieldAmount(sfSendMax); + BEAST_EXPECT(persisted.holds()); + BEAST_EXPECT(persisted.mantissa() == bad.mantissa); + BEAST_EXPECT(persisted.negative() == bad.negative); + } + } + { + Env env{*this, envconfig(), withoutFix, nullptr, beast::Severity::Disabled}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badSendMax = badMPTAmount(issue, bad); + auto const checkSeq = env.seq(alice); + auto tx = withNonCanonicalMPTAmount( + env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})), + sfSendMax, + badSendMax, + alice); + tx.ter = bad.negative ? TER{temBAD_AMOUNT} : TER{tesSUCCESS}; + env.submit(tx); + env.close(); + + auto const checkKeylet = keylet::check(alice.id(), checkSeq); + BEAST_EXPECT((env.le(checkKeylet) != nullptr) == !bad.negative); + if (!bad.negative) + { + // CheckCancel has no amount fields, but it must be able to + // remove a malformed legacy Check while the fix is disabled. + env(env.jt(check::cancel(alice, checkKeylet.key)), Ter{tesSUCCESS}); + env.close(); + BEAST_EXPECT(env.le(checkKeylet) == nullptr); + } + } + { + Env env{*this, envconfig(), withoutFix, nullptr, beast::Severity::Disabled}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badSendMax = badMPTAmount(issue, bad); + auto const checkSeq = env.seq(alice); + auto tx = withNonCanonicalMPTAmount( + env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})), + sfSendMax, + badSendMax, + alice); + tx.ter = bad.negative ? TER{temBAD_AMOUNT} : TER{tesSUCCESS}; + env.submit(tx); + env.close(); + + auto const checkKeylet = keylet::check(alice.id(), checkSeq); + BEAST_EXPECT((env.le(checkKeylet) != nullptr) == !bad.negative); + if (!bad.negative) + { + env.enableFeature(fixCleanup3_2_0); + env.close(); + + // Once the fix is enabled, CheckCancel should still remove + // a legacy Check because it does not consume the bad amount. + env(env.jt(check::cancel(alice, checkKeylet.key)), Ter{tesSUCCESS}); + env.close(); + BEAST_EXPECT(env.le(checkKeylet) == nullptr); + } + } + { + Env env{*this, envconfig(), withoutFix, nullptr, beast::Severity::Disabled}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badSendMax = badMPTAmount(issue, bad); + auto const checkSeq = env.seq(alice); + auto tx = withNonCanonicalMPTAmount( + env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})), + sfSendMax, + badSendMax, + alice); + tx.ter = bad.negative ? TER{temBAD_AMOUNT} : TER{tesSUCCESS}; + env.submit(tx); + env.close(); + + auto const checkKeylet = keylet::check(alice.id(), checkSeq); + BEAST_EXPECT((env.le(checkKeylet) != nullptr) == !bad.negative); + if (!bad.negative) + { + env.enableFeature(fixCleanup3_2_0); + env.close(); + + auto const cashAmount = STAmount{sfAmount, issue, std::uint64_t{1}, 0, false}; + env(env.jt(check::cash(bob, checkKeylet.key, cashAmount)), Ter{tefBAD_LEDGER}); + env.close(); + BEAST_EXPECT(env.le(checkKeylet) != nullptr); + } + } + { + Env env{*this, withoutFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const sendMax = STAmount{sfSendMax, issue, std::uint64_t{10}, 0, false}; + auto const checkSeq = env.seq(alice); + env(env.jt(check::create(alice, bob, sendMax)), Ter{tesSUCCESS}); + env.close(); + + auto const badCashAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + check::cash( + bob, + keylet::check(alice.id(), checkSeq).key, + STAmount{issue, std::uint64_t{1}})), + sfAmount, + badCashAmount, + bob); + expectRoundTripBadMPT(tx, sfAmount, bad); + tx.ter = bad.holderSourcePreFixTer; + env.submit(tx); + env.close(); + BEAST_EXPECT(env.le(keylet::check(alice.id(), checkSeq)) != nullptr); + BEAST_EXPECT( + (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue})); + } + { + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const sendMax = STAmount{sfSendMax, issue, std::uint64_t{10}, 0, false}; + auto const checkSeq = env.seq(alice); + env(env.jt(check::create(alice, bob, sendMax)), Ter{tesSUCCESS}); + env.close(); + + auto const badCashAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + check::cash( + bob, + keylet::check(alice.id(), checkSeq).key, + STAmount{issue, std::uint64_t{1}})), + sfAmount, + badCashAmount, + bob); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + + testcase("fixCleanup3_2_0 rejects non-canonical MPT Escrow amounts"); + { + Env env{*this, withoutFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const escrowSeq = env.seq(alice); + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + escrow::create(alice, bob, STAmount{issue, std::uint64_t{1}}), + escrow::kFinishTime(env.now() + 1s)), + sfAmount, + badAmount, + alice); + tx.ter = bad.negative ? TER{temBAD_AMOUNT} : TER{tecINSUFFICIENT_FUNDS}; + env.submit(tx); + env.close(); + BEAST_EXPECT(env.le(keylet::escrow(alice.id(), escrowSeq)) == nullptr); + } + { + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + escrow::create(alice, bob, STAmount{issue, std::uint64_t{1}}), + escrow::kFinishTime(env.now() + 1s)), + sfAmount, + badAmount, + alice); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + + testcase("fixCleanup3_2_0 rejects non-canonical MPT Clawback amounts"); + { + Env env{*this, withoutFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(claw(gw, STAmount{issue, std::uint64_t{1}}, bob)), + sfAmount, + badAmount, + gw); + expectRoundTripBadMPT(tx, sfAmount, bad); + tx.ter = bad.negative ? TER{temBAD_AMOUNT} : TER{tesSUCCESS}; + env.submit(tx); + env.close(); + + MPTValue const bobAfter = bad.negative ? MPTValue{10'000} : MPTValue{0}; + MPTValue const gwAfter = bad.negative ? MPTValue{-20'000} : MPTValue{-10'000}; + BEAST_EXPECT( + (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{bobAfter}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == STAmount{MPTAmount{gwAfter}, issue})); + } + { + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(claw(gw, STAmount{issue, std::uint64_t{1}}, bob)), + sfAmount, + badAmount, + gw); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + env.close(); + + BEAST_EXPECT( + (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue})); + BEAST_EXPECT( + (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue})); + } + + testcase("featureMPTokensV2 disabled rejects MPT OfferCreate amounts"); + { + Env env{*this, withoutFixAndV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badTakerPays = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(offer(alice, STAmount{issue, std::uint64_t{1}}, XRP(10))), + sfTakerPays, + badTakerPays, + alice); + expectRoundTripBadMPT(tx, sfTakerPays, bad); + tx.ter = temDISABLED; + env.submit(tx); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badTakerPays = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(offer(alice, STAmount{issue, std::uint64_t{1}}, XRP(10))), + sfTakerPays, + badTakerPays, + alice); + tx.ter = temDISABLED; + env.submit(tx); + } + { + // sfTakerPays is MPT: both amendments active. Negative offers + // fail in OfferCreate::preflight() before the universal check; + // positive non-canonical amounts fail in the universal check. + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badTakerPays = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(offer(alice, STAmount{issue, std::uint64_t{1}}, XRP(10))), + sfTakerPays, + badTakerPays, + alice); + tx.ter = TER{temBAD_AMOUNT}; + env.submit(tx); + } + { + // sfTakerGets is MPT: both amendments active. Negative offers + // fail in OfferCreate::preflight() before the universal check; + // positive non-canonical amounts fail in the universal check. + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badTakerGets = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt(offer(alice, XRP(10), STAmount{issue, std::uint64_t{1}})), + sfTakerGets, + badTakerGets, + alice); + tx.ter = TER{temBAD_AMOUNT}; + env.submit(tx); + } + + testcase("featureMPTokensV2 disabled rejects MPT AMMCreate amounts"); + { + Env env{*this, withoutFixAndV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::createJv(alice.id(), STAmount{issue, std::uint64_t{1}}, XRP(1), 0), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + expectRoundTripBadMPT(tx, sfAmount, bad); + tx.ter = temDISABLED; + env.submit(tx); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::createJv(alice.id(), STAmount{issue, std::uint64_t{1}}, XRP(1), 0), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + tx.ter = temDISABLED; + env.submit(tx); + } + { + // sfAmount is MPT: both amendments active, expect temBAD_AMOUNT + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::createJv(alice.id(), STAmount{issue, std::uint64_t{1}}, XRP(1), 0), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + + testcase("featureMPTokensV2 disabled rejects MPT AMMDeposit amounts"); + { + Env env{*this, withoutFixAndV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::depositJv( + {.account = alice, + .asset1In = STAmount{issue, std::uint64_t{1}}, + .assets = std::make_pair(Asset{issue}, Asset{xrpIssue()})}), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + expectRoundTripBadMPT(tx, sfAmount, bad); + tx.ter = temDISABLED; + env.submit(tx); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::depositJv( + {.account = alice, + .asset1In = STAmount{issue, std::uint64_t{1}}, + .assets = std::make_pair(Asset{issue}, Asset{xrpIssue()})}), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + tx.ter = temDISABLED; + env.submit(tx); + } + { + // sfAmount is MPT: both amendments active, expect temBAD_AMOUNT + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::depositJv( + {.account = alice, + .asset1In = STAmount{issue, std::uint64_t{1}}, + .assets = std::make_pair(Asset{issue}, Asset{xrpIssue()})}), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + + testcase("featureMPTokensV2 disabled rejects MPT AMMWithdraw amounts"); + { + Env env{*this, withoutFixAndV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::withdrawJv( + {.account = alice, + .asset1Out = STAmount{issue, std::uint64_t{1}}, + .assets = std::make_pair(Asset{issue}, Asset{xrpIssue()})}), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + expectRoundTripBadMPT(tx, sfAmount, bad); + tx.ter = temDISABLED; + env.submit(tx); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::withdrawJv( + {.account = alice, + .asset1Out = STAmount{issue, std::uint64_t{1}}, + .assets = std::make_pair(Asset{issue}, Asset{xrpIssue()})}), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + tx.ter = temDISABLED; + env.submit(tx); + } + { + // sfAmount is MPT: both amendments active, expect temBAD_AMOUNT + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + AMM::withdrawJv( + {.account = alice, + .asset1Out = STAmount{issue, std::uint64_t{1}}, + .assets = std::make_pair(Asset{issue}, Asset{xrpIssue()})}), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + alice); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + + testcase("featureMPTokensV2 disabled rejects MPT AMMClawback amounts"); + { + Env env{*this, withoutFixAndV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + amm::ammClawback( + gw, + alice, + Asset{issue}, + Asset{xrpIssue()}, + std::make_optional(STAmount{issue, std::uint64_t{1}})), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + gw); + expectRoundTripBadMPT(tx, sfAmount, bad); + tx.ter = temDISABLED; + env.submit(tx); + } + { + Env env{*this, withFixAndWithoutV2}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + amm::ammClawback( + gw, + alice, + Asset{issue}, + Asset{xrpIssue()}, + std::make_optional(STAmount{issue, std::uint64_t{1}})), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + gw); + tx.ter = temDISABLED; + env.submit(tx); + } + { + // sfAmount is MPT: both amendments active, expect temBAD_AMOUNT + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + auto tx = withNonCanonicalMPTAmount( + env.jt( + amm::ammClawback( + gw, + alice, + Asset{issue}, + Asset{xrpIssue()}, + std::make_optional(STAmount{issue, std::uint64_t{1}})), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + gw); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + + testcase("fixCleanup3_2_0 rejects non-canonical MPT VaultClawback amounts"); + { + Env env{*this, withFix}; + env.fund(XRP(100'000), alice, bob, gw); + env.close(); + auto const issue = makeIssue(env); + + auto const badAmount = badMPTAmount(issue, bad); + uint256 const fakeVaultId = keylet::vault(gw.id(), 1).key; + auto tx = withNonCanonicalMPTAmount( + env.jt( + Vault::clawback( + {.issuer = gw, + .id = fakeVaultId, + .holder = alice, + .amount = STAmount{issue, std::uint64_t{1}}}), + Fee(static_cast(env.current()->fees().increment.drops()))), + sfAmount, + badAmount, + gw); + tx.ter = temBAD_AMOUNT; + env.submit(tx); + } + } + } + void testTxJsonMetaFields(FeatureBitset features) { @@ -2106,13 +2991,14 @@ class MPToken_test : public beast::unit_test::Suite Account const alice{"alice"}; auto cfg = envconfig(); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env{*this, std::move(cfg), features}; MPTTester mptAlice(env, alice); 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" @@ -2263,7 +3149,7 @@ class MPToken_test : public beast::unit_test::Suite auto const mpt = xrpl::test::jtx::MPT(alice.name(), makeMptID(env.seq(alice), alice)); json::Value jv = claw(alice, mpt(1), bob); - jv[jss::Amount][jss::value] = std::to_string(kMAX_MP_TOKEN_AMOUNT + 1); + jv[jss::Amount][jss::value] = std::to_string(kMaxMpTokenAmount + 1); json::Value jv1; jv1[jss::secret] = alice.name(); jv1[jss::tx_json] = jv; @@ -2709,7 +3595,7 @@ class MPToken_test : public beast::unit_test::Suite mptAlice.create({.ownerCount = 1, .mutableFlags = tmfMPTCanMutateMetadata}); - std::string const metadata(kMAX_MP_TOKEN_METADATA_LENGTH + 1, 'a'); + std::string const metadata(kMaxMpTokenMetadataLength + 1, 'a'); mptAlice.set({.account = alice, .metadata = metadata, .err = temMALFORMED}); } @@ -2733,7 +3619,7 @@ class MPToken_test : public beast::unit_test::Suite mptAlice.set( {.account = alice, .id = mptID, - .transferFee = kMAX_TRANSFER_FEE + 1, + .transferFee = kMaxTransferFee + 1, .err = temBAD_TRANSFER_FEE}); } @@ -2887,8 +3773,8 @@ class MPToken_test : public beast::unit_test::Suite .flags = tfMPTCanTransfer, .mutableFlags = tmfMPTCanMutateTransferFee}); - for (std::uint16_t const fee : std::initializer_list{ - 1, 10, 100, 200, 500, 1000, kMAX_TRANSFER_FEE}) + for (std::uint16_t const fee : + std::initializer_list{1, 10, 100, 200, 500, 1000, kMaxTransferFee}) { mptAlice.set({.account = alice, .transferFee = fee}); BEAST_EXPECT(mptAlice.checkTransferFee(fee)); @@ -3148,23 +4034,23 @@ class MPToken_test : public beast::unit_test::Suite // MPTCanEscrow is not enabled env(escrow::create(carol, bob, mpt(3)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); // MPTCanEscrow is enabled now mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanEscrow}); env(escrow::create(carol, bob, mpt(3)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150)); // Clear MPTCanEscrow mptAlice.set({.account = alice, .mutableFlags = tmfMPTClearCanEscrow}); env(escrow::create(carol, bob, mpt(3)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tecNO_PERMISSION)); } @@ -3307,7 +4193,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"); @@ -3318,11 +4204,11 @@ class MPToken_test : public beast::unit_test::Suite Account const alice("alice"); Account const bob("bob"); - std::uint64_t constexpr kMAX_AMT = 150; + static constexpr std::uint64_t kMaxAmt = 150; Env env{*this, features}; MPTTester mptTester(env, issuer, {.holders = {alice, bob}}); - mptTester.create({.maxAmt = kMAX_AMT, .ownerCount = 1, .flags = tfMPTCanTransfer}); + mptTester.create({.maxAmt = kMaxAmt, .ownerCount = 1, .flags = tfMPTCanTransfer}); mptTester.authorize({.account = alice}); mptTester.authorize({.account = bob}); @@ -3359,14 +4245,14 @@ class MPToken_test : public beast::unit_test::Suite std::nullopt, "aggregate exceeds max"); - runTest(R{{alice.id(), 75}, {bob.id(), 75}}, tesSUCCESS, kMAX_AMT, "aggregate at boundary"); + runTest(R{{alice.id(), 75}, {bob.id(), 75}}, tesSUCCESS, kMaxAmt, "aggregate at boundary"); runTest(R{{alice.id(), 50}, {bob.id(), 50}}, tesSUCCESS, 100, "aggregate within limit"); runTest( R{{alice.id(), 150}, {bob.id(), 0}}, tesSUCCESS, - kMAX_AMT, + kMaxAmt, "one receiver at max, other zero"); runTest( @@ -3384,7 +4270,7 @@ class MPToken_test : public beast::unit_test::Suite runTest( R{{alice.id(), 50}, {bob.id(), 50}}, tesSUCCESS, - kMAX_AMT, + kMaxAmt, "nonzero outstanding, aggregate at boundary"); runTest( @@ -3396,7 +4282,7 @@ class MPToken_test : public beast::unit_test::Suite runTest( R{{alice.id(), 100}, {bob.id(), 0}}, tesSUCCESS, - kMAX_AMT, + kMaxAmt, "nonzero outstanding, single send at remaining capacity"); runTest( @@ -3409,14 +4295,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); } } @@ -3478,10 +4364,10 @@ class MPToken_test : public beast::unit_test::Suite auto const [errBuy, errSell] = [&]() -> std::pair { // Global lock if (lockMPTIssue) - return std::make_pair(tecFROZEN, tecFROZEN); + return std::make_pair(tecLOCKED, tecLOCKED); // Local lock if (lockMPToken) - return std::make_pair(tesSUCCESS, error(tecUNFUNDED_OFFER)); + return std::make_pair(error(tecLOCKED), error(tecUNFUNDED_OFFER)); // MPToken doesn't exist if (requireAuth) return std::make_pair(error(tecNO_AUTH), error(tecUNFUNDED_OFFER)); @@ -3544,51 +4430,77 @@ class MPToken_test : public beast::unit_test::Suite env(offer(alice, btc(10), eth(10)), Ter(tecUNFUNDED_OFFER)); } - // MPTLock flag is set and the account is not the issuer of MPT + // MPTLock flag is set: MPT/MPT offer crossing with independent issuers. + // gw2 issues BTC and gw issues ETH so each asset can be frozen independently. + // Passive setup: bob sells BTC (offer(bob, ETH, BTC)); dan sells ETH (offer(dan, BTC, + // ETH)). { + Account const gw2 = Account("gw2"); Account const bob = Account("bob"); Account const dan = Account("dan"); Env env(*this); - env.fund(XRP(1'000), gw, alice, carol, bob, dan); + env.fund(XRP(1'000), gw, gw2, alice, carol, bob, dan); MPTTester btc( {.env = env, - .issuer = gw, - .holders = {alice, carol, bob, dan}, + .issuer = gw2, + .holders = {alice, carol, bob, dan, gw}, .pay = 100, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); MPTTester eth( {.env = env, .issuer = gw, - .holders = {alice, carol, bob, dan}, + .holders = {alice, carol, bob, dan, gw2}, .pay = 100, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); + // bob sells BTC (takerGets=BTC); dan sells ETH (takerGets=ETH) env(offer(bob, eth(10), btc(10)), Txflags(tfPassive)); env(offer(dan, btc(10), eth(10)), Txflags(tfPassive)); + env.close(); - auto test = [&](auto const& flag, bool gwOwner = false) { - btc.set({.holder = carol, .flags = flag}); - btc.set({.holder = alice, .flags = flag}); + // --- Individual lock on BTC --- + // alice sells locked BTC (takerGets): balance zeroed, offer unfunded + btc.set({.holder = alice, .flags = tfMPTLock}); + env(offer(alice, eth(1), btc(1)), Ter(tecUNFUNDED_OFFER)); + btc.set({.holder = alice, .flags = tfMPTUnlock}); + // carol buys locked BTC (takerPays): locked MPToken cannot receive + btc.set({.holder = carol, .flags = tfMPTLock}); + env(offer(carol, btc(1), eth(1)), Ter(tecLOCKED)); + btc.set({.holder = carol, .flags = tfMPTUnlock}); + // gw2 is BTC issuer: individual lock on holders does not affect issuer + env(offer(gw2, eth(1), btc(1))); - if (gwOwner) - { - // Succeeds if the account is the issuer - env(offer(gw, eth(1), btc(1))); - env(offer(gw, btc(1), eth(1))); - } - else - { - auto const err = flag == tfMPTLock ? Ter(tecUNFUNDED_OFFER) : Ter(tesSUCCESS); - env(offer(alice, eth(1), btc(1)), err); - // Offer created by not crossed - env(offer(carol, btc(1), eth(1))); - BEAST_EXPECT(expectOffers(env, carol, 1, {{btc(1), eth(1)}})); - } - }; + // --- Individual lock on ETH --- + // alice sells locked ETH (takerGets): balance zeroed, offer unfunded + eth.set({.holder = alice, .flags = tfMPTLock}); + env(offer(alice, btc(1), eth(1)), Ter(tecUNFUNDED_OFFER)); + eth.set({.holder = alice, .flags = tfMPTUnlock}); + // carol buys locked ETH (takerPays): locked MPToken cannot receive + eth.set({.holder = carol, .flags = tfMPTLock}); + env(offer(carol, eth(1), btc(1)), Ter(tecLOCKED)); + eth.set({.holder = carol, .flags = tfMPTUnlock}); + // gw is ETH issuer: individual lock on holders does not affect issuer + env(offer(gw, btc(1), eth(1))); - test(tfMPTLock); - test(tfMPTLock, true); - test(tfMPTUnlock); + // --- Global lock on BTC --- + // All accounts fail regardless of role: global lock is checked in OfferCreate + // before offer crossing, so it applies even to the issuer. + btc.set({.flags = tfMPTLock}); + env(offer(alice, eth(1), btc(1)), Ter(tecLOCKED)); // alice sells BTC + env(offer(alice, btc(1), eth(1)), Ter(tecLOCKED)); // alice buys BTC + env(offer(gw2, eth(1), btc(1)), Ter(tecLOCKED)); // gw2 is BTC issuer, still fails + btc.set({.flags = tfMPTUnlock}); + + // --- Global lock on ETH --- + eth.set({.flags = tfMPTLock}); + env(offer(alice, btc(1), eth(1)), Ter(tecLOCKED)); // alice sells ETH + env(offer(alice, eth(1), btc(1)), Ter(tecLOCKED)); // alice buys ETH + env(offer(gw, btc(1), eth(1)), Ter(tecLOCKED)); // gw is ETH issuer, still fails + eth.set({.flags = tfMPTUnlock}); + + // --- After all locks cleared: normal crossing succeeds --- + env(offer(alice, eth(1), btc(1))); + env(offer(carol, btc(1), eth(1))); } // MPTRequireAuth flag is set and the account is not authorized @@ -3600,14 +4512,14 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 100, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | kMptDexFlags, .authHolder = true}); MPTTester const eth( {.env = env, .issuer = gw, .holders = {alice}, .pay = 100, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | kMptDexFlags, .authHolder = true}); btc.authorize({.account = gw, .holder = alice, .flags = tfMPTUnauthorize}); @@ -3803,6 +4715,7 @@ class MPToken_test : public beast::unit_test::Suite testcase("Cross Asset Payment"); using namespace test::jtx; Account const gw = Account("gw"); + Account const gw2 = Account("gw2"); Account const alice = Account("alice"); Account const carol = Account("carol"); Account const bob = Account("bob"); @@ -3914,7 +4827,7 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS, + .flags = tfMPTCanLock | kMptDexFlags, .mutableFlags = tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanTrade | tmfMPTCanMutateCanTransfer}); MPTTester eth( @@ -3922,21 +4835,21 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS, + .flags = tfMPTCanLock | kMptDexFlags, .mutableFlags = tmfMPTCanMutateCanTransfer}); MPTTester const usd( {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = kMPT_DEX_FLAGS | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTCanLock, .mutableFlags = tmfMPTCanMutateCanTransfer}); MPTTester const cad( {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = kMPT_DEX_FLAGS | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTCanLock, .mutableFlags = tmfMPTCanMutateCanTransfer}); env(offer(bob, eth(1'000), btc(1'000)), Txflags(tfPassive)); @@ -3979,6 +4892,7 @@ class MPToken_test : public beast::unit_test::Suite env(pay(ed, gw, btc(10)), Path(~btc), Sendmax(eth(10))); // BTC is transferred from issuer to bob env(pay(gw, ed, eth(10)), Path(~eth), Sendmax(btc(10))); + // // BTC is transferred from ed to bob, ed is not authorized env(pay(ed, gw, eth(10)), Path(~eth), Sendmax(btc(10)), Ter(tecNO_AUTH)); env.close(); @@ -3993,13 +4907,11 @@ class MPToken_test : public beast::unit_test::Suite env(pay(carol, ed, btc(10)), Path(~btc), Sendmax(eth(10)), Ter(tecPATH_PARTIAL)); env(pay(ed, carol, eth(10)), Path(~eth), Sendmax(btc(10)), Ter(tecPATH_PARTIAL)); env(pay(carol, ed, eth(10)), Path(~eth), Sendmax(btc(10)), Ter(tecPATH_PARTIAL)); - // Fail because BTC, which has CanTransfer disabled, is sent to - // bob + // Fail because BTC, which has CanTransfer disabled, is sent to bob env(pay(ed, gw, eth(10)), Path(~eth), Sendmax(btc(10)), Ter(tecPATH_PARTIAL)); env(pay(ed, gw, btc(10)), Path(~btc), Sendmax(eth(10)), Ter(tesSUCCESS)); env(pay(gw, ed, eth(10)), Path(~eth), Sendmax(btc(10)), Ter(tesSUCCESS)); - // Fail because BTC, which has CanTransfer disabled, is sent to - // ed + // Fail because BTC, which has CanTransfer disabled, is sent to ed env(pay(gw, ed, btc(10)), Path(~btc), Sendmax(eth(10)), Ter(tecPATH_PARTIAL)); env.close(); env(offer(gw, eth(100), btc(100)), Txflags(tfPassive)); @@ -4025,28 +4937,28 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS, + .flags = tfMPTCanLock | kMptDexFlags, .mutableFlags = tmfMPTCanMutateCanTransfer}); MPTTester eth( {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS, + .flags = tfMPTCanLock | kMptDexFlags, .mutableFlags = tmfMPTCanMutateCanTransfer}); MPTTester usd( {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = kMPT_DEX_FLAGS | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTCanLock, .mutableFlags = tmfMPTCanMutateCanTransfer}); MPTTester cad( {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 1'000, - .flags = kMPT_DEX_FLAGS | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTCanLock, .mutableFlags = tmfMPTCanMutateCanTransfer}); // takerGets can transfer if: // - CanTransfer is set @@ -4174,7 +5086,17 @@ class MPToken_test : public beast::unit_test::Suite env(pay(gw, carol, usd(1)), Path(~btc, ~eth, ~usd), Sendmax(XRP(1)), - Ter(tecPATH_PARTIAL)); + Txflags(tfPartialPayment | tfNoRippleDirect), + Ter(tecNO_PERMISSION)); + env.close(); + BEAST_EXPECT(expectOffers(env, bob, 3)); + + env(pay(carol, bob, btc(10)), Sendmax(XRP(10)), Ter(tecNO_PERMISSION)); + env(pay(carol, bob, XRP(10)), Sendmax(btc(10)), Ter(tecNO_PERMISSION)); + env(pay(gw, bob, btc(10)), Sendmax(XRP(10)), Ter(tecNO_PERMISSION)); + env(pay(gw, bob, XRP(10)), Sendmax(btc(10)), Ter(tecNO_PERMISSION)); + env(pay(carol, gw, btc(10)), Sendmax(XRP(10)), Ter(tecNO_PERMISSION)); + env(pay(carol, gw, XRP(10)), Sendmax(btc(10)), Ter(tecNO_PERMISSION)); env.close(); BEAST_EXPECT(expectOffers(env, bob, 3)); } @@ -4209,31 +5131,36 @@ class MPToken_test : public beast::unit_test::Suite auto getMPT = [&](Env& env) { MPTTester const btc( {.env = env, - .issuer = gw, - .holders = {alice, carol, bob}, + .issuer = gw2, + .holders = {alice, carol, bob, gw}, .pay = 100, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); MPTTester const eth( {.env = env, .issuer = gw, - .holders = {alice, carol, bob}, + .holders = {alice, carol, bob, gw2}, .pay = 100, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); return std::make_pair(btc, eth); }; auto getIOU = [&](Env& env) { - for (auto const& iou : {gw["BTC"], gw["ETH"]}) + for (auto const& a : {alice, carol, bob}) { - for (auto const& a : {alice, carol, bob}) - { - env(fset(a, asfDefaultRipple)); - env.close(); - env(trust(a, iou(200))); - env(pay(gw, a, iou(100))); - env.close(); - } + env(fset(a, asfDefaultRipple)); + env.close(); + env(trust(a, gw["ETH"](200))); + env(pay(gw, a, gw["ETH"](100))); + env(trust(a, gw2["BTC"](200))); + env(pay(gw2, a, gw2["BTC"](100))); + env.close(); } - return std::make_pair(gw["BTC"], gw["ETH"]); + // gw2 needs an ETH trust line to receive ETH when its offers fill + // gw needs BTC to sell BTC + env(trust(gw2, gw["ETH"](200))); + env(trust(gw, gw2["BTC"](200))); + env(pay(gw2, gw, gw2["BTC"](100))); + env.close(); + return std::make_pair(gw2["BTC"], gw["ETH"]); }; auto lock = [&]( Env& env, Account const& account, Token& token, LockType lock) { @@ -4243,12 +5170,12 @@ class MPToken_test : public beast::unit_test::Suite { if (lock == LockType::Global) { - env(fset(gw, asfGlobalFreeze)); + env(fset(token.account, asfGlobalFreeze)); } else { IOU const iou{account, token.currency}; - env(trust(gw, iou(0), tfSetFreeze)); + env(trust(token.account, iou(0), tfSetFreeze)); } } else if constexpr (std::is_same_v) @@ -4265,7 +5192,7 @@ class MPToken_test : public beast::unit_test::Suite }; auto test = [&](auto&& getTokens, TestArg const& arg) { Env env(*this); - env.fund(XRP(1'000), gw, alice, carol, bob); + env.fund(XRP(1'000), gw, gw2, alice, carol, bob); auto [btc, eth] = getTokens(env); @@ -4283,7 +5210,7 @@ class MPToken_test : public beast::unit_test::Suite } if (arg.globalFlagSell != LockType::None) { - lock(env, gw, btc, LockType::Global); + lock(env, gw2, btc, LockType::Global); } else { @@ -4301,34 +5228,58 @@ class MPToken_test : public beast::unit_test::Suite }; // clang-format off std::vector const tests = { - // src, dst, offer's owner are a holder - {.src = alice, .dst = carol, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY}, - // dst can receive IOU even if the account is frozen - {.src = alice, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS}, - {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY}, - {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagSell = LockType::Global, .err = tecPATH_DRY}, - // offer's owner can receive IOU even if the account is frozen - {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = - tecPATH_PARTIAL, .errIOU = tesSUCCESS}, - {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL}, - // src, dst are a holder, offer's owner is an issuer - {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = LockType::Individual, .err = tecPATH_DRY}, - // dst can receive IOU even if the account is frozen - {.src = alice, .dst = carol, .offerOwner = gw, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS}, - {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY}, - {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagSell = LockType::Global, .err = tecPATH_DRY}, - // src is issuer, dst and offer's owner are a holder - // dst can receive IOU even if the account is frozen - {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS}, - // offer's owner can receive IOU from an issuer even if takerBuys is frozen, MPT offer is unfunded in this case - {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS}, - {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL}, - // dst is issuer, src and offer's owner are a holder - {.src = alice, .dst = gw, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY}, - // offer's owner can receive IOU even if the account is frozen - {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL, - .errIOU = tesSUCCESS}, - {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL}, + // ----- src=alice (holder), dst=carol (holder), offerOwner=bob (holder) ----- + // alice's ETH locked: caught in check() + {.src = alice, .dst = carol, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY}, + // carol's BTC locked: caught in MPT check(); IOU dst can still receive when frozen + {.src = alice, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS}, + // ETH globally locked: caught in check() + {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY}, + // BTC globally locked: bob's offer unfunded in OfferStream + {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagSell = LockType::Global, .err = tecPATH_PARTIAL}, + // bob's ETH (takerPays) locked: MPT offer unfunded in OfferStream (locked holder cannot receive); IOU can still receive + {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS}, + // bob's BTC (takerGets) locked: offer unfunded in OfferStream + {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL}, + // ----- src=alice (holder), dst=carol (holder), offerOwner=gw2 (BTC issuer) ----- + // alice's ETH locked: caught in check() + {.src = alice, .dst = carol, .offerOwner = gw2, .srcFlag = LockType::Individual, .err = tecPATH_DRY}, + // carol's BTC locked: caught in MPT check(); IOU dst can still receive when frozen + {.src = alice, .dst = carol, .offerOwner = gw2, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS}, + // ETH globally locked: caught in check() + {.src = alice, .dst = carol, .offerOwner = gw2, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY}, + // BTC globally locked: gw2 is the BTC issuer, offer always permitted regardless of global freeze + {.src = alice, .dst = carol, .offerOwner = gw2, .globalFlagSell = LockType::Global, .err = tesSUCCESS}, + // ----- src=alice (holder), dst=carol (holder), offerOwner=gw (ETH issuer, BTC holder) ----- + // alice's ETH locked: caught in check() + {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = LockType::Individual, .err = tecPATH_DRY}, + // carol's BTC locked: caught in MPT check(); IOU dst can still receive when frozen + {.src = alice, .dst = carol, .offerOwner = gw, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS}, + // ETH globally locked: caught in check() + {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY}, + // BTC globally locked: gw holds BTC as a holder (not BTC issuer), offer unfunded in OfferStream + {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagSell = LockType::Global, .err = tecPATH_PARTIAL}, + // ----- src=gw (ETH issuer), dst=carol (holder), offerOwner=bob (holder) ----- + // ETH globally locked, src is ETH issuer: no first MPTEndpointStep so check() passes; + // MPT offer unfunded in OfferStream (globally-locked ETH cannot flow to holder via DEX); IOU issuer can still issue + {.src = gw, .dst = carol, .offerOwner = bob, .srcFlag = LockType::Global, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS}, + // BTC globally locked: last MPTEndpointStep only checks individual freeze, check() passes; offer unfunded in OfferStream + {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Global, .err = tecPATH_PARTIAL}, + // carol's BTC locked: caught in MPT check(); IOU dst can still receive when frozen + {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS}, + // bob's ETH (takerPays) locked: MPT offer unfunded in OfferStream (locked holder cannot receive); IOU can still receive + {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS}, + // bob's BTC (takerGets) locked: offer unfunded in OfferStream + {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL}, + // ----- src=alice (holder), dst=gw2 (BTC issuer), offerOwner=bob (holder) ----- + // alice's ETH locked: caught in check() + {.src = alice, .dst = gw2, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY}, + // BTC globally locked, dst is BTC issuer: no last MPTEndpointStep so check() passes; offer unfunded in OfferStream + {.src = alice, .dst = gw2, .offerOwner = bob, .dstFlag = LockType::Global, .err = tecPATH_PARTIAL}, + // bob's ETH (takerPays) locked: MPT offer unfunded in OfferStream (locked holder cannot receive); IOU can still receive + {.src = alice, .dst = gw2, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS}, + // bob's BTC (takerGets) locked: offer unfunded in OfferStream + {.src = alice, .dst = gw2, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL}, }; // clang-format on @@ -4347,13 +5298,13 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, carol, bob}, .pay = 100, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); MPTTester eth( {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 100, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | kMptDexFlags}); env(trust(alice, usd(100))); env(pay(gw, alice, usd(100))); @@ -5839,7 +6790,7 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice, carol}, .pay = 100, - .flags = kMPT_DEX_FLAGS | tfMPTCanLock}); + .flags = kMptDexFlags | tfMPTCanLock}); mpt.set({.flags = tfMPTLock}); @@ -5910,7 +6861,7 @@ class MPToken_test : public beast::unit_test::Suite {.env = env, .issuer = gw, .holders = {alice, carol}, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS}); + .flags = tfMPTRequireAuth | kMptDexFlags}); uint256 const chkId{getCheckIndex(alice, env.seq(alice))}; env(check::create(alice, carol, btc(50))); env.close(); @@ -5929,7 +6880,7 @@ class MPToken_test : public beast::unit_test::Suite env.close(); } - // MPTCanTransfer disabled + // MPTCanTransfer is disabled { Env env{*this, features}; env.fund(XRP(1'000), gw, alice, carol); @@ -5970,49 +6921,50 @@ class MPToken_test : public beast::unit_test::Suite BEAST_EXPECT(env.balance(alice, mpt) == mpt(0)); BEAST_EXPECT(env.balance(gw, mpt) == mpt(0)); - // neither src nor dst is issuer, can still create + // neither src nor dst is issuer, can't create + checkId = keylet::check(alice, env.seq(alice)).key; + env(check::create(alice, carol, mpt(100)), Ter(tecNO_AUTH)); + env.close(); + + // can create now + mpt.set({.account = gw, .mutableFlags = tmfMPTSetCanTransfer}); checkId = keylet::check(alice, env.seq(alice)).key; env(check::create(alice, carol, mpt(100))); env.close(); - - // can't cash - env(check::cash(carol, checkId, mpt(10)), Ter(tecPATH_PARTIAL)); - env.close(); - - // can cash now - mpt.set({.account = gw, .mutableFlags = tmfMPTSetCanTransfer}); env(pay(gw, alice, mpt(10))); env.close(); + // can't cash + mpt.set({.account = gw, .mutableFlags = tmfMPTClearCanTransfer}); + env.close(); + env(check::cash(carol, checkId, mpt(10)), Ter(tecNO_AUTH)); + env.close(); + // can cash + mpt.set({.account = gw, .mutableFlags = tmfMPTSetCanTransfer}); env(check::cash(carol, checkId, mpt(10))); env.close(); } - // MPTCanTrade disabled + // MPTCanTrade is disabled { Env env{*this, features}; env.fund(XRP(1'000), gw, alice, carol); env.close(); - MPTTester mpt( + MPT const mpt = MPTTester( {.env = env, .issuer = gw, .holders = {alice, carol}, - .flags = tfMPTCanTransfer, - .mutableFlags = tmfMPTCanMutateCanTrade}); + .pay = 10, + .flags = tfMPTCanTransfer}); - uint256 checkId{keylet::check(gw, env.seq(gw)).key}; + uint256 const checkId{keylet::check(alice, env.seq(alice)).key}; - // can't create - env(check::create(gw, alice, mpt(100)), Ter(tecNO_PERMISSION)); + // can create + env(check::create(alice, carol, mpt(100))); env.close(); - mpt.set({.account = gw, .mutableFlags = tmfMPTSetCanTrade}); - // can't cash - checkId = keylet::check(gw, env.seq(gw)).key; - env(check::create(gw, carol, mpt(100))); - env.close(); - mpt.set({.account = gw, .mutableFlags = tmfMPTClearCanTrade}); - env(check::cash(carol, checkId, mpt(10)), Ter(tecNO_PERMISSION)); + // can cash + env(check::cash(carol, checkId, mpt(10))); env.close(); } @@ -6057,7 +7009,7 @@ class MPToken_test : public beast::unit_test::Suite {.env = env, .issuer = gw, .holders = {alice}, - .flags = tfMPTRequireAuth | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | kMptDexFlags, .authHolder = true}); uint256 const chkId{getCheckIndex(alice, env.seq(alice))}; env(check::create(alice, carol, btc(1))); @@ -6067,33 +7019,6 @@ class MPToken_test : public beast::unit_test::Suite env.close(); } - // MPTCanTransfer is not set and the account is not the issuer of MPT - { - Env env{*this, features}; - env.fund(XRP(1'000), gw, alice, carol); - - auto eur = MPTTester( - {.env = env, .issuer = gw, .holders = {alice, carol}, .flags = tfMPTCanTrade}); - uint256 const chkId{getCheckIndex(alice, env.seq(alice))}; - // alice can create - env(check::create(alice, carol, eur(1))); - env.close(); - - // carol can't cash - env(check::cash(carol, chkId, eur(1)), Ter(tecPATH_PARTIAL)); - env.close(); - - // if issuer creates a check then carol can cash since - // it's a transfer from the issuer - uint256 const chkId1{getCheckIndex(gw, env.seq(gw))}; - // alice can't create since CanTransfer is not set - env(check::create(gw, carol, eur(1))); - env.close(); - - env(check::cash(carol, chkId1, eur(1))); - env.close(); - } - // Can create check if src/dst don't own MPT { Env env{*this, features}; @@ -6181,7 +7106,7 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000, - .flags = tfMPTCanLock | tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanLock | tfMPTCanClawback | kMptDexFlags}); env.trust(usd(10'000), alice); env(pay(gw, alice, usd(10'000))); @@ -6212,7 +7137,7 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 40'000, - .flags = tfMPTRequireAuth | tfMPTCanClawback | kMPT_DEX_FLAGS, + .flags = tfMPTRequireAuth | tfMPTCanClawback | kMptDexFlags, .authHolder = true}); env.trust(usd(10'000), alice); @@ -6254,8 +7179,7 @@ class MPToken_test : public beast::unit_test::Suite AMM amm(env, gw, btc(100), usd(100)); env.close(); // alice can't deposit since MPTCanTransfer is not set - amm.deposit( - DepositArg{.account = alice, .tokens = 1'000, .err = Ter(tecNO_PERMISSION)}); + amm.deposit(DepositArg{.account = alice, .tokens = 1'000, .err = Ter(tecNO_AUTH)}); env.close(); // can't clawback since alice is not an LP @@ -6296,9 +7220,9 @@ class MPToken_test : public beast::unit_test::Suite .issuer = gw, .holders = {alice}, .pay = 10'000, - .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + .flags = tfMPTCanClawback | kMptDexFlags}); auto eur = - MPTTester({.env = env, .issuer = gw, .flags = tfMPTCanClawback | kMPT_DEX_FLAGS}); + MPTTester({.env = env, .issuer = gw, .flags = tfMPTCanClawback | kMptDexFlags}); AMM amm(env, gw, usd(1'000), eur(1'000)); amm.deposit({.account = alice, .asset1In = usd(1'000)}); // MPToken doesn't exist @@ -6437,7 +7361,7 @@ class MPToken_test : public beast::unit_test::Suite auto usd = MPTTester( {.env = env, .issuer = gw, - .flags = tfMPTCanLock | kMPT_DEX_FLAGS, + .flags = tfMPTCanLock | kMptDexFlags, .mutableFlags = tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback | tmfMPTCanMutateCanTrade}); auto eur = MPTTester({.env = env, .issuer = gw, .holders = {alice}, .pay = 1'000'000}); @@ -6488,8 +7412,8 @@ class MPToken_test : public beast::unit_test::Suite // alice and issuer can't create usd.set({.flags = tfMPTLock}); - createFail(alice, tecFROZEN); - createFail(gw, tecFROZEN); + createFail(alice, tecLOCKED); + createFail(gw, tecLOCKED); // MPTRequireAuth is set @@ -6509,7 +7433,7 @@ class MPToken_test : public beast::unit_test::Suite usd.set({.mutableFlags = tmfMPTClearRequireAuth}); usd.set({.mutableFlags = tmfMPTClearCanTransfer}); // alice can't create - createFail(alice, tecNO_PERMISSION); + createFail(alice, tecNO_AUTH); // issuer can create createDeleteAMM(gw); usd.set({.mutableFlags = tmfMPTSetCanTransfer}); @@ -6555,12 +7479,12 @@ class MPToken_test : public beast::unit_test::Suite {.account = account, .asset1In = usd(1), .asset2In = eur(1), - .err = Ter(tecFROZEN)}); + .err = Ter(tecLOCKED)}); amm.deposit( {.account = account, .asset1In = eur(1), .assets = std::make_pair(eur, usd), - .err = Ter(tecFROZEN)}); + .err = Ter(tecLOCKED)}); } usd.set({.flags = tfMPTUnlock}); @@ -6573,8 +7497,6 @@ class MPToken_test : public beast::unit_test::Suite eur.authorize({.account = carol}); env(pay(gw, carol, eur(1'000'000))); usd.set({.mutableFlags = tmfMPTSetRequireAuth}); - // have to authorize amm account - usd.authorize({.account = gw, .holder = Account{"amm", amm.ammAccount()}}); env.close(); amm.deposit( {.account = carol, .asset1In = usd(1), .asset2In = eur(1), .err = Ter(tecNO_AUTH)}); @@ -6588,6 +7510,16 @@ class MPToken_test : public beast::unit_test::Suite // carol is authorized, can deposit usd.authorize({.account = gw, .holder = carol}); amm.deposit({.account = carol, .tokens = 1'000}); + // Can't authorize or unauthorize AMM pseudo-account + usd.authorize( + {.account = gw, + .holder = Account{"amm", amm.ammAccount()}, + .err = tecNO_PERMISSION}); + usd.authorize( + {.account = gw, + .holder = Account{"amm", amm.ammAccount()}, + .flags = tfMPTUnauthorize, + .err = tecNO_PERMISSION}); // MPTCanTransfer is not set @@ -6595,15 +7527,12 @@ class MPToken_test : public beast::unit_test::Suite usd.set({.mutableFlags = tmfMPTClearCanTransfer}); // carol can't deposit amm.deposit( - {.account = carol, - .asset1In = usd(1), - .asset2In = eur(1), - .err = Ter(tecNO_PERMISSION)}); + {.account = carol, .asset1In = usd(1), .asset2In = eur(1), .err = Ter(tecNO_AUTH)}); amm.deposit( {.account = carol, .asset1In = eur(1), .assets = std::make_pair(eur, usd), - .err = Ter(tecNO_PERMISSION)}); + .err = Ter(tecNO_AUTH)}); // issuer can deposit amm.deposit({.account = gw, .tokens = 1'000}); // carol can deposit @@ -6645,8 +7574,8 @@ class MPToken_test : public beast::unit_test::Suite {.account = account, .asset1Out = usd(1), .asset2Out = eur(1), - .err = Ter(tecFROZEN)}); - amm.withdraw({.account = account, .tokens = 1'000, .err = Ter(tecFROZEN)}); + .err = Ter(tecLOCKED)}); + amm.withdraw({.account = account, .tokens = 1'000, .err = Ter(tecLOCKED)}); // can single withdraw another asset amm.withdraw( {.account = account, .asset1Out = eur(1), .assets = std::make_pair(eur, usd)}); @@ -6672,29 +7601,38 @@ class MPToken_test : public beast::unit_test::Suite usd.authorize({.account = gw, .holder = carol}); amm.withdraw({.account = carol, .asset1Out = usd(1), .asset2Out = eur(1)}); - // MPTCanTransfer is set + // MPTCanTransfer is not set, allow to withdraw usd.set({.mutableFlags = tmfMPTClearRequireAuth}); usd.set({.mutableFlags = tmfMPTClearCanTransfer}); - // carol can't withdraw - amm.withdraw( - {.account = carol, - .asset1Out = usd(1), - .asset2Out = eur(1), - .err = Ter(tecNO_PERMISSION)}); + // carol can withdraw + amm.withdraw({.account = carol, .asset1Out = usd(1), .asset2Out = eur(1)}); // can withdraw another asset amm.withdraw( {.account = carol, .asset1Out = eur(1), .assets = std::make_pair(eur, usd)}); // issuer can withdraw amm.withdraw({.account = gw, .asset1Out = usd(1), .asset2Out = eur(1)}); + // Holder can't transfer to another holder + env.fund(XRP(1'000), bob); + usd.authorize({.account = bob}); + env(pay(carol, bob, usd(1)), Ter(tecNO_AUTH)); + usd.authorize({.account = bob, .flags = tfMPTUnauthorize}); + // Can redeem + env(pay(carol, gw, usd(1))); // carol can withdraw usd.set({.mutableFlags = tmfMPTSetCanTransfer}); amm.withdraw({.account = carol, .asset1Out = usd(1), .asset2Out = eur(1)}); usd.set({.mutableFlags = tmfMPTSetCanTransfer}); + + // MPTCanTrade is not set, allow to withdraw + usd.set({.mutableFlags = tmfMPTClearCanTrade}); - amm.withdraw({.account = gw, .tokens = 1'000, .err = Ter(tecNO_PERMISSION)}); - amm.withdraw({.account = carol, .tokens = 1'000, .err = Ter(tecNO_PERMISSION)}); + amm.withdraw({.account = gw, .tokens = 1'000}); + amm.withdraw({.account = carol, .tokens = 1'000}); + // Can't DEX + amm.deposit( + DepositArg{.account = carol, .asset1In = usd(1), .err = Ter(tecNO_PERMISSION)}); usd.set({.mutableFlags = tmfMPTSetCanTrade}); // MPToken created on withdraw @@ -6713,6 +7651,99 @@ class MPToken_test : public beast::unit_test::Suite } } + void + testFixDoubleOwnerCount(FeatureBitset all) + { + testcase("Fix Double adjustOwnerCount in AMMWithdraw"); + + using namespace jtx; + + // Carol deposits XRP into an XRP/MPT pool, then withdraws MPT. + // Carol has no MPToken before the withdrawal. If the bug exists, + // her ownerCount will be inflated by +1 extra. + Account const gw{"gw"}; + Account const alice{"alice"}; + Account const carol{"carol"}; + Env env(*this, all); + env.fund(XRP(30'000), gw, alice, carol); + env.close(); + + // Create MPT with DEX flags. Only alice is a holder initially. + MPT const btc = MPTTester( + {.env = env, .issuer = gw, .holders = {alice}, .pay = 20'000, .flags = kMptDexFlags}); + + // Alice creates XRP/MPT AMM pool + AMM amm(env, alice, XRP(10'000), btc(10'000)); + + // Carol deposits XRP (single asset) into the pool. + // Carol gets LP tokens but does NOT have an MPToken yet. + auto const carolOwnersBefore = ownerCount(env, carol); + amm.deposit(carol, XRP(1'000), std::nullopt, std::nullopt, tfSingleAsset); + auto const carolOwnersAfterDeposit = ownerCount(env, carol); + // Carol should have +1 for LP token trustline + BEAST_EXPECT(carolOwnersAfterDeposit == carolOwnersBefore + 1); + + auto const carolOwnersBeforeWithdraw = ownerCount(env, carol); + // Carol withdraws single MPT asset. She doesn't have an MPToken, + // so one must be created. Bug: ownerCount incremented twice. + amm.withdraw({.account = carol, .asset1Out = btc(100), .flags = tfSingleAsset}); + auto const carolOwnersAfterWithdraw = ownerCount(env, carol); + + // Expected: +1 for the new MPToken (so total increase = 1) + BEAST_EXPECT(carolOwnersAfterWithdraw == carolOwnersBeforeWithdraw + 1); + } + + void + testTradeAndTransfer() + { + using namespace jtx; + testcase("Trade and Transfer"); + + // Verify canMPTTradeAndTransfer validates the flags when from == to and from != to + + Account const gw{"gw"}; + Account const alice{"alice"}; + Account const carol{"carol"}; + Env env(*this); + env.fund(XRP(1'000), gw, alice, carol); + + MPTTester mpt( + {.env = env, + .issuer = gw, + .holders = {alice, carol}, + .pay = 100, + .flags = kMptDexFlags, + .mutableFlags = tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanTrade}); + + // Both flags are enabled + BEAST_EXPECT(isTesSuccess(canMPTTradeAndTransfer(*env.current(), mpt, gw, gw))); + BEAST_EXPECT(isTesSuccess(canMPTTradeAndTransfer(*env.current(), mpt, gw, alice))); + BEAST_EXPECT(isTesSuccess(canMPTTradeAndTransfer(*env.current(), mpt, alice, alice))); + BEAST_EXPECT(isTesSuccess(canMPTTradeAndTransfer(*env.current(), mpt, alice, carol))); + + // MPTCanTrade is disabled + mpt.set({.mutableFlags = tmfMPTClearCanTrade}); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, gw, gw) == tecNO_PERMISSION); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, gw, alice) == tecNO_PERMISSION); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, alice, alice) == tecNO_PERMISSION); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, alice, carol) == tecNO_PERMISSION); + + // MPTCanTransfer is disabled + mpt.set({.mutableFlags = tmfMPTSetCanTrade}); + mpt.set({.mutableFlags = tmfMPTClearCanTransfer}); + BEAST_EXPECT(isTesSuccess(canMPTTradeAndTransfer(*env.current(), mpt, gw, gw))); + BEAST_EXPECT(isTesSuccess(canMPTTradeAndTransfer(*env.current(), mpt, gw, alice))); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, alice, alice) == tecNO_AUTH); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, alice, carol) == tecNO_AUTH); + + // Both flags are disabled + mpt.set({.mutableFlags = tmfMPTClearCanTrade}); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, gw, gw) == tecNO_PERMISSION); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, gw, alice) == tecNO_PERMISSION); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, alice, alice) == tecNO_PERMISSION); + BEAST_EXPECT(canMPTTradeAndTransfer(*env.current(), mpt, alice, carol) == tecNO_PERMISSION); + } + public: void run() override @@ -6781,7 +7812,7 @@ public: // Test MPT Amount is invalid in Tx, which don't support MPT testMPTInvalidInTx(all); - + testNonCanonicalMPTAmountCleanup(all); // Test parsed MPTokenIssuanceID in API response metadata testTxJsonMetaFields(all); @@ -6819,6 +7850,12 @@ public: // Test AMM testBasicAMM(all); + + // Test Trade/Transfer + testTradeAndTransfer(); + + // Fixes + testFixDoubleOwnerCount(all); } }; diff --git a/src/test/app/Manifest_test.cpp b/src/test/app/Manifest_test.cpp index f20847ae5c..d559ecd7b5 100644 --- a/src/test/app/Manifest_test.cpp +++ b/src/test/app/Manifest_test.cpp @@ -115,7 +115,7 @@ public: SecretKey const& ssk, int seq) { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = seq; st[sfPublicKey] = pk; st[sfSigningPubKey] = spk; @@ -137,7 +137,7 @@ public: { auto const pk = derivePublicKey(type, sk); - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = std::numeric_limits::max(); st[sfPublicKey] = pk; @@ -156,7 +156,7 @@ public: { auto const pk = derivePublicKey(type, sk); - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = std::numeric_limits::max(); st[sfPublicKey] = pk; @@ -186,7 +186,7 @@ public: auto const pk = derivePublicKey(type, sk); auto const spk = derivePublicKey(stype, ssk); - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = seq; st[sfPublicKey] = pk; st[sfSigningPubKey] = spk; @@ -363,7 +363,7 @@ public: auto const kp = randomKeyPair(KeyType::Secp256k1); auto const m = makeManifest(sk, KeyType::Ed25519, kp.second, KeyType::Secp256k1, 0); - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = 0; st[sfPublicKey] = pk; st[sfSigningPubKey] = kp.first; @@ -495,7 +495,7 @@ public: auto const spk = derivePublicKey(KeyType::Secp256k1, ssk); auto buildManifestObject = [&](std::uint16_t version) { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = 3; st[sfPublicKey] = pk; st[sfSigningPubKey] = spk; @@ -573,7 +573,7 @@ public: std::optional domain, bool noSigningPublic = false, bool noSignature = false) { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = seq; st[sfPublicKey] = pk; @@ -724,7 +724,7 @@ public: } { // reject matching master & ephemeral keys - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = 314159; st[sfPublicKey] = pk; st[sfSigningPubKey] = pk; @@ -797,7 +797,7 @@ public: auto const pk2 = derivePublicKey(KeyType::Secp256k1, sk2); auto test = [&](std::string domain) { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = 7; st[sfPublicKey] = pk1; st[sfDomain] = makeSlice(domain); diff --git a/src/test/app/MultiSign_test.cpp b/src/test/app/MultiSign_test.cpp index 55e1b73158..f21611df0e 100644 --- a/src/test/app/MultiSign_test.cpp +++ b/src/test/app/MultiSign_test.cpp @@ -143,7 +143,7 @@ public: env.require(Owners(alice, 1)); } // Remove alice's signer list and get the owner count back. - env(signers(alice, jtx::kNONE)); + env(signers(alice, jtx::kNone)); env.close(); env.require(Owners(alice, 0)); } @@ -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"); @@ -826,7 +826,7 @@ public: BEAST_EXPECT(env.seq(alice) == aliceSeq); // Remove alice's signer list and get the owner count back. - env(signers(alice, jtx::kNONE), Sig(alie)); + env(signers(alice, jtx::kNone), Sig(alie)); env.close(); env.require(Owners(alice, 0)); } @@ -871,23 +871,23 @@ public: env(fset(alice, asfDisableMaster), Sig(alice)); // R0: A lone regular key cannot be removed. - env(regkey(alice, kDISABLED), Sig(alie), Ter(tecNO_ALTERNATIVE_KEY)); + env(regkey(alice, kDisabled), Sig(alie), Ter(tecNO_ALTERNATIVE_KEY)); // Add a signer list. env(signers(alice, 1, {{bogie_, 1}}), Sig(alie)); // R1: The regular key can be removed if there's a signer list. - env(regkey(alice, kDISABLED), Sig(alie)); + env(regkey(alice, kDisabled), Sig(alie)); // L0: A lone signer list cannot be removed. auto const baseFee = env.current()->fees().base; - env(signers(alice, jtx::kNONE), Msig(bogie_), Fee(2 * baseFee), Ter(tecNO_ALTERNATIVE_KEY)); + env(signers(alice, jtx::kNone), Msig(bogie_), Fee(2 * baseFee), Ter(tecNO_ALTERNATIVE_KEY)); // Enable the master key. env(fclear(alice, asfDisableMaster), Msig(bogie_), Fee(2 * baseFee)); // L1: The signer list can be removed if the master key is enabled. - env(signers(alice, jtx::kNONE), Msig(bogie_), Fee(2 * baseFee)); + env(signers(alice, jtx::kNone), Msig(bogie_), Fee(2 * baseFee)); // Add a signer list. env(signers(alice, 1, {{bogie_, 1}}), Sig(alice)); @@ -899,13 +899,13 @@ public: env(regkey(alice, alie), Msig(bogie_), Fee(2 * baseFee)); // L2: The signer list can be removed if there's a regular key. - env(signers(alice, jtx::kNONE), Sig(alie)); + env(signers(alice, jtx::kNone), Sig(alie)); // Enable the master key. env(fclear(alice, asfDisableMaster), Sig(alie)); // R2: The regular key can be removed if the master key is enabled. - env(regkey(alice, kDISABLED), Sig(alie)); + env(regkey(alice, kDisabled), Sig(alie)); } // Verify that the first regular key can be made for free using the @@ -1398,7 +1398,7 @@ public: BEAST_EXPECT(env.seq(alice) == aliceSeq); // Should also be able to remove the signer list using a ticket. - env(signers(alice, jtx::kNONE), ticket::Use(aliceTicketSeq++)); + env(signers(alice, jtx::kNone), ticket::Use(aliceTicketSeq++)); env.close(); env.require(tickets(alice, env.seq(alice) - aliceTicketSeq)); BEAST_EXPECT(env.seq(alice) == aliceSeq); @@ -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/NFTokenAuth_test.cpp b/src/test/app/NFTokenAuth_test.cpp index da5760f387..4929cadd65 100644 --- a/src/test/app/NFTokenAuth_test.cpp +++ b/src/test/app/NFTokenAuth_test.cpp @@ -582,11 +582,11 @@ public: run() override { using namespace test::jtx; - static FeatureBitset const kALL{testableAmendments()}; + static FeatureBitset const kAll{testableAmendments()}; - static std::array const kFEATURES = {kALL - fixEnforceNFTokenTrustlineV2, kALL}; + static std::array const kFeatures = {kAll - fixEnforceNFTokenTrustlineV2, kAll}; - for (auto const feature : kFEATURES) + for (auto const feature : kFeatures) { testBuyOfferUnauthorizedSeller(feature); testCreateBuyOfferUnauthorizedBuyer(feature); diff --git a/src/test/app/NFTokenBurn_test.cpp b/src/test/app/NFTokenBurn_test.cpp index 56bb6b75d7..482d275d51 100644 --- a/src/test/app/NFTokenBurn_test.cpp +++ b/src/test/app/NFTokenBurn_test.cpp @@ -67,7 +67,7 @@ class NFTokenBurn_test : public beast::unit_test::Suite using namespace test::jtx; uint256 const nftokenID = token::getNextID(env, owner, 0, tfTransferable); env(token::mint(owner, 0), - token::Uri(std::string(kMAX_TOKEN_URI_LENGTH, 'u')), + token::Uri(std::string(kMaxTokenUriLength, 'u')), Txflags(tfTransferable)); env.close(); @@ -200,7 +200,7 @@ class NFTokenBurn_test : public beast::unit_test::Suite // way each time. std::mt19937 engine; std::uniform_int_distribution feeDist( - decltype(kMAX_TRANSFER_FEE){}, kMAX_TRANSFER_FEE); + decltype(kMaxTransferFee){}, kMaxTransferFee); alice.nfts.reserve(105); while (alice.nfts.size() < 105) @@ -337,7 +337,7 @@ class NFTokenBurn_test : public beast::unit_test::Suite BEAST_EXPECT(nftCount(env, becky.acct) == 0); BEAST_EXPECT(nftCount(env, minter.acct) == 0); - // When all nfts are burned kNONE of the accounts should have + // When all nfts are burned kNone of the accounts should have // an ownerCount. BEAST_EXPECT(ownerCount(env, alice) == 0); BEAST_EXPECT(ownerCount(env, becky) == 0); @@ -515,7 +515,7 @@ class NFTokenBurn_test : public beast::unit_test::Suite { // Removing the last token from the last page deletes the // _previous_ page because we need to preserve that last - // page an an anchor. The contents of the next-to-last page + // page as an anchor. The contents of the next-to-last page // are moved into the last page. lastNFTokenPage = env.le(keylet::nftpageMax(alice)); BEAST_EXPECT(lastNFTokenPage); @@ -694,7 +694,7 @@ class NFTokenBurn_test : public beast::unit_test::Suite { // Removing the last token from the last page deletes the // _previous_ page because we need to preserve that last - // page an an anchor. The contents of the next-to-last page + // page as an anchor. The contents of the next-to-last page // are moved into the last page. lastNFTokenPage = env.le(keylet::nftpageMax(alice)); BEAST_EXPECT(lastNFTokenPage); @@ -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}; @@ -861,8 +861,8 @@ class NFTokenBurn_test : public beast::unit_test::Suite // When the token is burned, 498 sell offers and 1 buy offer are // removed. In total, 499 offers are removed std::vector offerIndexes; - auto const nftokenID = createNftAndOffers( - env, alice, offerIndexes, kMAX_DELETABLE_TOKEN_OFFER_ENTRIES - 2); + auto const nftokenID = + createNftAndOffers(env, alice, offerIndexes, kMaxDeletableTokenOfferEntries - 2); // Verify all sell offers are present in the ledger. for (uint256 const& offerIndex : offerIndexes) @@ -908,8 +908,8 @@ class NFTokenBurn_test : public beast::unit_test::Suite // After we burn the token, 500 of the sell offers should be // removed, and one is left over std::vector offerIndexes; - auto const nftokenID = createNftAndOffers( - env, alice, offerIndexes, kMAX_DELETABLE_TOKEN_OFFER_ENTRIES + 1); + auto const nftokenID = + createNftAndOffers(env, alice, offerIndexes, kMaxDeletableTokenOfferEntries + 1); // Verify all sell offers are present in the ledger. for (uint256 const& offerIndex : offerIndexes) @@ -929,10 +929,10 @@ class NFTokenBurn_test : public beast::unit_test::Suite offerDeletedCount++; } - BEAST_EXPECT(offerIndexes.size() == kMAX_TOKEN_OFFER_CANCEL_COUNT + 1); + BEAST_EXPECT(offerIndexes.size() == kMaxTokenOfferCancelCount + 1); // 500 sell offers should be removed - BEAST_EXPECT(offerDeletedCount == kMAX_TOKEN_OFFER_CANCEL_COUNT); + BEAST_EXPECT(offerDeletedCount == kMaxTokenOfferCancelCount); // alice should have ownerCounts of one for the orphaned sell offer BEAST_EXPECT(ownerCount(env, alice) == 1); @@ -952,8 +952,8 @@ class NFTokenBurn_test : public beast::unit_test::Suite // are removed. // In total, 500 offers are removed std::vector offerIndexes; - auto const nftokenID = createNftAndOffers( - env, alice, offerIndexes, kMAX_DELETABLE_TOKEN_OFFER_ENTRIES - 1); + auto const nftokenID = + createNftAndOffers(env, alice, offerIndexes, kMaxDeletableTokenOfferEntries - 1); // Verify all sell offers are present in the ledger. for (uint256 const& offerIndex : offerIndexes) diff --git a/src/test/app/NFTokenDir_test.cpp b/src/test/app/NFTokenDir_test.cpp index fbae51406b..117f2bc816 100644 --- a/src/test/app/NFTokenDir_test.cpp +++ b/src/test/app/NFTokenDir_test.cpp @@ -126,10 +126,10 @@ class NFTokenDir_test : public beast::unit_test::Suite // Mint 100 sequential NFTs. Tweak the taxon so zero is always stored. // That's what makes them sequential. - constexpr std::size_t kNFT_COUNT = 100; + static constexpr std::size_t kNftCount = 100; std::vector nftIDs; - nftIDs.reserve(kNFT_COUNT); - for (int i = 0; i < kNFT_COUNT; ++i) + nftIDs.reserve(kNftCount); + for (int i = 0; i < kNftCount; ++i) { std::uint32_t const taxon = toUInt32(nft::cipheredTaxon(i, nft::toTaxon(0))); nftIDs.emplace_back(token::getNextID(env, issuer, taxon, tfTransferable)); @@ -272,7 +272,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // These seeds cause a lopsided split where the new NFT is added // to the upper page. - static std::initializer_list const kSPLIT_AND_ADD_TO_HI{ + static std::initializer_list const kSplitAndAddToHi{ "sp6JS7f14BuwFY8Mw5p3b8jjQBBTK", // 0. 0x1d2932ea "sp6JS7f14BuwFY8Mw6F7X3EiGKazu", // 1. 0x1d2932ea "sp6JS7f14BuwFY8Mw6FxjntJJfKXq", // 2. 0x1d2932ea @@ -318,7 +318,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // These seeds cause a lopsided split where the new NFT is added // to the lower page. - static std::initializer_list const kSPLIT_AND_ADD_TO_LO{ + static std::initializer_list const kSplitAndAddToLo{ "sp6JS7f14BuwFY8Mw5p3b8jjQBBTK", // 0. 0x1d2932ea "sp6JS7f14BuwFY8Mw6F7X3EiGKazu", // 1. 0x1d2932ea "sp6JS7f14BuwFY8Mw6FxjntJJfKXq", // 2. 0x1d2932ea @@ -363,8 +363,8 @@ class NFTokenDir_test : public beast::unit_test::Suite }; // Run the test cases. - exerciseLopsided(kSPLIT_AND_ADD_TO_HI); - exerciseLopsided(kSPLIT_AND_ADD_TO_LO); + exerciseLopsided(kSplitAndAddToHi); + exerciseLopsided(kSplitAndAddToLo); } void @@ -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"}; @@ -480,7 +480,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // These seeds fill the last 17 entries of the initial page with // equivalent NFTs. The split should keep these together. - static std::initializer_list const kSEVENTEEN_HI{ + static std::initializer_list const kSeventeenHi{ // These 16 need to be kept together by the implementation. "sp6JS7f14BuwFY8Mw5EYu5z86hKDL", // 0. 0x399187e9 "sp6JS7f14BuwFY8Mw5PUAMwc5ygd7", // 1. 0x399187e9 @@ -521,7 +521,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // These seeds fill the first entries of the initial page with // equivalent NFTs. The split should keep these together. - static std::initializer_list const kSEVENTEEN_LO{ + static std::initializer_list const kSeventeenLo{ // These 17 need to be kept together by the implementation. "sp6JS7f14BuwFY8Mw5EYu5z86hKDL", // 0. 0x399187e9 "sp6JS7f14BuwFY8Mw5PUAMwc5ygd7", // 1. 0x399187e9 @@ -561,8 +561,8 @@ class NFTokenDir_test : public beast::unit_test::Suite }; // Run the test cases. - exercise(kSEVENTEEN_HI); - exercise(kSEVENTEEN_LO); + exercise(kSeventeenHi); + exercise(kSeventeenLo); } void @@ -583,7 +583,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // Here are 33 seeds that produce identical low 32-bits in their // corresponding AccountIDs. - static std::initializer_list const kSEEDS{ + static std::initializer_list const kSeeds{ "sp6JS7f14BuwFY8Mw5FnqmbciPvH6", // 0. 0x9a8ebed3 "sp6JS7f14BuwFY8Mw5MBGbyMSsXLp", // 1. 0x9a8ebed3 "sp6JS7f14BuwFY8Mw5S4PnDyBdKKm", // 2. 0x9a8ebed3 @@ -621,8 +621,8 @@ class NFTokenDir_test : public beast::unit_test::Suite // Create accounts for all of the seeds and fund those accounts. std::vector accounts; - accounts.reserve(kSEEDS.size()); - for (std::string_view const seed : kSEEDS) + accounts.reserve(kSeeds.size()); + for (std::string_view const seed : kSeeds) { Account const& account = accounts.emplace_back(Account::AcctStringType::Base58Seed, std::string(seed)); @@ -656,10 +656,10 @@ class NFTokenDir_test : public beast::unit_test::Suite env.close(); // Verify that the low 96 bits of all generated NFTs is identical. - uint256 const expectLowBits = nftIDs.front() & nft::kPAGE_MASK; + uint256 const expectLowBits = nftIDs.front() & nft::kPageMask; for (uint256 const& nftID : nftIDs) { - BEAST_EXPECT(expectLowBits == (nftID & nft::kPAGE_MASK)); + BEAST_EXPECT(expectLowBits == (nftID & nft::kPageMask)); } // Remove one NFT and offer from the vectors. This offer is the one @@ -731,7 +731,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // // All of the NFTs should be acquired by the buyer. // - // Lastly, kNONE of the remaining NFTs should be acquirable by the + // Lastly, kNone of the remaining NFTs should be acquirable by the // buyer. They would cause page overflow. testcase("NFToken consecutive packing"); @@ -747,7 +747,7 @@ class NFTokenDir_test : public beast::unit_test::Suite // Here are 33 seeds that produce identical low 32-bits in their // corresponding AccountIDs. - static std::initializer_list const kSEEDS{ + static std::initializer_list const kSeeds{ "sp6JS7f14BuwFY8Mw56vZeiBuhePx", // 0. 0x115d0525 "sp6JS7f14BuwFY8Mw5BodF9tGuTUe", // 1. 0x115d0525 "sp6JS7f14BuwFY8Mw5EnhC1cg84J7", // 2. 0x115d0525 @@ -785,8 +785,8 @@ class NFTokenDir_test : public beast::unit_test::Suite // Create accounts for all of the seeds and fund those accounts. std::vector accounts; - accounts.reserve(kSEEDS.size()); - for (std::string_view const seed : kSEEDS) + accounts.reserve(kSeeds.size()); + for (std::string_view const seed : kSeeds) { Account const& account = accounts.emplace_back(Account::AcctStringType::Base58Seed, std::string(seed)); @@ -832,10 +832,10 @@ class NFTokenDir_test : public beast::unit_test::Suite // sequence is identical. for (auto const& vec : nftIDsByPage) { - uint256 const expectLowBits = vec.front() & nft::kPAGE_MASK; + uint256 const expectLowBits = vec.front() & nft::kPageMask; for (uint256 const& nftID : vec) { - BEAST_EXPECT(expectLowBits == (nftID & nft::kPAGE_MASK)); + BEAST_EXPECT(expectLowBits == (nftID & nft::kPageMask)); } } @@ -850,11 +850,11 @@ class NFTokenDir_test : public beast::unit_test::Suite { overflowNFTs.push_back(nftIDsByPage[i].back()); nftIDsByPage[i].pop_back(); - BEAST_EXPECT(nftIDsByPage[i].size() == kSEEDS.size() - 1); + BEAST_EXPECT(nftIDsByPage[i].size() == kSeeds.size() - 1); overflowOffers.push_back(offers[i].back()); offers[i].pop_back(); - BEAST_EXPECT(offers[i].size() == kSEEDS.size() - 1); + BEAST_EXPECT(offers[i].size() == kSeeds.size() - 1); } // buyer accepts all of the offers that won't cause an overflow. @@ -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 6f204886cf..22af87662d 100644 --- a/src/test/app/NFToken_test.cpp +++ b/src/test/app/NFToken_test.cpp @@ -508,11 +508,11 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // Can't set a transfer fee if the NFT does not have the tfTRANSFERABLE // flag set. - env(token::mint(alice, 0u), token::XferFee(kMAX_TRANSFER_FEE), Ter(temMALFORMED)); + env(token::mint(alice, 0u), token::XferFee(kMaxTransferFee), Ter(temMALFORMED)); // Set a bad transfer fee. env(token::mint(alice, 0u), - token::XferFee(kMAX_TRANSFER_FEE + 1), + token::XferFee(kMaxTransferFee + 1), Txflags(tfTransferable), Ter(temBAD_NFTOKEN_TRANSFER_FEE)); @@ -524,7 +524,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // Invalid URI: too long. env(token::mint(alice, 0u), - token::Uri(std::string(kMAX_TOKEN_URI_LENGTH + 1, 'q')), + token::Uri(std::string(kMaxTokenUriLength + 1, 'q')), Ter(temMALFORMED)); //---------------------------------------------------------------------- @@ -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); @@ -894,7 +894,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // List of tokens to delete is too long. { - std::vector const offers(kMAX_TOKEN_OFFER_CANCEL_COUNT + 1, buyerOfferIndex); + std::vector const offers(kMaxTokenOfferCancelCount + 1, buyerOfferIndex); env(token::cancelOffer(buyer, offers), Ter(temMALFORMED)); env.close(); @@ -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); @@ -1084,7 +1084,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // preclaim // The buy offer must be non-zero. - env(token::acceptBuyOffer(buyer, beast::kZERO), Ter(tecOBJECT_NOT_FOUND)); + env(token::acceptBuyOffer(buyer, beast::kZero), Ter(tecOBJECT_NOT_FOUND)); env.close(); BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); @@ -1095,17 +1095,17 @@ 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--; } BEAST_EXPECT(ownerCount(env, buyer) == buyerCount); // The sell offer must be non-zero. - env(token::acceptSellOffer(buyer, beast::kZERO), Ter(tecOBJECT_NOT_FOUND)); + env(token::acceptSellOffer(buyer, beast::kZero), Ter(tecOBJECT_NOT_FOUND)); env.close(); BEAST_EXPECT(ownerCount(env, buyer) == 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--; } @@ -1320,7 +1320,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite //---------------------------------------------------------------------- // doApply // - // As far as I can see kNONE of the failure modes are accessible as + // As far as I can see kNone of the failure modes are accessible as // long as the preflight and preclaim conditions are met. } @@ -2140,14 +2140,13 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // A transfer fee greater than 50% is not allowed. env(token::mint(alice), Txflags(tfTransferable), - token::XferFee(kMAX_TRANSFER_FEE + 1), + token::XferFee(kMaxTransferFee + 1), Ter(temBAD_NFTOKEN_TRANSFER_FEE)); env.close(); // Make an nft with a transfer fee of 50%. - uint256 const nftID = - token::getNextID(env, alice, 0u, tfTransferable, kMAX_TRANSFER_FEE); - env(token::mint(alice), Txflags(tfTransferable), token::XferFee(kMAX_TRANSFER_FEE)); + uint256 const nftID = token::getNextID(env, alice, 0u, tfTransferable, kMaxTransferFee); + env(token::mint(alice), Txflags(tfTransferable), token::XferFee(kMaxTransferFee)); env.close(); // Becky buys the nft for XAU(10). Check balances. @@ -2288,14 +2287,14 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite env(pay(becky, gw, env.balance(becky, gwXAU))); env.close(); - STAmount const startXAUBalance(gwXAU, STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET + 5); + STAmount const startXAUBalance(gwXAU, STAmount::kMinValue, STAmount::kMinOffset + 5); env(pay(gw, alice, startXAUBalance)); env(pay(gw, minter, startXAUBalance)); env(pay(gw, becky, startXAUBalance)); env.close(); // Here is the smallest expressible gwXAU amount. - STAmount const tinyXAU(gwXAU, STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET); + STAmount const tinyXAU(gwXAU, STAmount::kMinValue, STAmount::kMinOffset); // minter buys the nft for tinyXAU. Since the transfer involves // alice there should be no transfer fee. @@ -2328,7 +2327,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // carol sells to becky. This is the smallest gwXAU amount // to pay for a transfer that enables a transfer fee of 1. - STAmount const cheapNFT(gwXAU, STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET + 5); + STAmount const cheapNFT(gwXAU, STAmount::kMinValue, STAmount::kMinOffset + 5); STAmount beckyBalance = env.balance(becky, gwXAU); uint256 const beckyBuyOfferIndex = keylet::nftoffer(becky, env.seq(becky)).key; @@ -3091,10 +3090,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--; @@ -3113,7 +3112,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 @@ -3179,10 +3178,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--; @@ -3201,7 +3200,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 @@ -3278,7 +3277,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--; @@ -3288,7 +3287,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 @@ -3367,7 +3366,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 @@ -3453,7 +3452,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); @@ -3609,10 +3608,10 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite env.fund(XRP(1000), alice); env.close(); - std::string const uri(kMAX_TOKEN_URI_LENGTH, '?'); + std::string const uri(kMaxTokenUriLength, '?'); std::vector offerIndexes; - offerIndexes.reserve(kMAX_TOKEN_OFFER_CANCEL_COUNT + 1); - for (uint32_t i = 0; i < kMAX_TOKEN_OFFER_CANCEL_COUNT + 1; ++i) + offerIndexes.reserve(kMaxTokenOfferCancelCount + 1); + for (uint32_t i = 0; i < kMaxTokenOfferCancelCount + 1; ++i) { Account const nftAcct(std::string("nftAcct") + std::to_string(i)); Account const offerAcct(std::string("offerAcct") + std::to_string(i)); @@ -3857,7 +3856,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite { checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__); - uint256 const nftID = mintNFT(kMAX_TRANSFER_FEE); + uint256 const nftID = mintNFT(kMaxTransferFee); // minter creates their offer. uint256 const minterOfferIndex = keylet::nftoffer(minter, env.seq(minter)).key; @@ -3899,7 +3898,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite { checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__); - uint256 const nftID = mintNFT(kMAX_TRANSFER_FEE); + uint256 const nftID = mintNFT(kMaxTransferFee); // minter creates their offer. uint256 const minterOfferIndex = keylet::nftoffer(minter, env.seq(minter)).key; @@ -4049,7 +4048,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__); setXAUBalance({issuer, minter, buyer, broker}, 1000, __LINE__); - uint256 const nftID = mintNFT(kMAX_TRANSFER_FEE); + uint256 const nftID = mintNFT(kMaxTransferFee); // minter creates their offer. uint256 const minterOfferIndex = keylet::nftoffer(minter, env.seq(minter)).key; @@ -4127,7 +4126,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__); setXAUBalance({issuer, minter, buyer, broker}, 1000, __LINE__); - uint256 const nftID = mintNFT(kMAX_TRANSFER_FEE / 2); // 25% + uint256 const nftID = mintNFT(kMaxTransferFee / 2); // 25% // minter creates their offer. uint256 const minterOfferIndex = keylet::nftoffer(minter, env.seq(minter)).key; @@ -4164,7 +4163,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__); setXAUBalance({issuer, minter, buyer}, 1000, __LINE__); setXAUBalance({broker}, 500, __LINE__); - uint256 const nftID = mintNFT(kMAX_TRANSFER_FEE / 2); // 25% + uint256 const nftID = mintNFT(kMaxTransferFee / 2); // 25% // minter creates their offer. uint256 const minterOfferIndex = keylet::nftoffer(minter, env.seq(minter)).key; @@ -4479,7 +4478,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. @@ -5118,7 +5117,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite } { // Minter attempts to sell the token for XPB 10, which they - // have no trust line for and buyer has kNONE of (sellside). + // have no trust line for and buyer has kNone of (sellside). reinitializeTrustLineBalances(); auto const nftID = mintNFT(minter); auto const offerID = createSellOffer(minter, nftID, gwXPB(10)); @@ -5129,7 +5128,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite } { // Minter attempts to sell the token for XPB 10, which they - // have no trust line for and buyer has kNONE of (buyside). + // have no trust line for and buyer has kNone of (buyside). reinitializeTrustLineBalances(); auto const nftID = mintNFT(minter); auto const offerID = createBuyOffer( @@ -6091,7 +6090,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]; @@ -6111,7 +6111,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]; @@ -6149,7 +6150,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]; @@ -6355,7 +6357,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite BEAST_EXPECT(ownerCount(env, bob) == 0); - // Send bob an kINCREMENT reserve and base fee (to make up for + // Send bob an kIncrement reserve and base fee (to make up for // the transaction fee burnt from the prev failed tx) Bob now // owns 250,000,000 drops env(pay(env.master, bob, incReserve + drops(baseFee))); @@ -6484,8 +6486,8 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite env.fund(XRP(10000), alice); env.close(); - // Bob is funded with account reserve + kINCREMENT reserve + 1 XRP - // kINCREMENT reserve is for the buy offer, and 1 XRP is for offer + // Bob is funded with account reserve + kIncrement reserve + 1 XRP + // kIncrement reserve is for the buy offer, and 1 XRP is for offer // price env.fund(acctReserve + incReserve + XRP(1), bob); env.close(); @@ -6950,7 +6952,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite // Invalid URI length > 256 env(token::modify(issuer, nftId), - token::Uri(std::string(kMAX_TOKEN_URI_LENGTH + 1, 'q')), + token::Uri(std::string(kMaxTokenUriLength + 1, 'q')), Ter(temMALFORMED)); env.close(); } @@ -7180,7 +7182,7 @@ public: { testWithFeats( allFeatures_ - fixNFTokenReserve - featureNFTokenMintOffer - featureDynamicNFT - - fixSecurity3_1_3); + fixCleanup3_1_3); } }; @@ -7217,7 +7219,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/NetworkID_test.cpp b/src/test/app/NetworkID_test.cpp index a98fbd6b4f..677d8f166d 100644 --- a/src/test/app/NetworkID_test.cpp +++ b/src/test/app/NetworkID_test.cpp @@ -37,7 +37,7 @@ public: { using namespace jtx; return envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = networkID; + cfg->networkId = networkID; return cfg; }); } 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 7fbf042fca..17fb8edf38 100644 --- a/src/test/app/OfferMPT_test.cpp +++ b/src/test/app/OfferMPT_test.cpp @@ -522,9 +522,9 @@ public: // carol's offer can be partially crossed when EUR is IOU: // 10e-3EUR/1USD using tEUR = std::decay_t; - bool constexpr kIS_EURIOU = std::is_same_v; + static constexpr bool kIsEuriou = std::is_same_v; // partially crossed if IOU, removed but not taken if MPT - auto const balanceCarolUSD = kIS_EURIOU ? usd(0) : initialCarolUSD; + auto const balanceCarolUSD = kIsEuriou ? usd(0) : initialCarolUSD; env.require(offers(carol, 0), Balance(carol, balanceCarolUSD)); if (crossBothOffers) @@ -535,7 +535,7 @@ public: else { // partially crossed if IOU, not crossed if MPT - auto const balanceAliceUSD = kIS_EURIOU ? usd(1) : usd(0); + auto const balanceAliceUSD = kIsEuriou ? usd(1) : usd(0); env.require(offers(alice, 1), Balance(alice, balanceAliceUSD)); } } @@ -590,9 +590,9 @@ public: // carol's offer can be partially crossed when EUR is IOU: // 10e-3EUR/1USD using tEUR = std::decay_t; - bool constexpr kIS_EURIOU = std::is_same_v; + static constexpr bool kIsEuriou = std::is_same_v; // partially crossed if IOU, removed but not taken if MPT - auto const balanceCarolUSD = kIS_EURIOU ? usd(0) : initialCarolUSD; + auto const balanceCarolUSD = kIsEuriou ? usd(0) : initialCarolUSD; env.require(offers(carol, 0)); env.require(Balance(carol, balanceCarolUSD)); } @@ -784,7 +784,7 @@ public: Owners(alice, 1), offers(alice, 0), Balance(bob, startBalance - (f * 2)), - Balance(bob, usd(kNONE)), + Balance(bob, usd(kNone)), Owners(bob, 1), offers(bob, 1)); @@ -973,7 +973,7 @@ public: // Offers with negative amounts { - env(offer(alice, -usd(1'000), XRP(1'000)), Ter(temBAD_OFFER)); + env(offer(alice, -usd(1'000), XRP(1'000)), Ter(temBAD_AMOUNT)); env.require(Owners(alice, 1), offers(alice, 0)); } @@ -1057,7 +1057,7 @@ public: offers(alice, 0), Owners(alice, 1), Balance(bob, startBalance - f), - Balance(bob, usd(kNONE)), + Balance(bob, usd(kNone)), offers(bob, 1), Owners(bob, 1)); } @@ -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); @@ -1759,7 +1764,7 @@ public: env.require(Owners(alice, 2)); env.require(Balance(carol, usd(0))); - env.require(Balance(carol, eur(kNONE))); + env.require(Balance(carol, eur(kNone))); env.require(offers(carol, 0)); env.require(Owners(carol, 1)); @@ -1969,7 +1974,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"); @@ -2302,8 +2308,8 @@ public: env.close(); env.require(Balance(alice, usd(1'000))); - env.require(Balance(alice, eur(kNONE))); - env.require(Balance(bob, usd(kNONE))); + env.require(Balance(alice, eur(kNone))); + env.require(Balance(bob, usd(kNone))); env.require(Balance(bob, eur(1'000))); env.require(offers(alice, 0)); env.require(offers(bob, 0)); @@ -2660,7 +2666,7 @@ public: // alice submits a tfSell | tfFillOrKill offer that does not cross. env(offer(alice, usd(21), XRP(2'100), tfSell | tfFillOrKill), Ter(tecKILLED)); env.close(); - env.require(Balance(alice, usd(kNONE))); + env.require(Balance(alice, usd(kNone))); env.require(offers(alice, 0)); env.require(Balance(bob, usd(100))); } @@ -2757,7 +2763,7 @@ public: // USD(125) was removed from his account due to the gateway fee. // // A comparable payment would look like this: - // env (pay (bob, alice, USD(100)), sendmax(USD(125))) + // env (pay (bob, alice, USD(100)), Sendmax(USD(125))) env(offer(bob, XRP(1), usd(10'000))); env.close(); @@ -3005,6 +3011,92 @@ public: } }; testHelper2TokensMix(test); + + // Payment trIn: MPT transfer fee must be charged when the payment + // destination is the MPT issuer and MPT crosses the DEX (1-hop). + // Bug: rate() returned parity because strandDst_ == MPT issuer. + // Fix: parity only when this asset IS the final delivered asset. + { + auto const gw = Account("gw_tr1"); + auto const alice = Account("alice_tr1"); + auto const bob = Account("bob_tr1"); + + Env env{*this, features}; + env.fund(XRP(10'000), gw, alice, bob); + env.close(); + + MPT const usd = MPTTester( + {.env = env, .issuer = gw, .holders = {alice, bob}, .transferFee = 25'000}); + + // alice needs MPT(1250): MPT(1000) to bob's offer + MPT(250) transfer fee (25%) + env(pay(gw, alice, usd(1'250))); + // bob's offer: give XRP(1000), want MPT(1000) + env(offer(bob, usd(1'000), XRP(1'000))); + env.close(); + + // alice pays gw (MPT issuer) XRP(1000) using MPT as source + // strand: alice -> [MPT/XRP BookStep] -> gw + // strandDst_ = gw = MPT issuer, strandDeliver_ = XRP + // trIn = rate(MPT, gw): fix charges 25% (MPT != strandDeliver_) + env(pay(alice, gw, XRP(1'000)), Path(~XRP), Sendmax(usd(1'250))); + env.close(); + + // alice consumed all MPT(1250): MPT(1000) to bob + MPT(250) fee + BEAST_EXPECT(env.balance(alice, usd) == usd(0)); + // bob received MPT(1000) net + BEAST_EXPECT(env.balance(bob, usd) == usd(1'000)); + } + + // Payment trIn (2-hop): MPT transfer fee must be charged when MPT is + // intermediate and the destination is the MPT issuer. + // BookStep2(MPT/XRP) prevStep=BookStep1 returns redeems direction + // (ownerPaysTransferFee_=false for Payment), so trIn applies. + // Bug: parity because strandDst_ == MPT issuer. + // Fix: 25% fee because MPT != strandDeliver_(XRP). + { + auto const gw = Account("gw_tr2"); + auto const gw2 = Account("gw2_tr2"); + auto const alice = Account("alice_tr2"); + auto const bob = Account("bob_tr2"); + auto const carol = Account("carol_tr2"); + + Env env{*this, features}; + env.fund(XRP(10'000), gw, gw2, alice, bob, carol); + env.close(); + + MPT const musd = MPTTester( + {.env = env, .issuer = gw, .holders = {bob, carol}, .transferFee = 25'000}); + auto const gusd = gw2["USD"]; + + env(trust(alice, gusd(10'000))); + env(trust(bob, gusd(10'000))); + env.close(); + + env(pay(gw2, alice, gusd(1'000))); + env(pay(gw, bob, musd(1'000))); + env.close(); + + // bob's offer: give MPT(1000), want GUSD(1000) + env(offer(bob, gusd(1'000), musd(1'000))); + // carol's offer: give XRP(800), want MPT(800) + env(offer(carol, musd(800), XRP(800))); + env.close(); + + // Payment: alice GUSD -> [BookStep1: GUSD/MUSD] -> [BookStep2: MUSD/XRP] -> gw XRP + // strandDst_ = gw = MPT issuer, strandDeliver_ = XRP + // BookStep2 trIn: fix = 1.25 -> upstream needs MUSD(1000) for carol's MUSD(800) offer + // => alice must provide full GUSD(1000) to bob's offer; without fix alice only pays + // GUSD(800) + env(pay(alice, gw, XRP(800)), Path(~musd), Sendmax(gusd(1'000))); + env.close(); + + // alice spent all GUSD(1000); bug would leave GUSD(200) unspent + BEAST_EXPECT(env.balance(alice, gusd) == gusd(0)); + // bob gave MPT(1000) and received GUSD(1000) + BEAST_EXPECT(env.balance(bob, musd) == musd(0)); + // carol received MPT(800) net (MPT(200) went to gw as fee) + BEAST_EXPECT(env.balance(carol, musd) == musd(800)); + } } void @@ -3432,14 +3524,14 @@ public: .token = "JPY", .issuer = gw, .holders = {alice}, - .limit = kMAX_MP_TOKEN_AMOUNT, + .limit = kMaxMpTokenAmount, .transferFee = 2'000}); auto const btc = issue2( {.env = env, .token = "BTC", .issuer = gw, .holders = {bob}, - .limit = kMAX_MP_TOKEN_AMOUNT, + .limit = kMaxMpTokenAmount, .transferFee = 2'000}); env(pay(gw, alice, jpy(3'699'034'802'280'317))); @@ -3852,7 +3944,7 @@ public: // GW requires authorization for holders of its IOUs auto gwMUSD = - MPTTester({.env = env, .issuer = gw, .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth}); + MPTTester({.env = env, .issuer = gw, .flags = kMptDexFlags | tfMPTRequireAuth}); MPT const gwUSD = gwMUSD; // Have gw authorize bob and alice @@ -3911,7 +4003,7 @@ public: env.close(); auto gwMUSD = - MPTTester({.env = env, .issuer = gw, .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth}); + MPTTester({.env = env, .issuer = gw, .flags = kMptDexFlags | tfMPTRequireAuth}); MPT const gwUSD = gwMUSD; // alice can't create an offer because alice doesn't own @@ -3920,7 +4012,7 @@ public: env.close(); env.require(offers(alice, 0)); - env.require(Balance(alice, gwUSD(kNONE))); + env.require(Balance(alice, gwUSD(kNone))); gwMUSD.authorize({.account = bob}); gwMUSD.authorize({.account = gw, .holder = bob}); @@ -3991,7 +4083,7 @@ public: env.close(); auto gwMUSD = - MPTTester({.env = env, .issuer = gw, .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth}); + MPTTester({.env = env, .issuer = gw, .flags = kMptDexFlags | tfMPTRequireAuth}); MPT const gwUSD = gwMUSD; // Test that gw can create an offer to buy gw's currency. @@ -4700,6 +4792,101 @@ public: } } + void + testAutoCreateReserve(FeatureBitset features) + { + // When an offer on the book is partially crossed, the payment engine + // auto-creates a new ledger object (MPToken or IOU trustline) for the + // offer owner to hold the incoming asset. This happens inside + // BookStep::forEachOffer (MPT: checkCreateMPT) and BookStep::consumeOffer + // (IOU: directSendNoFeeIOU -> trustCreate) without a reserve sufficiency + // check. The offer owner can therefore end up with more objects than + // their XRP balance can reserve for, consistent with IOU behavior. + + testcase("Auto-Create Object Without Reserve Check During Partial Crossing"); + + using namespace jtx; + + auto const gw = Account{"gateway"}; + auto const alice = Account{"alice"}; + auto const carol = Account{"carol"}; + auto const bob = Account{"bob"}; + + auto test = [&](auto&& getToken, auto&& execTx) { + // MPT/IOU: carol's existing offer buys MPT/IOU by selling XRP. + // carol has no MPToken/Trustline for this issuance. When alice partially crosses + // carol's offer, an MPToken/Trustline is auto-created for carol without checking + // that she can afford the extra reserve slot. + Env env{*this, features}; + + auto const f = env.current()->fees().base; + auto const r = reserve(env, 0); + auto const inc = reserve(env, 1) - r; + + env.fund(XRP(10'000), gw, alice, bob); + + // getToken: + // - Create MPT with CanTransfer + CanTrade; authorize alice as holder. + // - Create IOU trustline + auto const token = getToken(env); + + // carol: reserve(0) + 1 increment + fee covers placing one offer. + // After the offer tx she has exactly reserve(1) + XRP(30). + // XRP(30) < inc (50 XRP), so receiving a second object will put her + // below reserve(2). + if (BEAST_EXPECT(inc > XRP(30))) + env.fund(r + inc + f + XRP(30), carol); + + // carol's offer goes on the book (no counterpart yet). + // TakerPays=Token(30): carol will receive Token when crossed. + // TakerGets=XRP(30): carol will give XRP when crossed. + env(offer(carol, token(30), XRP(30))); + env.require(Owners(carol, 1)); + + // Execute offer create or cross-currency payment + // alice partially crosses carol's offer. + // alice sends Token(15) to carol and receives XRP(15). + // Token: + // - MPT: checkCreateMPT auto-creates an MPToken for carol (no reserve check). + // - IOU: directSendNoFeeIOU auto-creates an Trustline for carol (no reserve check). + execTx(env, token); + + // Carol now owns 2 objects (remaining offer + new MPToken) even + // though her XRP balance is only reserve(1) + XRP(15), which is + // below reserve(2) = reserve(1) + inc. + auto const carolBalance = r + inc + XRP(15); + env.require(Owners(carol, 2), Balance(carol, token(15)), Balance(carol, carolBalance)); + BEAST_EXPECT(carolBalance < r + 2 * inc); // below reserve(2) + }; + std::function const getIOU = [&](Env& env) -> PrettyAsset { + env.trust(gw["USD"](1'000), alice); + env(pay(gw, alice, gw["USD"](100))); + return gw["USD"]; + }; + std::function const getMPT = [&](Env& env) -> PrettyAsset { + MPT const mpT1 = MPTTester({.env = env, .issuer = gw, .holders = {alice}, .pay = 100}); + return mpT1; + }; + for (auto&& getToken : {getIOU, getMPT}) + { + test(getToken, [&](Env& env, PrettyAsset const& token) { + // alice partially crosses carol's offer. + // alice sends Token(15) to carol and receives XRP(15). + // Token is MPT: checkCreateMPT auto-creates an MPToken for carol (no reserve + // check). Token is IOU: directSendNoFeeIOU auto-creates a trustline for carol (no + // reserve check). + env(offer(alice, XRP(15), token(15))); + }); + test(getToken, [&](Env& env, PrettyAsset const& token) { + // Similar to above but with cross-currency payment. + env(pay(alice, bob, XRP(15)), + Sendmax(token(15)), + Path(~XRP), + Txflags(tfNoRippleDirect | tfPartialPayment)); + }); + } + } + void testAll(FeatureBitset features) { @@ -4756,14 +4943,15 @@ public: testRmSmallIncreasedQOffersMPT(features); testFillOrKill(features); testTickSize(features); + testAutoCreateReserve(features); } void run() override { using namespace jtx; - static FeatureBitset const kALL{testableAmendments()}; - testAll(kALL); + static FeatureBitset const kAll{testableAmendments()}; + testAll(kAll); } }; diff --git a/src/test/app/Offer_test.cpp b/src/test/app/Offer_test.cpp index dbedfc61a3..1716f84c7a 100644 --- a/src/test/app/Offer_test.cpp +++ b/src/test/app/Offer_test.cpp @@ -260,7 +260,7 @@ public: for (int i = 0; i < 101; ++i) env(offer(carol, usd(1), eur(2))); - env(pay(alice, bob, eur(kEPSILON)), Path(~eur), Sendmax(usd(100))); + env(pay(alice, bob, eur(kEpsilon)), Path(~eur), Sendmax(usd(100))); } void @@ -818,7 +818,7 @@ public: Owners(alice, 1), offers(alice, 0), Balance(bob, startBalance - (f * 2)), - Balance(bob, usd(kNONE)), + Balance(bob, usd(kNone)), Owners(bob, 1), offers(bob, 1)); @@ -1128,7 +1128,7 @@ public: offers(alice, 0), Owners(alice, 1), Balance(bob, startBalance - f), - Balance(bob, usd(kNONE)), + Balance(bob, usd(kNone)), offers(bob, 1), Owners(bob, 1)); } @@ -1239,7 +1239,7 @@ public: BEAST_EXPECT(isOffer(env, accountToTest, XRP(1000), usd(50))); // now make an offer that will cross and auto-bridge, meaning - // the outstanding offers will be taken leaving us with kNONE + // the outstanding offers will be taken leaving us with kNone env(offer(accountToTest, usd(50), btc(250))); auto jrr = getBookOffers(env, usd, btc); @@ -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()); } @@ -1902,7 +1907,7 @@ public: env.require(Owners(alice, 2)); env.require(Balance(carol, usd(0))); - env.require(Balance(carol, eur(kNONE))); + env.require(Balance(carol, eur(kNone))); env.require(offers(carol, 0)); env.require(Owners(carol, 1)); @@ -2133,7 +2138,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"); @@ -2513,8 +2519,8 @@ public: env.close(); env.require(Balance(alice, usd(1000))); - env.require(Balance(alice, eur(kNONE))); - env.require(Balance(bob, usd(kNONE))); + env.require(Balance(alice, eur(kNone))); + env.require(Balance(bob, usd(kNone))); env.require(Balance(bob, eur(1000))); env.require(offers(alice, 0)); env.require(offers(bob, 0)); @@ -2859,7 +2865,7 @@ public: // alice submits a tfSell | tfFillOrKill offer that does not cross. env(offer(alice, usd(21), XRP(2100), tfSell | tfFillOrKill), Ter(killedCode)); env.close(); - env.require(Balance(alice, usd(kNONE))); + env.require(Balance(alice, usd(kNone))); env.require(offers(alice, 0)); env.require(Balance(bob, usd(100))); } @@ -3134,14 +3140,14 @@ public: env(pay(kim, meg, nBux(60)), Path(lex, ned), Sendmax(kBux(200))); env.close(); - env.require(Balance(kim, kBux(kNONE))); - env.require(Balance(kim, nBux(kNONE))); + env.require(Balance(kim, kBux(kNone))); + env.require(Balance(kim, nBux(kNone))); env.require(Balance(lex, kBux(72))); env.require(Balance(lex, nBux(40))); - env.require(Balance(meg, kBux(kNONE))); + env.require(Balance(meg, kBux(kNone))); env.require(Balance(meg, nBux(60))); - env.require(Balance(ned, kBux(kNONE))); - env.require(Balance(ned, nBux(kNONE))); + env.require(Balance(ned, kBux(kNone))); + env.require(Balance(ned, nBux(kNone))); // Now verify that offer crossing is unaffected by QualityOut. env(offer(lex, kBux(30), nBux(30))); @@ -3150,14 +3156,14 @@ public: env(offer(kim, nBux(30), kBux(30))); env.close(); - env.require(Balance(kim, kBux(kNONE))); + env.require(Balance(kim, kBux(kNone))); env.require(Balance(kim, nBux(30))); env.require(Balance(lex, kBux(102))); env.require(Balance(lex, nBux(10))); - env.require(Balance(meg, kBux(kNONE))); + env.require(Balance(meg, kBux(kNone))); env.require(Balance(meg, nBux(60))); env.require(Balance(ned, kBux(-30))); - env.require(Balance(ned, nBux(kNONE))); + env.require(Balance(ned, nBux(kNone))); } { // Make sure things work right when we're auto-bridging as well. @@ -3490,14 +3496,14 @@ public: env(pay(ann, cam, dBux(60)), Path(bob, dan), Sendmax(aBux(200))); env.close(); - env.require(Balance(ann, aBux(kNONE))); - env.require(Balance(ann, dBux(kNONE))); + env.require(Balance(ann, aBux(kNone))); + env.require(Balance(ann, dBux(kNone))); env.require(Balance(bob, aBux(72))); env.require(Balance(bob, dBux(40))); - env.require(Balance(cam, aBux(kNONE))); + env.require(Balance(cam, aBux(kNone))); env.require(Balance(cam, dBux(60))); - env.require(Balance(dan, aBux(kNONE))); - env.require(Balance(dan, dBux(kNONE))); + env.require(Balance(dan, aBux(kNone))); + env.require(Balance(dan, dBux(kNone))); env(offer(bob, aBux(30), dBux(30))); env.close(); @@ -3512,14 +3518,14 @@ public: Ter(temBAD_PATH)); env.close(); - env.require(Balance(ann, aBux(kNONE))); + env.require(Balance(ann, aBux(kNone))); env.require(Balance(ann, dBux(0))); env.require(Balance(bob, aBux(72))); env.require(Balance(bob, dBux(40))); - env.require(Balance(cam, aBux(kNONE))); + env.require(Balance(cam, aBux(kNone))); env.require(Balance(cam, dBux(60))); env.require(Balance(dan, aBux(0))); - env.require(Balance(dan, dBux(kNONE))); + env.require(Balance(dan, dBux(kNone))); } } @@ -4215,7 +4221,7 @@ public: env.close(); env.require(offers(alice, 1)); - env.require(Balance(alice, gwUSD(kNONE))); + env.require(Balance(alice, gwUSD(kNone))); env(fset(gw, asfRequireAuth)); env.close(); @@ -4239,7 +4245,7 @@ public: env.require(offers(alice, 0)); // alice's unauthorized offer is deleted & bob's offer not crossed. - env.require(Balance(alice, gwUSD(kNONE))); + env.require(Balance(alice, gwUSD(kNone))); env.require(offers(bob, 1)); env.require(Balance(bob, gwUSD(50))); @@ -4250,7 +4256,7 @@ public: env.close(); env.require(offers(alice, 0)); - env.require(Balance(alice, gwUSD(kNONE))); + env.require(Balance(alice, gwUSD(kNone))); env.require(offers(bob, 1)); env.require(Balance(bob, gwUSD(50))); @@ -4564,25 +4570,25 @@ public: env.close(); auto txn = noop(gw); - txn[sfTickSize.fieldName] = Quality::kMIN_TICK_SIZE - 1; + txn[sfTickSize.fieldName] = Quality::kMinTickSize - 1; env(txn, Ter(temBAD_TICK_SIZE)); - txn[sfTickSize.fieldName] = Quality::kMIN_TICK_SIZE; + txn[sfTickSize.fieldName] = Quality::kMinTickSize; env(txn); - BEAST_EXPECT((*env.le(gw))[sfTickSize] == Quality::kMIN_TICK_SIZE); + BEAST_EXPECT((*env.le(gw))[sfTickSize] == Quality::kMinTickSize); txn = noop(gw); - txn[sfTickSize.fieldName] = Quality::kMAX_TICK_SIZE; + txn[sfTickSize.fieldName] = Quality::kMaxTickSize; env(txn); BEAST_EXPECT(!env.le(gw)->isFieldPresent(sfTickSize)); txn = noop(gw); - txn[sfTickSize.fieldName] = Quality::kMAX_TICK_SIZE - 1; + txn[sfTickSize.fieldName] = Quality::kMaxTickSize - 1; env(txn); - BEAST_EXPECT((*env.le(gw))[sfTickSize] == Quality::kMAX_TICK_SIZE - 1); + BEAST_EXPECT((*env.le(gw))[sfTickSize] == Quality::kMaxTickSize - 1); txn = noop(gw); - txn[sfTickSize.fieldName] = Quality::kMAX_TICK_SIZE + 1; + txn[sfTickSize.fieldName] = Quality::kMaxTickSize + 1; env(txn, Ter(temBAD_TICK_SIZE)); txn[sfTickSize.fieldName] = 0; diff --git a/src/test/app/Oracle_test.cpp b/src/test/app/Oracle_test.cpp index 84ef568d52..7e7f5e9bd0 100644 --- a/src/test/app/Oracle_test.cpp +++ b/src/test/app/Oracle_test.cpp @@ -286,7 +286,7 @@ private: .err = Ter(tecINVALID_UPDATE_TIME)}); oracle.set(UpdateArg{.series = {{"XRP", "USD", 740, 1}}, .fee = baseFee}); BEAST_EXPECT(oracle.expectLastUpdateTime( - static_cast(kTEST_START_TIME.count() + 450))); + static_cast(kTestStartTime.count() + 450))); // Less than the previous lastUpdateTime oracle.set( UpdateArg{ @@ -298,7 +298,7 @@ private: oracle.set( UpdateArg{ .series = {{"XRP", "USD", 740, 1}}, - .lastUpdateTime = static_cast(kEPOCH_OFFSET.count() - 1), + .lastUpdateTime = static_cast(kEpochOffset.count() - 1), .fee = baseFee, .err = Ter(tecINVALID_UPDATE_TIME)}); } @@ -344,7 +344,7 @@ private: Oracle const oracle( env, {.owner = owner, - .series = {{"USD", "BTC", 740, kMAX_PRICE_SCALE + 1}}, + .series = {{"USD", "BTC", 740, kMaxPriceScale + 1}}, .fee = baseFee, .err = Ter(temMALFORMED)}); } @@ -748,7 +748,7 @@ private: .series = {{"XRP", "USD", 741, 1}}, .msig = Msig(becky, bogie), .fee = baseFee}); BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 741, 1}})); // remove the signer list - env(signers(alice, jtx::kNONE), Sig(alie)); + env(signers(alice, jtx::kNone), Sig(alie)); env.close(); env.require(Owners(alice, 1)); // create new signer list diff --git a/src/test/app/PathMPT_test.cpp b/src/test/app/PathMPT_test.cpp index ef8aa587f8..3ba67b58a6 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"; @@ -87,9 +87,9 @@ class PathMPT_test : public beast::unit_test::Suite // with the search parameters that the tests were written for. using namespace jtx; return Env(*this, envconfig([](std::unique_ptr cfg) { - cfg->PATH_SEARCH_OLD = 7; - cfg->PATH_SEARCH = 7; - cfg->PATH_SEARCH_MAX = 10; + cfg->pathSearchOld = 7; + cfg->pathSearch = 7; + cfg->pathSearchMax = 10; return cfg; })); } @@ -112,7 +112,7 @@ public: MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt = 100}); auto& app = env.app(); - Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; + Resource::Charge loadType = Resource::kFeeReferenceRpc; Resource::Consumer c; RPC::JsonContext context{ @@ -125,15 +125,15 @@ public: .role = Role::USER, .coro = {}, .infoSub = {}, - .apiVersion = RPC::kAPI_VERSION_IF_UNSPECIFIED}, + .apiVersion = RPC::kApiVersionIfUnspecified}, {}, {}}; json::Value result; Gate g; // Test RPC::Tuning::max_src_cur source currencies. std::vector numSrc; - numSrc.reserve(RPC::Tuning::kMAX_SRC_CUR); - for (std::uint8_t i = 0; i < RPC::Tuning::kMAX_SRC_CUR; ++i) + numSrc.reserve(RPC::Tuning::kMaxSrcCur); + for (std::uint8_t i = 0; i < RPC::Tuning::kMaxSrcCur; ++i) numSrc.push_back(makeMptID(i, bob)); app.getJobQueue().postCoro(JtClient, "RPC-Client", [&](auto const& coro) { context.params = xrpl::test::detail::rpf(alice, bob, usd, numSrc); @@ -145,7 +145,7 @@ public: BEAST_EXPECT(!result.isMember(jss::error)); // Test more than RPC::Tuning::max_src_cur source currencies. - numSrc.push_back(makeMptID(RPC::Tuning::kMAX_SRC_CUR, bob)); + numSrc.push_back(makeMptID(RPC::Tuning::kMaxSrcCur, bob)); app.getJobQueue().postCoro(JtClient, "RPC-Client", [&](auto const& coro) { context.params = xrpl::test::detail::rpf(alice, bob, usd, numSrc); context.coro = coro; @@ -157,7 +157,7 @@ public: // Test RPC::Tuning::max_auto_src_cur source currencies. numSrc.clear(); - for (auto i = 0; i < (RPC::Tuning::kMAX_AUTO_SRC_CUR - 1); ++i) + for (auto i = 0; i < (RPC::Tuning::kMaxAutoSrcCur - 1); ++i) { auto curm = MPTTester({.env = env, .issuer = alice, .holders = {bob}}); numSrc.push_back(curm.issuanceID()); diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp index 9424bc05bf..4cfe938798 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; @@ -101,9 +101,9 @@ class Path_test : public beast::unit_test::Suite // with the search parameters that the tests were written for. using namespace jtx; return Env(*this, envconfig([](std::unique_ptr cfg) { - cfg->PATH_SEARCH_OLD = 7; - cfg->PATH_SEARCH = 7; - cfg->PATH_SEARCH_MAX = 10; + cfg->pathSearchOld = 7; + cfg->pathSearch = 7; + cfg->pathSearchMax = 10; return cfg; })); } @@ -151,7 +151,7 @@ public: using namespace jtx; auto& app = env.app(); - Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; + Resource::Charge loadType = Resource::kFeeReferenceRpc; Resource::Consumer c; RPC::JsonContext context{ @@ -164,21 +164,21 @@ public: .role = Role::USER, .coro = {}, .infoSub = {}, - .apiVersion = RPC::kAPI_VERSION_IF_UNSPECIFIED}, + .apiVersion = RPC::kApiVersionIfUnspecified}, {}, {}}; - 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); } @@ -216,7 +216,7 @@ public: STAmount da; if (result.isMember(jss::destination_amount)) - da = amountFromJson(kSF_GENERIC, result[jss::destination_amount]); + da = amountFromJson(sfGeneric, result[jss::destination_amount]); STAmount sa; STPathSet paths; @@ -228,10 +228,10 @@ public: auto const& path = alts[0u]; if (path.isMember(jss::source_amount)) - sa = amountFromJson(kSF_GENERIC, path[jss::source_amount]); + sa = amountFromJson(sfGeneric, path[jss::source_amount]); if (path.isMember(jss::destination_amount)) - da = amountFromJson(kSF_GENERIC, path[jss::destination_amount]); + da = amountFromJson(sfGeneric, path[jss::destination_amount]); if (path.isMember(jss::paths_computed)) { @@ -262,7 +262,7 @@ public: env.close(); auto& app = env.app(); - Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; + Resource::Charge loadType = Resource::kFeeReferenceRpc; Resource::Consumer c; RPC::JsonContext context{ @@ -275,14 +275,14 @@ public: .role = Role::USER, .coro = {}, .infoSub = {}, - .apiVersion = RPC::kAPI_VERSION_IF_UNSPECIFIED}, + .apiVersion = RPC::kApiVersionIfUnspecified}, {}, {}}; json::Value result; Gate g; // Test RPC::Tuning::max_src_cur source currencies. app.getJobQueue().postCoro(JtClient, "RPC-Client", [&](auto const& coro) { - context.params = rpf(Account("alice"), Account("bob"), RPC::Tuning::kMAX_SRC_CUR); + context.params = rpf(Account("alice"), Account("bob"), RPC::Tuning::kMaxSrcCur); context.coro = coro; RPC::doCommand(context, result); g.signal(); @@ -292,7 +292,7 @@ public: // Test more than RPC::Tuning::max_src_cur source currencies. app.getJobQueue().postCoro(JtClient, "RPC-Client", [&](auto const& coro) { - context.params = rpf(Account("alice"), Account("bob"), RPC::Tuning::kMAX_SRC_CUR + 1); + context.params = rpf(Account("alice"), Account("bob"), RPC::Tuning::kMaxSrcCur + 1); context.coro = coro; RPC::doCommand(context, result); g.signal(); @@ -301,7 +301,7 @@ public: BEAST_EXPECT(result.isMember(jss::error)); // Test RPC::Tuning::max_auto_src_cur source currencies. - for (auto i = 0; i < (RPC::Tuning::kMAX_AUTO_SRC_CUR - 1); ++i) + for (auto i = 0; i < (RPC::Tuning::kMaxAutoSrcCur - 1); ++i) env.trust(Account("alice")[std::to_string(i + 100)](100), "bob"); app.getJobQueue().postCoro(JtClient, "RPC-Client", [&](auto const& coro) { context.params = rpf(Account("alice"), Account("bob"), 0); @@ -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..b81afa830e 100644 --- a/src/test/app/PayChan_test.cpp +++ b/src/test/app/PayChan_test.cpp @@ -246,7 +246,7 @@ struct PayChan_test : public beast::unit_test::Suite BEAST_EXPECT(!channelExists(*env.current(), chan)); auto const feeDrops = env.current()->fees().base; auto const delta = chanAmt - chanBal; - assert(delta > beast::kZERO); + assert(delta > beast::kZero); BEAST_EXPECT(env.balance(alice) == preAlice + delta); BEAST_EXPECT(env.balance(bob) == preBob - feeDrops); } @@ -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"; @@ -1916,7 +1916,7 @@ struct PayChan_test : public beast::unit_test::Suite STAmount const reqAmt = authAmt + drops(1); assert(reqAmt <= chanAmt); // Note that since claim() returns a tem (neither tec nor tes), - // the ticket is not consumed. So we don't kINCREMENT bobTicket. + // the ticket is not consumed. So we don't kIncrement bobTicket. auto const sig = signClaimAuth(alice.pk(), alice.sk(), chan, authAmt); env(claim(bob, chan, reqAmt, authAmt, Slice(sig), alice.pk()), ticket::Use(bobTicketSeq), @@ -1951,7 +1951,7 @@ struct PayChan_test : public beast::unit_test::Suite BEAST_EXPECT(!channelExists(*env.current(), chan)); auto const feeDrops = env.current()->fees().base; auto const delta = chanAmt - chanBal; - assert(delta > beast::kZERO); + assert(delta > beast::kZero); BEAST_EXPECT(env.balance(alice) == preAlice + delta); BEAST_EXPECT(env.balance(bob) == preBob - feeDrops); } diff --git a/src/test/app/PayStrandMPT_test.cpp b/src/test/app/PayStrandMPT_test.cpp index 5550a26ab2..20e582fbf7 100644 --- a/src/test/app/PayStrandMPT_test.cpp +++ b/src/test/app/PayStrandMPT_test.cpp @@ -328,7 +328,7 @@ struct PayStrandMPT_test : public beast::unit_test::Suite {.env = env, .issuer = gw, .holders = {alice, bob}, - .flags = kMPT_DEX_FLAGS | tfMPTCanLock, + .flags = kMptDexFlags | tfMPTCanLock, .maxAmt = 1'000}); MPT const usd = usdm; env(pay(gw, alice, usd(100))); @@ -361,7 +361,7 @@ struct PayStrandMPT_test : public beast::unit_test::Suite auto usdm = MPTTester( {.env = env, .issuer = gw, - .flags = kMPT_DEX_FLAGS | tfMPTRequireAuth, + .flags = kMptDexFlags | tfMPTRequireAuth, .maxAmt = 1'000}); MPT const usd = usdm; diff --git a/src/test/app/PayStrand_test.cpp b/src/test/app/PayStrand_test.cpp index 78b152d690..67a37833b2 100644 --- a/src/test/app/PayStrand_test.cpp +++ b/src/test/app/PayStrand_test.cpp @@ -308,12 +308,12 @@ struct ExistingElementPool currencyNames.clear(); currencyNames.reserve(numCur); - constexpr size_t kBUF_SIZE = 32; - char buf[kBUF_SIZE]; + static constexpr size_t kBufSize = 32; + char buf[kBufSize]; for (size_t id = 0; id < numAct; ++id) { - snprintf(buf, kBUF_SIZE, "A%zu", id); + snprintf(buf, kBufSize, "A%zu", id); accounts.emplace_back(buf); } @@ -321,15 +321,15 @@ struct ExistingElementPool { if (id < 10) { - snprintf(buf, kBUF_SIZE, "CC%zu", id); + snprintf(buf, kBufSize, "CC%zu", id); } else if (id < 100) { - snprintf(buf, kBUF_SIZE, "C%zu", id); + snprintf(buf, kBufSize, "C%zu", id); } else { - snprintf(buf, kBUF_SIZE, "%zu", id); + snprintf(buf, kBufSize, "%zu", id); } currencies.emplace_back(toCurrency(buf)); currencyNames.emplace_back(buf); diff --git a/src/test/app/PermissionedDEX_test.cpp b/src/test/app/PermissionedDEX_test.cpp index a0b16aa557..c6e94d7994 100644 --- a/src/test/app/PermissionedDEX_test.cpp +++ b/src/test/app/PermissionedDEX_test.cpp @@ -7,6 +7,9 @@ #include #include #include +#include +#include +#include #include #include // IWYU pragma: keep #include @@ -34,6 +37,7 @@ #include #include #include +#include #include #include @@ -140,7 +144,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite static uint256 getBookDirKey(Book const& book, STAmount const& takerPays, STAmount const& takerGets) { - return keylet::quality(keylet::kBOOK(book), getRate(takerGets, takerPays)).key; + return keylet::quality(keylet::kBook(book), getRate(takerGets, takerPays)).key; } static std::optional @@ -1392,13 +1396,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 +1428,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 +1440,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,13 +1452,318 @@ 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)); } } + void + testHybridOfferCrossingQuality(FeatureBitset features) + { + bool const fixEnabled = features[fixCleanup3_2_0]; + testcase << "Hybrid offer crossing quality" + << (fixEnabled ? " (fixCleanup3_2_0)" : " (pre-fix)"); + + // Partially-crossed hybrid offer should have consistent quality + // across both book directories. + // + // Steps: + // - Bob places a hybrid offer. + // - Alice places an opposing hybrid offer that partially crosses. + // + // Verify: + // - Domain-book key quality == its sfExchangeRate. + // - Post-fix: open-book key quality == domain-book key quality. + // - Pre-fix: open-book key quality != domain-book key quality + // (key used post-crossing rate, sfExchangeRate used pre-crossing). + + Env env(*this, features); + auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] = + PermissionedDEX(env); + + // Bob places a hybrid offer: TakerPays = XRP(100), TakerGets = USD(40) + auto const bobOfferSeq{env.seq(bob_)}; + env(offer(bob_, XRP(100), USD(40)), Txflags(tfHybrid), Domain(domainID)); + env.close(); + BEAST_EXPECT(offerExists(env, bob_, bobOfferSeq)); + + // Alice places a hybrid offer in the opposite direction that + // partially crosses Bob's offer. + // Alice: TakerPays = USD(100), TakerGets = XRP(300) (rate = 3 XRP/USD) + // Bob's offer is at a better rate (2.5 XRP/USD) so crossing occurs. + auto const aliceOfferSeq{env.seq(alice_)}; + env(offer(alice_, USD(100), XRP(300)), Txflags(tfHybrid), Domain(domainID)); + env.close(); + + // After crossing, Alice's remaining offer should be placed. + auto const sle = env.le(keylet::offer(alice_.id(), aliceOfferSeq)); + BEAST_EXPECT(sle); + BEAST_EXPECT(sle->isFieldPresent(sfAdditionalBooks)); + BEAST_EXPECT(sle->getFieldArray(sfAdditionalBooks).size() == 1); + + auto const domainDirKey = sle->getFieldH256(sfBookDirectory); + auto const openDirKey = + sle->getFieldArray(sfAdditionalBooks)[0].getFieldH256(sfBookDirectory); + + auto const domainQuality = getQuality(domainDirKey); + auto const openQuality = getQuality(openDirKey); + + // Read the directory SLEs and check sfExchangeRate vs key quality. + auto const domainDirSle = env.le(Keylet(ltDIR_NODE, domainDirKey)); + auto const openDirSle = env.le(Keylet(ltDIR_NODE, openDirKey)); + BEAST_EXPECT(domainDirSle); + BEAST_EXPECT(openDirSle); + + auto const domainExRate = domainDirSle->getFieldU64(sfExchangeRate); + auto const openExRate = openDirSle->getFieldU64(sfExchangeRate); + auto const preCrossingQuality = std::uint64_t{5623825668291712342ULL}; + auto const postCrossingQuality = std::uint64_t{5623825668291712341ULL}; + + // Domain directory: sfExchangeRate should always match key quality + // (both use the pre-crossing rate). Correct behavior. + BEAST_EXPECT(domainQuality == preCrossingQuality); + BEAST_EXPECT(domainExRate == preCrossingQuality); + BEAST_EXPECT(domainExRate == domainQuality); + + if (fixEnabled) + { + // Correct behavior: both directory keys use the pre-crossing rate. + BEAST_EXPECT(openQuality == preCrossingQuality); + BEAST_EXPECT(domainQuality == openQuality); + + // sfExchangeRate matches key quality on both directories. + BEAST_EXPECT(openExRate == preCrossingQuality); + BEAST_EXPECT(openExRate == openQuality); + } + else + { + // Wrong legacy behavior: the open-book directory key uses the + // post-crossing rate instead of the domain-book rate. + BEAST_EXPECT(openQuality == postCrossingQuality); + BEAST_EXPECT(domainQuality != openQuality); + + // The open-book sfExchangeRate still uses the pre-crossing rate, + // so it no longer matches the actual quality encoded in the + // open-book directory key. + BEAST_EXPECT(openExRate == preCrossingQuality); + BEAST_EXPECT(openExRate != openQuality); + BEAST_EXPECT(openExRate == domainQuality); + } + } + + void + testBookExchangeRateFix(FeatureBitset features) + { + testcase("LedgerStateFix BookExchangeRate"); + + // Use the pre-fix path to create a hybrid offer with a mismatched + // sfExchangeRate, then apply LedgerStateFix to correct it. + // + // Steps: + // - Create a partially-crossed hybrid offer (pre-fixCleanup3_2_0) + // so the open-book directory has wrong sfExchangeRate. + // - Re-enable fixCleanup3_2_0 and submit a LedgerStateFix to + // repair the open-book directory's sfExchangeRate. + // + // Verify: + // - Before fix: sfExchangeRate != getQuality(key). + // - After fix: sfExchangeRate == getQuality(key). + + { + // Amendment gate: BookExchangeRate fixes require fixCleanup3_2_0. + Env env(*this, features - fixCleanup3_2_0); + Account const carol{"carol"}; + + env.fund(XRP(1000), carol); + env.close(); + + env(ledgerStateFix::bookExchangeRate(carol, uint256{1}), Ter(temDISABLED)); + } + + { + // Preflight check: BookExchangeRate fixes only accept their + // required fix-specific field. + Env env(*this, features); + Account const carol{"carol"}; + + env.fund(XRP(1000), carol); + env.close(); + + // BookExchangeRate fixes require sfBookDirectory. + auto missingBookDirectory = ledgerStateFix::bookExchangeRate(carol, uint256{1}); + missingBookDirectory.removeMember(sfBookDirectory.jsonName); + env(missingBookDirectory, Ter(temINVALID)); + + // BookExchangeRate fixes reject fields that belong to other + // LedgerStateFix types. + auto extraOwner = ledgerStateFix::bookExchangeRate(carol, uint256{1}); + extraOwner[sfOwner.jsonName] = carol.human(); + env(extraOwner, Ter(temINVALID)); + } + + { + Env env(*this, features); + auto const setup = PermissionedDEX(env); + auto const fixFee = drops(env.current()->fees().increment); + + { + // Preclaim check: the target directory must exist. + env(ledgerStateFix::bookExchangeRate(setup.carol, uint256{1}), + Fee(fixFee), + Ter(tecOBJECT_NOT_FOUND)); + } + + { + // Preclaim check: the target directory must be a book root + // page. Owner directories are ltDIR_NODE entries, but they do + // not carry sfExchangeRate. + auto const ownerDir = keylet::ownerDir(setup.bob.id()); + auto const ownerDirSle = env.le(ownerDir); + BEAST_EXPECT(ownerDirSle); + BEAST_EXPECT(!ownerDirSle->isFieldPresent(sfExchangeRate)); + + env(ledgerStateFix::bookExchangeRate(setup.carol, ownerDir.key), + Fee(fixFee), + Ter(tecNO_PERMISSION)); + } + + { + // Preclaim check: a correct sfExchangeRate leaves nothing to + // repair. + auto const bobOfferSeq{env.seq(setup.bob)}; + env(offer(setup.bob, XRP(100), setup.usd(40))); + env.close(); + + auto const sle = env.le(keylet::offer(setup.bob.id(), bobOfferSeq)); + BEAST_EXPECT(sle); + + auto const dirKey = sle->getFieldH256(sfBookDirectory); + { + auto const dirSle = env.le(Keylet(ltDIR_NODE, dirKey)); + BEAST_EXPECT(dirSle); + auto const exchangeRate = dirSle->getFieldU64(sfExchangeRate); + auto const quality = getQuality(dirKey); + BEAST_EXPECT(exchangeRate == quality); + } + + env(ledgerStateFix::bookExchangeRate(setup.carol, dirKey), + Fee(fixFee), + Ter(tecNO_PERMISSION)); + } + } + + { + // Repair path: start without fixCleanup3_2_0 to produce the + // mismatch, then enable the amendment and fix it. + Env env(*this, features - fixCleanup3_2_0); + auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] = + PermissionedDEX(env); + + // Bob places a hybrid offer. + env(offer(bob_, XRP(100), USD(40)), Txflags(tfHybrid), Domain(domainID)); + env.close(); + + // Alice partially crosses Bob. + auto const aliceOfferSeq{env.seq(alice_)}; + env(offer(alice_, USD(100), XRP(300)), Txflags(tfHybrid), Domain(domainID)); + env.close(); + + auto const sle = env.le(keylet::offer(alice_.id(), aliceOfferSeq)); + BEAST_EXPECT(sle); + + auto const openDirKey = + sle->getFieldArray(sfAdditionalBooks)[0].getFieldH256(sfBookDirectory); + + auto const preCrossingQuality = std::uint64_t{5623825668291712342ULL}; + auto const postCrossingQuality = std::uint64_t{5623825668291712341ULL}; + + // Confirm mismatch exists. + { + auto const dirSle = env.le(Keylet(ltDIR_NODE, openDirKey)); + BEAST_EXPECT(dirSle); + auto const exchangeRate = dirSle->getFieldU64(sfExchangeRate); + auto const quality = getQuality(openDirKey); + BEAST_EXPECT(exchangeRate == preCrossingQuality); + BEAST_EXPECT(quality == postCrossingQuality); + BEAST_EXPECT(exchangeRate != quality); + } + + // Enable fixCleanup3_2_0 and apply the LedgerStateFix. + env.enableFeature(fixCleanup3_2_0); + env.close(); + + auto const fixFee = drops(env.current()->fees().increment); + env(ledgerStateFix::bookExchangeRate(carol_, openDirKey), Fee(fixFee)); + env.close(); + + // Confirm sfExchangeRate now matches the key quality. + { + auto const dirSle = env.le(Keylet(ltDIR_NODE, openDirKey)); + BEAST_EXPECT(dirSle); + auto const exchangeRate = dirSle->getFieldU64(sfExchangeRate); + auto const quality = getQuality(openDirKey); + BEAST_EXPECT(exchangeRate == postCrossingQuality); + BEAST_EXPECT(quality == postCrossingQuality); + BEAST_EXPECT(exchangeRate == quality); + } + + // Submitting again should fail — nothing to fix. + env(ledgerStateFix::bookExchangeRate(carol_, openDirKey), + Fee(fixFee), + Ter(tecNO_PERMISSION)); + } + } + + void + testCancelRegularOfferWithDomainCreate(FeatureBitset features) + { + bool const fixEnabled = features[fixCleanup3_2_0]; + + testcase << "Cancel regular offer via domain OfferCreate" + << (fixEnabled ? " (fixCleanup3_2_0 enabled)" : " (fixCleanup3_2_0 disabled)"); + + // An OfferCreate with sfDomainID and sfOfferSequence pointing to + // the user's own non-domain offer should atomically cancel the + // regular offer and place the new domain offer. + // + // Pre-fixCleanup3_2_0: ValidPermissionedDEX flagged the deleted + // regular offer, so the transaction failed with tecINVARIANT_FAILED. + // Post-fixCleanup3_2_0: the invariant ignores deletions and the + // transaction succeeds. + + Env env(*this, features); + auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] = + PermissionedDEX(env); + + auto const regularSeq = env.seq(bob); + env(offer(bob, XRP(10), USD(10))); + env.close(); + BEAST_EXPECT(checkOffer(env, bob, regularSeq, XRP(10), USD(10), 0, false)); + + auto const domainSeq = env.seq(bob); + if (fixEnabled) + { + env(offer(bob, XRP(20), USD(20)), + Domain(domainID), + Json(jss::OfferSequence, regularSeq)); + env.close(); + BEAST_EXPECT(!offerExists(env, bob, regularSeq)); + BEAST_EXPECT(checkOffer(env, bob, domainSeq, XRP(20), USD(20), 0, true)); + } + else + { + env(offer(bob, XRP(20), USD(20)), + Domain(domainID), + Json(jss::OfferSequence, regularSeq), + Ter(tecINVARIANT_FAILED)); + env.close(); + BEAST_EXPECT(offerExists(env, bob, regularSeq)); + BEAST_EXPECT(!offerExists(env, bob, domainSeq)); + } + } + public: void run() override @@ -1478,7 +1786,15 @@ public: testHybridInvalidOffer(all); testHybridOfferDirectories(all); testHybridMalformedOffer(all); - testHybridMalformedOffer(all - fixSecurity3_1_3); + testHybridMalformedOffer(all - fixCleanup3_1_3); + testHybridOfferCrossingQuality(all); + testHybridOfferCrossingQuality(all - fixCleanup3_2_0); + testBookExchangeRateFix(all); + + // Cancelling a regular offer in a domain OfferCreate is allowed + // only after fixCleanup3_2_0. + testCancelRegularOfferWithDomainCreate(all); + testCancelRegularOfferWithDomainCreate(all - fixCleanup3_2_0); } }; diff --git a/src/test/app/PermissionedDomains_test.cpp b/src/test/app/PermissionedDomains_test.cpp index a49f913861..0857a4bdef 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)); @@ -139,7 +135,7 @@ class PermissionedDomains_test : public beast::unit_test::Suite {alice10, "credential9"}, {alice11, "credential10"}, {alice12, "credential11"}}; - BEAST_EXPECT(credentials11.size() == kMAX_PERMISSIONED_DOMAIN_CREDENTIALS_ARRAY_SIZE + 1); + BEAST_EXPECT(credentials11.size() == kMaxPermissionedDomainCredentialsArraySize + 1); env(pdomain::setTx(account, credentials11, domain), Ter(temARRAY_TOO_LARGE)); // Test credentials including non-existent issuer. @@ -176,12 +172,12 @@ class PermissionedDomains_test : public beast::unit_test::Suite env(txJsonMutable, Ter(temMALFORMED)); // Make too long CredentialType. - constexpr std::string_view kLONG_CREDENTIAL_TYPE = + static constexpr std::string_view kLongCredentialType = "Cred0123456789012345678901234567890123456789012345678901234567890"; - static_assert(kLONG_CREDENTIAL_TYPE.size() == kMAX_CREDENTIAL_TYPE_LENGTH + 1); + static_assert(kLongCredentialType.size() == kMaxCredentialTypeLength + 1); txJsonMutable["AcceptedCredentials"][2u] = credentialOrig; txJsonMutable["AcceptedCredentials"][2u][jss::Credential]["CredentialType"] = - std::string(kLONG_CREDENTIAL_TYPE); + std::string(kLongCredentialType); BEAST_EXPECT(exceptionExpected(env, txJsonMutable).starts_with("invalidParams")); // Remove Credentialtype from a credential and apply. @@ -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); @@ -313,19 +309,19 @@ class PermissionedDomains_test : public beast::unit_test::Suite // Make longest possible CredentialType. { - constexpr std::string_view kLONG_CREDENTIAL_TYPE = + static constexpr std::string_view kLongCredentialType = "Cred0123456789012345678901234567890123456789012345678901234567" "89"; - static_assert(kLONG_CREDENTIAL_TYPE.size() == kMAX_CREDENTIAL_TYPE_LENGTH); + static_assert(kLongCredentialType.size() == kMaxCredentialTypeLength); pdomain::Credentials const longCredentials{ - {alice[1], std::string(kLONG_CREDENTIAL_TYPE)}}; + {alice[1], std::string(kLongCredentialType)}}; env(pdomain::setTx(alice[0], longCredentials)); // 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()); @@ -362,10 +358,10 @@ class PermissionedDomains_test : public beast::unit_test::Suite }; uint256 domain2; { - BEAST_EXPECT(credentials10.size() == kMAX_PERMISSIONED_DOMAIN_CREDENTIALS_ARRAY_SIZE); + BEAST_EXPECT(credentials10.size() == kMaxPermissionedDomainCredentialsArraySize); 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]; @@ -406,11 +402,11 @@ class PermissionedDomains_test : public beast::unit_test::Suite // Try to delete the account with domains. auto const acctDelFee(drops(env.current()->fees().increment)); - constexpr std::size_t kDELETE_DELTA = 255; + static constexpr std::size_t kDeleteDelta = 255; { // Close enough ledgers to make it potentially deletable if empty. std::size_t const ownerSeq = env.seq(alice[0]); - while (kDELETE_DELTA + ownerSeq > env.current()->seq()) + while (kDeleteDelta + ownerSeq > env.current()->seq()) env.close(); env(acctdelete(alice[0], alice[2]), Fee(acctDelFee), Ter(tecHAS_OBLIGATIONS)); } @@ -421,7 +417,7 @@ class PermissionedDomains_test : public beast::unit_test::Suite env(pdomain::deleteTx(alice[0], objs.first)); env.close(); std::size_t const ownerSeq = env.seq(alice[0]); - while (kDELETE_DELTA + ownerSeq > env.current()->seq()) + while (kDeleteDelta + ownerSeq > env.current()->seq()) env.close(); env(acctdelete(alice[0], alice[2]), Fee(acctDelFee)); } @@ -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/RCLValidations_test.cpp b/src/test/app/RCLValidations_test.cpp index 6b3ea8cdbe..c3b0ddea9c 100644 --- a/src/test/app/RCLValidations_test.cpp +++ b/src/test/app/RCLValidations_test.cpp @@ -69,9 +69,9 @@ class RCLValidations_test : public beast::unit_test::Suite jtx::Env env(*this); Config const config; auto prev = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config.features}, - config.FEES.toFees(), + config.fees.toFees(), std::vector{}, env.app().getNodeFamily()); history.push_back(prev); @@ -235,9 +235,9 @@ class RCLValidations_test : public beast::unit_test::Suite auto& j = env.journal; Config const config; auto prev = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config.features}, - config.FEES.toFees(), + config.fees.toFees(), std::vector{}, env.app().getNodeFamily()); history.push_back(prev); diff --git a/src/test/app/ReducedOffer_test.cpp b/src/test/app/ReducedOffer_test.cpp index 4a2c2dba0a..47a2c1294c 100644 --- a/src/test/app/ReducedOffer_test.cpp +++ b/src/test/app/ReducedOffer_test.cpp @@ -560,8 +560,8 @@ public: Amounts const& carolOffer) -> unsigned int { // alice submits an offer that may become a blocker. std::uint32_t const aliceOfferSeq = env.seq(alice); - static Amounts const kALICE_INITIAL_OFFER(usd(2), drops(3382562)); - env(offer(alice, kALICE_INITIAL_OFFER.in, kALICE_INITIAL_OFFER.out)); + static Amounts const kAliceInitialOffer(usd(2), drops(3382562)); + env(offer(alice, kAliceInitialOffer.in, kAliceInitialOffer.out)); env.close(); STAmount const initialRate = Quality(jsonOfferToAmounts(ledgerEntryOffer( env, alice, aliceOfferSeq)[jss::node])) @@ -598,8 +598,8 @@ public: Amounts const aliceReducedOffer = jsonOfferToAmounts(aliceOffer[jss::node]); - BEAST_EXPECT(aliceReducedOffer.in < kALICE_INITIAL_OFFER.in); - BEAST_EXPECT(aliceReducedOffer.out < kALICE_INITIAL_OFFER.out); + BEAST_EXPECT(aliceReducedOffer.in < kAliceInitialOffer.in); + BEAST_EXPECT(aliceReducedOffer.out < kAliceInitialOffer.out); STAmount const inLedgerRate = Quality(aliceReducedOffer).rate(); badRate = inLedgerRate > initialRate ? 1 : 0; @@ -641,12 +641,12 @@ public: return badRate; }; - constexpr int kLOOP_COUNT = 100; + static constexpr int kLoopCount = 100; unsigned int blockedCount = 0; { STAmount increaseGets = usd(0); STAmount const step(increaseGets.asset(), 1, -8); - for (unsigned int i = 0; i < kLOOP_COUNT; ++i) + for (unsigned int i = 0; i < kLoopCount; ++i) { blockedCount += exerciseOfferTrio(Amounts(drops(1642020), usd(1) + increaseGets)); diff --git a/src/test/app/Regression_test.cpp b/src/test/app/Regression_test.cpp index d7c92f1748..1c83e97e61 100644 --- a/src/test/app/Regression_test.cpp +++ b/src/test/app/Regression_test.cpp @@ -85,12 +85,12 @@ struct Regression_test : public beast::unit_test::Suite // be reproduced against an open ledger. Make a local // closed ledger and work with it directly. auto closed = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); - auto expectedDrops = kINITIAL_XRP; + auto expectedDrops = kInitialXrp; BEAST_EXPECT(closed->header().drops == expectedDrops); auto const aliceXRP = 400; @@ -138,7 +138,7 @@ struct Regression_test : public beast::unit_test::Suite BEAST_EXPECT(balance == XRP(0)); } - expectedDrops -= aliceXRP * kDROPS_PER_XRP; + expectedDrops -= aliceXRP * kDropsPerXrp; BEAST_EXPECT(next->header().drops == expectedDrops); } @@ -194,7 +194,7 @@ struct Regression_test : public beast::unit_test::Suite using namespace jtx; Env env(*this, envconfig([](std::unique_ptr cfg) { cfg->section("transaction_queue").set("minimum_txn_in_ledger_standalone", "3"); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; })); EnvSs envs(env); @@ -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}); @@ -211,7 +211,7 @@ struct Regression_test : public beast::unit_test::Suite // our fee limit. for (int i = 0; i < 5; ++i) { - envs(noop(alice), Fee(kNONE), Seq(kNONE))(params); + envs(noop(alice), Fee(kNone), Seq(kNone))(params); auto tx = env.tx(); if (BEAST_EXPECT(tx)) @@ -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/SHAMapStore_test.cpp b/src/test/app/SHAMapStore_test.cpp index 574874e005..fc5ef02465 100644 --- a/src/test/app/SHAMapStore_test.cpp +++ b/src/test/app/SHAMapStore_test.cpp @@ -36,14 +36,14 @@ namespace xrpl::test { class SHAMapStore_test : public beast::unit_test::Suite { - static auto const kDELETE_INTERVAL = 8; + static auto const kDeleteInterval = 8; static auto onlineDelete(std::unique_ptr cfg) { - cfg->LEDGER_HISTORY = kDELETE_INTERVAL; + cfg->ledgerHistory = kDeleteInterval; auto& section = cfg->section(ConfigSection::nodeDatabase()); - section.set("online_delete", std::to_string(kDELETE_INTERVAL)); + section.set("online_delete", std::to_string(kDeleteInterval)); return cfg; } @@ -196,7 +196,7 @@ public: auto const firstSeq = waitForReady(env); auto lastRotated = firstSeq - 1; - for (auto i = firstSeq + 1; i < kDELETE_INTERVAL + firstSeq; ++i) + for (auto i = firstSeq + 1; i < kDeleteInterval + firstSeq; ++i) { env.fund(XRP(10000), noripple("test" + std::to_string(i))); env.close(); @@ -206,7 +206,7 @@ public: } BEAST_EXPECT(store.getLastRotated() == lastRotated); - for (auto i = 3; i < kDELETE_INTERVAL + lastRotated; ++i) + for (auto i = 3; i < kDeleteInterval + lastRotated; ++i) { ledgers.emplace(i, env.rpc("ledger", std::to_string(i))); BEAST_EXPECT( @@ -214,31 +214,31 @@ public: !getHash(ledgers[i]).empty()); } - ledgerCheck(env, kDELETE_INTERVAL + 1, 2); - transactionCheck(env, kDELETE_INTERVAL); - accountTransactionCheck(env, 2 * kDELETE_INTERVAL); + ledgerCheck(env, kDeleteInterval + 1, 2); + transactionCheck(env, kDeleteInterval); + accountTransactionCheck(env, 2 * kDeleteInterval); { // Closing one more ledger triggers a rotate env.close(); auto ledger = env.rpc("ledger", "current"); - BEAST_EXPECT(goodLedger(env, ledger, std::to_string(kDELETE_INTERVAL + 4))); + BEAST_EXPECT(goodLedger(env, ledger, std::to_string(kDeleteInterval + 4))); } store.rendezvous(); - BEAST_EXPECT(store.getLastRotated() == kDELETE_INTERVAL + 3); + BEAST_EXPECT(store.getLastRotated() == kDeleteInterval + 3); lastRotated = store.getLastRotated(); BEAST_EXPECT(lastRotated == 11); // That took care of the fake hashes - ledgerCheck(env, kDELETE_INTERVAL + 1, 3); - transactionCheck(env, kDELETE_INTERVAL); - accountTransactionCheck(env, 2 * kDELETE_INTERVAL); + ledgerCheck(env, kDeleteInterval + 1, 3); + transactionCheck(env, kDeleteInterval); + accountTransactionCheck(env, 2 * kDeleteInterval); // The last iteration of this loop should trigger a rotate - for (auto i = lastRotated - 1; i < lastRotated + kDELETE_INTERVAL - 1; ++i) + for (auto i = lastRotated - 1; i < lastRotated + kDeleteInterval - 1; ++i) { env.close(); @@ -247,7 +247,7 @@ public: ledgers.emplace(i, env.rpc("ledger", std::to_string(i))); BEAST_EXPECT( - store.getLastRotated() == lastRotated || i == lastRotated + kDELETE_INTERVAL - 2); + store.getLastRotated() == lastRotated || i == lastRotated + kDeleteInterval - 2); BEAST_EXPECT( goodLedger(env, ledgers[i], std::to_string(i), true) && !getHash(ledgers[i]).empty()); @@ -255,9 +255,9 @@ public: store.rendezvous(); - BEAST_EXPECT(store.getLastRotated() == kDELETE_INTERVAL + lastRotated); + BEAST_EXPECT(store.getLastRotated() == kDeleteInterval + lastRotated); - ledgerCheck(env, kDELETE_INTERVAL + 1, lastRotated); + ledgerCheck(env, kDeleteInterval + 1, lastRotated); transactionCheck(env, 0); accountTransactionCheck(env, 0); } @@ -283,7 +283,7 @@ public: BEAST_EXPECT(bad(canDelete, RpcNotEnabled)); // Close ledgers without triggering a rotate - for (; ledgerSeq < lastRotated + kDELETE_INTERVAL; ++ledgerSeq) + for (; ledgerSeq < lastRotated + kDeleteInterval; ++ledgerSeq) { env.close(); @@ -314,7 +314,7 @@ public: lastRotated = store.getLastRotated(); // Close enough ledgers to trigger another rotate - for (; ledgerSeq < lastRotated + kDELETE_INTERVAL + 1; ++ledgerSeq) + for (; ledgerSeq < lastRotated + kDeleteInterval + 1; ++ledgerSeq) { env.close(); @@ -324,7 +324,7 @@ public: store.rendezvous(); - ledgerCheck(env, kDELETE_INTERVAL + 1, lastRotated); + ledgerCheck(env, kDeleteInterval + 1, lastRotated); BEAST_EXPECT(lastRotated != store.getLastRotated()); } @@ -352,7 +352,7 @@ public: BEAST_EXPECT(!RPC::containsError(canDelete[jss::result])); BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == 0); - auto const firstBatch = kDELETE_INTERVAL + ledgerSeq; + auto const firstBatch = kDeleteInterval + ledgerSeq; for (; ledgerSeq < firstBatch; ++ledgerSeq) { env.close(); @@ -367,9 +367,9 @@ public: BEAST_EXPECT(lastRotated == store.getLastRotated()); // This does not kick off a cleanup - canDelete = env.rpc("can_delete", std::to_string(ledgerSeq + (kDELETE_INTERVAL / 2))); + canDelete = env.rpc("can_delete", std::to_string(ledgerSeq + (kDeleteInterval / 2))); BEAST_EXPECT(!RPC::containsError(canDelete[jss::result])); - BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == ledgerSeq + (kDELETE_INTERVAL / 2)); + BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == ledgerSeq + (kDeleteInterval / 2)); store.rendezvous(); @@ -391,7 +391,7 @@ public: BEAST_EXPECT(store.getLastRotated() == ledgerSeq - 1); lastRotated = ledgerSeq - 1; - for (; ledgerSeq < lastRotated + kDELETE_INTERVAL; ++ledgerSeq) + for (; ledgerSeq < lastRotated + kDeleteInterval; ++ledgerSeq) { // No cleanups in this loop. env.close(); @@ -425,7 +425,7 @@ public: BEAST_EXPECT( canDelete[jss::result][jss::can_delete] == std::numeric_limits::max()); - for (; ledgerSeq < lastRotated + kDELETE_INTERVAL; ++ledgerSeq) + for (; ledgerSeq < lastRotated + kDeleteInterval; ++ledgerSeq) { // No cleanups in this loop. env.close(); @@ -458,7 +458,7 @@ public: BEAST_EXPECT(!RPC::containsError(canDelete[jss::result])); BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == ledgerSeq - 1); - for (; ledgerSeq < lastRotated + kDELETE_INTERVAL; ++ledgerSeq) + for (; ledgerSeq < lastRotated + kDeleteInterval; ++ledgerSeq) { // No cleanups in this loop. env.close(); @@ -527,11 +527,11 @@ public: auto writableBackend = makeBackendRotating(env, scheduler, writableDb); auto archiveBackend = makeBackendRotating(env, scheduler, archiveDb); - constexpr int kREAD_THREADS = 4; + static constexpr int kReadThreads = 4; auto nscfg = env.app().config().section(ConfigSection::nodeDatabase()); auto dbr = std::make_unique( scheduler, - kREAD_THREADS, + kReadThreads, std::move(writableBackend), std::move(archiveBackend), nscfg, 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..b5d1af9ef0 100644 --- a/src/test/app/SetRegularKey_test.cpp +++ b/src/test/app/SetRegularKey_test.cpp @@ -54,7 +54,7 @@ public: env(noop(alice), Sig(alice)); testcase("Revoke regular key"); - env(regkey(alice, kDISABLED)); + env(regkey(alice, kDisabled)); env(noop(alice), Sig(bob), Ter(tefBAD_AUTH)); env(noop(alice), Sig(alice)); } @@ -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 @@ -158,7 +154,7 @@ public: env.close(); // Disable the regular key using a ticket. - env(regkey(alice, kDISABLED), Sig(alie), ticket::Use(--ticketSeq)); + env(regkey(alice, kDisabled), Sig(alie), ticket::Use(--ticketSeq)); env.close(); // alice should be able to sign using the master key but not the diff --git a/src/test/app/TheoreticalQuality_test.cpp b/src/test/app/TheoreticalQuality_test.cpp index ed6f91f475..8f7d844019 100644 --- a/src/test/app/TheoreticalQuality_test.cpp +++ b/src/test/app/TheoreticalQuality_test.cpp @@ -125,9 +125,9 @@ class RandomAccountParams std::uint32_t const initialBalance_; // probability of changing a value from its default - constexpr static double kPROB_CHANGE_DEFAULT = 0.75; + static constexpr double kProbChangeDefault = 0.75; // probability that an account redeems into another account - constexpr static double kPROB_REDEEM = 0.5; + static constexpr double kProbRedeem = 0.5; std::uniform_real_distribution<> zeroOneDist_{0.0, 1.0}; std::uniform_real_distribution<> transferRateDist_{1.0, 2.0}; std::uniform_real_distribution<> qualityPercentDist_{80, 120}; @@ -135,7 +135,7 @@ class RandomAccountParams bool shouldSet() { - return zeroOneDist_(engine_) <= kPROB_CHANGE_DEFAULT; + return zeroOneDist_(engine_) <= kProbChangeDefault; }; void @@ -206,7 +206,7 @@ public: Currency const& currency) { using namespace jtx; - if (zeroOneDist_(engine_) > kPROB_REDEEM) + if (zeroOneDist_(engine_) > kProbRedeem) return; setInitialBalance(env, acc, peer, currency); } @@ -290,8 +290,8 @@ class TheoreticalQuality_test : public beast::unit_test::Suite auto compareClose = [](Quality const& q1, Quality const& q2) { // relative diff is fabs(a-b)/min(a,b) // can't get access to internal value. Use the rate - constexpr double kTOLERANCE = 0.0000001; - return relativeDistance(q1, q2) <= kTOLERANCE; + static constexpr double kTolerance = 0.0000001; + return relativeDistance(q1, q2) <= kTolerance; }; for (auto const& strand : sr.second) @@ -339,7 +339,7 @@ public: auto const currency = toCurrency("USD"); - constexpr std::size_t const kNUM_ACCOUNTS = 4; + static constexpr std::size_t kNumAccounts = 4; // There are three relevant trust lines: `alice->bob`, `bob->carol`, and // `carol->dan`. There are four accounts. If we count the number of @@ -355,7 +355,7 @@ public: // randomly sample the test space. int const numTestIterations = reqNumIterations.value_or(250); - constexpr std::uint32_t kPAYMENT_AMOUNT = 1; + static constexpr std::uint32_t kPaymentAmount = 1; // Class to randomly set account transfer rates, qualities, and other // params. @@ -373,15 +373,15 @@ public: auto const bob = Account("bob" + iterAsStr); auto const carol = Account("carol" + iterAsStr); auto const dan = Account("dan" + iterAsStr); - std::array accounts{{alice, bob, carol, dan}}; - static_assert(kNUM_ACCOUNTS == 4, "Path is only correct for four accounts"); + std::array accounts{{alice, bob, carol, dan}}; + static_assert(kNumAccounts == 4, "Path is only correct for four accounts"); Path const accountsPath(accounts[1], accounts[2]); env.fund(XRP(10000), alice, bob, carol, dan); env.close(); // iterate through all pairs of accounts, randomly set the transfer // rate, qIn, qOut, and if the account issues or redeems - for (std::size_t ii = 0; ii < kNUM_ACCOUNTS; ++ii) + for (std::size_t ii = 0; ii < kNumAccounts; ++ii) { rndAccParams.maybeSetTransferRate(env, accounts[ii]); // The payment is from: @@ -389,7 +389,7 @@ public: // set the trust lines and initial balances for each pair of // neighboring accounts std::size_t const j = ii + 1; - if (j == kNUM_ACCOUNTS) + if (j == kNumAccounts) continue; rndAccParams.setupTrustLines(env, accounts[ii], accounts[j], currency); @@ -399,7 +399,7 @@ public: // Accounts are set up, make the payment IOU const iou{accounts.back(), currency}; RippleCalcTestParams const rcp{env.json( - pay(accounts.front(), accounts.back(), iou(kPAYMENT_AMOUNT)), + pay(accounts.front(), accounts.back(), iou(kPaymentAmount)), accountsPath, Txflags(tfNoRippleDirect))}; @@ -422,7 +422,7 @@ public: int const numTestIterations = reqNumIterations.value_or(100); - constexpr std::uint32_t kPAYMENT_AMOUNT = 1; + static constexpr std::uint32_t kPaymentAmount = 1; Currency const eurCurrency = toCurrency("EUR"); Currency const usdCurrency = toCurrency("USD"); @@ -444,8 +444,8 @@ public: auto const oscar = Account("oscar" + iterAsStr); // offer owner auto const usdb = bob["USD"]; auto const eurc = carol["EUR"]; - constexpr std::size_t const kNUM_ACCOUNTS = 5; - std::array const accounts{{alice, bob, carol, dan, oscar}}; + static constexpr std::size_t kNumAccounts = 5; + std::array const accounts{{alice, bob, carol, dan, oscar}}; // sendmax should be in USDB and delivered amount should be in EURC // normalized path should be: @@ -478,8 +478,8 @@ public: IOU const srcIOU{bob, usdCurrency}; IOU const dstIOU{carol, eurCurrency}; RippleCalcTestParams const rcp{env.json( - pay(alice, dan, dstIOU(kPAYMENT_AMOUNT)), - Sendmax(srcIOU(100 * kPAYMENT_AMOUNT)), + pay(alice, dan, dstIOU(kPaymentAmount)), + Sendmax(srcIOU(100 * kPaymentAmount)), bookPath, Txflags(tfNoRippleDirect))}; diff --git a/src/test/app/Ticket_test.cpp b/src/test/app/Ticket_test.cpp index d266ec12d2..626cdbe44d 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.")) @@ -673,12 +673,12 @@ class Ticket_test : public beast::unit_test::Suite // Successfully create several tickets (using a sequence). std::uint32_t ticketSeq{env.seq(alice)}; - static constexpr std::uint32_t kTICKET_COUNT{10}; - env(ticket::create(alice, kTICKET_COUNT)); + static constexpr std::uint32_t kTicketCount{10}; + env(ticket::create(alice, kTicketCount)); uint256 const txHash1{getTxID()}; // Just for grins use the tickets in reverse from largest to smallest. - ticketSeq += kTICKET_COUNT; + ticketSeq += kTicketCount; env(noop(alice), ticket::Use(--ticketSeq)); uint256 const txHash2{getTxID()}; @@ -757,7 +757,7 @@ class Ticket_test : public beast::unit_test::Suite testSignWithTicketSequence() { // The sign and the submit RPC commands automatically fill in the - // Sequence field of a transaction if kNONE is provided. If a + // Sequence field of a transaction if kNone is provided. If a // TicketSequence is provided in the transaction, then the // auto-filled Sequence should be zero. testcase("Sign with TicketSequence"); @@ -779,11 +779,11 @@ class Ticket_test : public beast::unit_test::Suite { // Test that the "sign" RPC command fills in a "Sequence": 0 field - // if kNONE is provided. + // if kNone is provided. // 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")); @@ -812,11 +812,11 @@ class Ticket_test : public beast::unit_test::Suite } { // Test that the "submit" RPC command fills in a "Sequence": 0 - // field if kNONE is provided. + // field if kNone is provided. // 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/Transaction_ordering_test.cpp b/src/test/app/Transaction_ordering_test.cpp index 50340497a4..7c0721cde3 100644 --- a/src/test/app/Transaction_ordering_test.cpp +++ b/src/test/app/Transaction_ordering_test.cpp @@ -64,7 +64,7 @@ struct Transaction_ordering_test : public beast::unit_test::Suite testcase("Incorrect order"); Env env(*this, envconfig([](std::unique_ptr cfg) { - cfg->FORCE_MULTI_THREAD = false; + cfg->forceMultiThread = false; return cfg; })); @@ -102,7 +102,7 @@ struct Transaction_ordering_test : public beast::unit_test::Suite testcase("Incorrect order multiple intermediaries"); Env env(*this, envconfig([](std::unique_ptr cfg) { - cfg->FORCE_MULTI_THREAD = true; + cfg->forceMultiThread = true; return cfg; })); @@ -110,16 +110,16 @@ struct Transaction_ordering_test : public beast::unit_test::Suite env.fund(XRP(1000), noripple(alice)); auto const aliceSequence = env.seq(alice); - static constexpr auto kSIZE = 5; + static constexpr auto kSize = 5; std::vector tx; - tx.reserve(kSIZE); - for (auto i = 0; i < kSIZE; ++i) + tx.reserve(kSize); + for (auto i = 0; i < kSize; ++i) { tx.emplace_back(env.jt(noop(alice), Seq(aliceSequence + i), LastLedgerSeq(7))); } - for (auto i = 1; i < kSIZE; ++i) + for (auto i = 1; i < kSize; ++i) { env(tx[i], Ter(terPRE_SEQ)); BEAST_EXPECT(env.seq(alice) == aliceSequence); @@ -127,11 +127,11 @@ struct Transaction_ordering_test : public beast::unit_test::Suite env(tx[0]); env.app().getJobQueue().rendezvous(); - BEAST_EXPECT(env.seq(alice) == aliceSequence + kSIZE); + BEAST_EXPECT(env.seq(alice) == aliceSequence + kSize); env.close(); - for (auto i = 0; i < kSIZE; ++i) + for (auto i = 0; i < kSize; ++i) { auto const result = env.rpc("tx", to_string(tx[i].stx->getTransactionID())); BEAST_EXPECT(result["result"]["meta"]["TransactionResult"] == "tesSUCCESS"); 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..8333fce3b3 100644 --- a/src/test/app/TxQ_test.cpp +++ b/src/test/app/TxQ_test.cpp @@ -60,8 +60,8 @@ namespace xrpl::test { class TxQPosNegFlows_test : public beast::unit_test::Suite { // Same as corresponding values from TxQ.h - static constexpr FeeLevel64 kBASE_FEE_LEVEL{256}; - static constexpr FeeLevel64 kMIN_ESCALATION_FEE_LEVEL = kBASE_FEE_LEVEL * 500; + static constexpr FeeLevel64 kBaseFeeLevel{256}; + static constexpr FeeLevel64 kMinEscalationFeeLevel = kBaseFeeLevel * 500; static void fillQueue(jtx::Env& env, jtx::Account const& account) @@ -109,7 +109,7 @@ class TxQPosNegFlows_test : public beast::unit_test::Suite { FeeLevel64 const expectedMedFeeLevel = (feeLevel1 + feeLevel2 + FeeLevel64{1}) / 2; - return std::max(expectedMedFeeLevel, kMIN_ESCALATION_FEE_LEVEL).fee(); + return std::max(expectedMedFeeLevel, kMinEscalationFeeLevel).fee(); } static auto @@ -276,8 +276,8 @@ public: ////////////////////////////////////////////////////////////// - constexpr auto kLARGE_FEE_MULTIPLIER = 700; - auto const largeFee = baseFee * kLARGE_FEE_MULTIPLIER; + static constexpr auto kLargeFeeMultiplier = 700; + auto const largeFee = baseFee * kLargeFeeMultiplier; // Stuff the ledger and queue so we can verify that // stuff gets kicked out. @@ -319,7 +319,7 @@ public: // is put back in. Neat. env.close(); // clang-format off - checkMetrics(*this, env, 2, 8, 5, 4, kBASE_FEE_LEVEL.fee(), calcMedFeeLevel(FeeLevel64{kBASE_FEE_LEVEL.fee() * kLARGE_FEE_MULTIPLIER})); + checkMetrics(*this, env, 2, 8, 5, 4, kBaseFeeLevel.fee(), calcMedFeeLevel(FeeLevel64{kBaseFeeLevel.fee() * kLargeFeeMultiplier})); // clang-format on env.close(); @@ -742,8 +742,8 @@ public: // Queue an item with a sufficient LastLedgerSeq. env(noop(alice), LastLedgerSeq(8), queued); - constexpr auto kLARGE_FEE_MULTIPLIER = 700; - auto const largeFee = baseFee * kLARGE_FEE_MULTIPLIER; + static constexpr auto kLargeFeeMultiplier = 700; + auto const largeFee = baseFee * kLargeFeeMultiplier; // Queue items with higher fees to force the previous // txn to wait. @@ -756,7 +756,7 @@ public: auto& txQ = env.app().getTxQ(); auto aliceStat = txQ.getAccountTxs(alice.id()); BEAST_EXPECT(aliceStat.size() == 1); - BEAST_EXPECT(aliceStat.begin()->feeLevel == kBASE_FEE_LEVEL); + BEAST_EXPECT(aliceStat.begin()->feeLevel == kBaseFeeLevel); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) BEAST_EXPECT(aliceStat.begin()->lastValid && *aliceStat.begin()->lastValid == 8); BEAST_EXPECT(!aliceStat.begin()->consequences.isBlocker()); @@ -764,12 +764,11 @@ public: auto bobStat = txQ.getAccountTxs(bob.id()); BEAST_EXPECT(bobStat.size() == 1); BEAST_EXPECT( - bobStat.begin()->feeLevel == - FeeLevel64{kBASE_FEE_LEVEL.fee() * kLARGE_FEE_MULTIPLIER}); + bobStat.begin()->feeLevel == FeeLevel64{kBaseFeeLevel.fee() * kLargeFeeMultiplier}); BEAST_EXPECT(!bobStat.begin()->lastValid); BEAST_EXPECT(!bobStat.begin()->consequences.isBlocker()); - auto noStat = txQ.getAccountTxs(Account::kMASTER.id()); + auto noStat = txQ.getAccountTxs(Account::kMaster.id()); BEAST_EXPECT(noStat.empty()); } @@ -787,12 +786,12 @@ public: env.close(); // alice's transaction is still hanging around // clang-format off - checkMetrics(*this, env, 1, 8, 5, 4, kBASE_FEE_LEVEL.fee(), kBASE_FEE_LEVEL.fee() * kLARGE_FEE_MULTIPLIER); + checkMetrics(*this, env, 1, 8, 5, 4, kBaseFeeLevel.fee(), kBaseFeeLevel.fee() * kLargeFeeMultiplier); // clang-format on BEAST_EXPECT(env.seq(alice) == 3); - constexpr auto kANOTHER_LARGE_FEE_MULTIPLIER = 800; - auto const anotherLargeFee = baseFee * kANOTHER_LARGE_FEE_MULTIPLIER; + static constexpr auto kAnotherLargeFeeMultiplier = 800; + auto const anotherLargeFee = baseFee * kAnotherLargeFeeMultiplier; // Keep alice's transaction waiting. // clang-format off env(noop(bob), Fee(anotherLargeFee), queued); @@ -802,7 +801,7 @@ public: env(noop(edgar), Fee(anotherLargeFee), queued); env(noop(felicia), Fee(anotherLargeFee - 1), queued); env(noop(felicia), Fee(anotherLargeFee - 1), Seq(env.seq(felicia) + 1), queued); - checkMetrics(*this, env, 8, 8, 5, 4, kBASE_FEE_LEVEL.fee() + 1, kBASE_FEE_LEVEL.fee() * kLARGE_FEE_MULTIPLIER); + checkMetrics(*this, env, 8, 8, 5, 4, kBaseFeeLevel.fee() + 1, kBaseFeeLevel.fee() * kLargeFeeMultiplier); // clang-format on env.close(); @@ -810,7 +809,7 @@ public: // into the ledger, so her transaction is gone, // though one of felicia's is still in the queue. // clang-format off - checkMetrics(*this, env, 1, 10, 6, 5, kBASE_FEE_LEVEL.fee(), kBASE_FEE_LEVEL.fee() * kLARGE_FEE_MULTIPLIER); + checkMetrics(*this, env, 1, 10, 6, 5, kBaseFeeLevel.fee(), kBaseFeeLevel.fee() * kLargeFeeMultiplier); // clang-format on BEAST_EXPECT(env.seq(alice) == 3); BEAST_EXPECT(env.seq(felicia) == 7); @@ -818,7 +817,7 @@ public: env.close(); // And now the queue is empty // clang-format off - checkMetrics(*this, env, 0, 12, 1, 6, kBASE_FEE_LEVEL.fee(), kBASE_FEE_LEVEL.fee() * kANOTHER_LARGE_FEE_MULTIPLIER); + checkMetrics(*this, env, 0, 12, 1, 6, kBaseFeeLevel.fee(), kBaseFeeLevel.fee() * kAnotherLargeFeeMultiplier); // clang-format on BEAST_EXPECT(env.seq(alice) == 3); BEAST_EXPECT(env.seq(felicia) == 8); @@ -868,8 +867,8 @@ public: fillQueue(env, alice); checkMetrics(*this, env, 0, 6, 4, 3); - constexpr auto kALICE_FEE_MULTIPLIER = 3; - auto feeAlice = baseFee * kALICE_FEE_MULTIPLIER; + static constexpr auto kAliceFeeMultiplier = 3; + auto feeAlice = baseFee * kAliceFeeMultiplier; auto seqAlice = env.seq(alice); for (int i = 0; i < 4; ++i) { @@ -894,7 +893,7 @@ public: ++seqCarol; } // clang-format off - checkMetrics(*this, env, 6, 6, 4, 3, (kBASE_FEE_LEVEL.fee() * kALICE_FEE_MULTIPLIER) + 1); + checkMetrics(*this, env, 6, 6, 4, 3, (kBaseFeeLevel.fee() * kAliceFeeMultiplier) + 1); // clang-format on // Carol submits high enough to beat Bob's average fee which kicks @@ -1023,16 +1022,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(); + static constexpr std::size_t kInitQueueMax = 6; + checkMetrics(*this, env, 0, kInitQueueMax, 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, kInitQueueMax, 4, 3); // Alice - price starts exploding: held env(noop(alice), Fee(11), queued); - checkMetrics(*this, env, 1, initQueueMax, 4, 3); + checkMetrics(*this, env, 1, kInitQueueMax, 4, 3); auto aliceSeq = env.seq(alice); auto bobSeq = env.seq(bob); @@ -1040,28 +1044,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, kInitQueueMax, 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, kInitQueueMax, 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, kInitQueueMax, 4, 3); // Bob - queue a transaction env(noop(bob), queued); - checkMetrics(*this, env, 4, initQueueMax, 4, 3); + checkMetrics(*this, env, 4, kInitQueueMax, 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, kInitQueueMax, 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, kInitQueueMax, 4, 3, 257); BEAST_EXPECT(env.seq(alice) == aliceSeq); BEAST_EXPECT(env.seq(bob) == bobSeq); @@ -1255,7 +1259,7 @@ public: testcase("tie breaking"); auto cfg = makeConfig({{"minimum_txn_in_ledger_standalone", "4"}}); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env(*this, std::move(cfg)); auto alice = Account("alice"); @@ -1531,7 +1535,7 @@ public: { double const feeMultiplier = static_cast(cost.drops()) / baseFee; medFeeLevel = - FeeLevel64{static_cast(feeMultiplier * kBASE_FEE_LEVEL.fee())}; + FeeLevel64{static_cast(feeMultiplier * kBaseFeeLevel.fee())}; } env(noop(alice), Fee(cost)); @@ -1542,7 +1546,7 @@ public: env.close(); // If not for the maximum, the per ledger would be 11. // clang-format off - checkMetrics(*this, env, 0, 10, 0, 5, kBASE_FEE_LEVEL.fee(), calcMedFeeLevel(medFeeLevel)); + checkMetrics(*this, env, 0, 10, 0, 5, kBaseFeeLevel.fee(), calcMedFeeLevel(medFeeLevel)); // clang-format on } @@ -2649,7 +2653,7 @@ public: {{"minimum_txn_in_ledger_standalone", "1"}, {"ledgers_in_queue", "10"}, {"maximum_txn_per_account", "11"}}); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env(*this, std::move(cfg)); auto const baseFee = env.current()->fees().base.drops(); @@ -2789,7 +2793,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) @@ -2797,13 +2801,13 @@ public: envs( noop(alice), Fee(baseFee * 100), - Seq(kNONE), + Seq(kNone), Json(jss::LastLedgerSequence, lastLedgerSeq), Ter(terQUEUED))(submitParams); } else { - envs(noop(alice), Fee(baseFee * 100), Seq(kNONE), Ter(terQUEUED))(submitParams); + envs(noop(alice), Fee(baseFee * 100), Seq(kNone), Ter(terQUEUED))(submitParams); } } checkMetrics(*this, env, 5, std::nullopt, 7, 6); @@ -2814,7 +2818,7 @@ public: for (auto const& tx : aliceStat) { BEAST_EXPECT(tx.seqProxy == seq); - BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBASE_FEE_LEVEL.fee() * 100}); + BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBaseFeeLevel.fee() * 100}); if (seq.value() == aliceSeq + 2) { BEAST_EXPECT(tx.lastValid && *tx.lastValid == lastLedgerSeq); @@ -2829,7 +2833,7 @@ public: // Put some txs in the queue for bob. // Give them a higher fee so they'll beat alice's. for (int i = 0; i < 8; ++i) - envs(noop(bob), Fee(baseFee * 200), Seq(kNONE), Ter(terQUEUED))(); + envs(noop(bob), Fee(baseFee * 200), Seq(kNone), Ter(terQUEUED))(); checkMetrics(*this, env, 13, std::nullopt, 7, 6); env.close(); @@ -2838,14 +2842,14 @@ public: // Give them a higher fee so they'll beat alice's. fillQueue(env, bob); for (int i = 0; i < 9; ++i) - envs(noop(bob), Fee(baseFee * 200), Seq(kNONE), Ter(terQUEUED))(); + envs(noop(bob), Fee(baseFee * 200), Seq(kNone), Ter(terQUEUED))(); checkMetrics(*this, env, 14, 14, 8, 7, 25601); env.close(); // Put some more txs in the queue for bob. // Give them a higher fee so they'll beat alice's. fillQueue(env, bob); for (int i = 0; i < 10; ++i) - envs(noop(bob), Fee(baseFee * 200), Seq(kNONE), Ter(terQUEUED))(); + envs(noop(bob), Fee(baseFee * 200), Seq(kNone), Ter(terQUEUED))(); checkMetrics(*this, env, 15, 16, 9, 8); env.close(); checkMetrics(*this, env, 4, 18, 10, 9); @@ -2867,13 +2871,13 @@ public: ++seq; BEAST_EXPECT(tx.seqProxy.isSeq() && tx.seqProxy.value() == seq); - BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBASE_FEE_LEVEL.fee() * 100}); + BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBaseFeeLevel.fee() * 100}); BEAST_EXPECT(!tx.lastValid); ++seq; } } // Now, fill the gap. - envs(noop(alice), Fee(baseFee * 100), Seq(kNONE), Ter(terQUEUED))(submitParams); + envs(noop(alice), Fee(baseFee * 100), Seq(kNone), Ter(terQUEUED))(submitParams); checkMetrics(*this, env, 5, 18, 10, 9); { auto aliceStat = txQ.getAccountTxs(alice.id()); @@ -2882,7 +2886,7 @@ public: for (auto const& tx : aliceStat) { BEAST_EXPECT(tx.seqProxy.isSeq() && tx.seqProxy.value() == seq); - BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBASE_FEE_LEVEL * 100}); + BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBaseFeeLevel * 100}); BEAST_EXPECT(!tx.lastValid); ++seq; } @@ -2974,11 +2978,11 @@ public: BEAST_EXPECT(!queueData.isMember(jss::transactions)); } - auto submitParams = json::Value(json::ObjectValue); - 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); - envs(noop(alice), Fee(baseFee * 10), Seq(kNONE), Ter(terQUEUED))(submitParams); + 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); + envs(noop(alice), Fee(baseFee * 10), Seq(kNone), Ter(terQUEUED))(submitParams); checkMetrics(*this, env, 4, 6, 4, 3); { @@ -3009,7 +3013,7 @@ public: { auto const& item = queued[i]; BEAST_EXPECT(item[jss::seq] == data[jss::Sequence].asInt() + i); - BEAST_EXPECT(item[jss::fee_level] == std::to_string(kBASE_FEE_LEVEL.fee() * 10)); + BEAST_EXPECT(item[jss::fee_level] == std::to_string(kBaseFeeLevel.fee() * 10)); BEAST_EXPECT(!item.isMember(jss::LastLedgerSequence)); BEAST_EXPECT(item.isMember(jss::fee)); @@ -3026,12 +3030,12 @@ public: checkMetrics(*this, env, 0, 8, 4, 4); // Fill the ledger and then queue up a blocker. - envs(noop(alice), Seq(kNONE))(submitParams); + envs(noop(alice), Seq(kNone))(submitParams); envs( fset(alice, asfAccountTxnID), Fee(baseFee * 10), - Seq(kNONE), + Seq(kNone), Json(jss::LastLedgerSequence, 10), Ter(terQUEUED))(submitParams); checkMetrics(*this, env, 1, 8, 5, 4); @@ -3064,7 +3068,7 @@ public: { auto const& item = queued[i]; BEAST_EXPECT(item[jss::seq] == data[jss::Sequence].asInt() + i); - BEAST_EXPECT(item[jss::fee_level] == std::to_string(kBASE_FEE_LEVEL.fee() * 10)); + BEAST_EXPECT(item[jss::fee_level] == std::to_string(kBaseFeeLevel.fee() * 10)); BEAST_EXPECT(item.isMember(jss::fee)); BEAST_EXPECT(item[jss::fee] == std::to_string(baseFee * 10)); BEAST_EXPECT(item.isMember(jss::max_spend_drops)); @@ -3085,7 +3089,7 @@ public: } } - envs(noop(alice), Fee(baseFee * 10), Seq(kNONE), Ter(telCAN_NOT_QUEUE_BLOCKED))( + envs(noop(alice), Fee(baseFee * 10), Seq(kNone), Ter(telCAN_NOT_QUEUE_BLOCKED))( submitParams); checkMetrics(*this, env, 1, 8, 5, 4); @@ -3117,7 +3121,7 @@ public: { auto const& item = queued[i]; BEAST_EXPECT(item[jss::seq] == data[jss::Sequence].asInt() + i); - BEAST_EXPECT(item[jss::fee_level] == std::to_string(kBASE_FEE_LEVEL.fee() * 10)); + BEAST_EXPECT(item[jss::fee_level] == std::to_string(kBaseFeeLevel.fee() * 10)); if (i == queued.size() - 1) { @@ -3220,7 +3224,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 +3411,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()); { @@ -3678,7 +3682,7 @@ public: for (auto const& tx : aliceQueue) { BEAST_EXPECT(tx.seqProxy == seq); - BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBASE_FEE_LEVEL.fee() * 10}); + BEAST_EXPECT(tx.feeLevel == FeeLevel64{kBaseFeeLevel.fee() * 10}); seq.advanceBy(1); } @@ -4057,17 +4061,17 @@ public: Account const ellie("ellie"); Account const fiona("fiona"); - constexpr int kLEDGERS_IN_QUEUE = 30; + static constexpr int kLedgersInQueue = 30; auto cfg = makeConfig( {{"minimum_txn_in_ledger_standalone", "1"}, - {"ledgers_in_queue", std::to_string(kLEDGERS_IN_QUEUE)}, + {"ledgers_in_queue", std::to_string(kLedgersInQueue)}, {"maximum_txn_per_account", "10"}}, {{"account_reserve", "1000"}, {"owner_reserve", "50"}}); auto& votingSection = cfg->section("voting"); - votingSection.set("account_reserve", std::to_string(cfg->FEES.reference_fee.drops() * 100)); + votingSection.set("account_reserve", std::to_string(cfg->fees.referenceFee.drops() * 100)); - votingSection.set("reference_fee", std::to_string(cfg->FEES.reference_fee.drops())); + votingSection.set("reference_fee", std::to_string(cfg->fees.referenceFee.drops())); Env env(*this, std::move(cfg)); @@ -4085,7 +4089,7 @@ public: env.close(); auto const metrics = env.app().getTxQ().getMetrics(*env.current()); - checkMetrics(*this, env, 0, kLEDGERS_IN_QUEUE * metrics.txPerLedger, 0, 2); + checkMetrics(*this, env, 0, kLedgersInQueue * metrics.txPerLedger, 0, 2); // Close ledgers until the amendments show up. int i = 0; @@ -4096,7 +4100,7 @@ public: break; } auto expectedPerLedger = xrpl::detail::numUpVotedAmendments() + 1; - checkMetrics(*this, env, 0, kLEDGERS_IN_QUEUE * expectedPerLedger, 0, expectedPerLedger); + checkMetrics(*this, env, 0, kLedgersInQueue * expectedPerLedger, 0, expectedPerLedger); // Now wait 2 weeks modulo 256 ledgers for the amendments to be // enabled. Speed the process by closing ledgers every 80 minutes, @@ -4115,7 +4119,7 @@ public: *this, env, 0, - kLEDGERS_IN_QUEUE * expectedPerLedger, + kLedgersInQueue * expectedPerLedger, expectedPerLedger + 1, expectedPerLedger); @@ -4148,7 +4152,7 @@ public: *this, env, expectedInQueue, - kLEDGERS_IN_QUEUE * expectedPerLedger, + kLedgersInQueue * expectedPerLedger, expectedPerLedger + 1, expectedPerLedger); @@ -4174,7 +4178,7 @@ public: *this, env, expectedInQueue, - kLEDGERS_IN_QUEUE * expectedPerLedger, + kLedgersInQueue * expectedPerLedger, expectedInLedger, expectedPerLedger); { @@ -4378,7 +4382,7 @@ public: // b) For just now having a queued transaction fail on apply() // because of the sequence gap. // - // Verify that kNONE of alice's queued transactions actually applied to + // Verify that kNone of alice's queued transactions actually applied to // her account. BEAST_EXPECT(env.seq(alice) == seqSaveAlice); seqAlice = seqSaveAlice; 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..20a3557db5 100644 --- a/src/test/app/ValidatorList_test.cpp +++ b/src/test/app/ValidatorList_test.cpp @@ -81,7 +81,7 @@ private: SecretKey const& ssk, int seq) { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = seq; st[sfPublicKey] = pk; @@ -104,7 +104,7 @@ private: static std::string makeRevocationString(PublicKey const& pk, SecretKey const& sk) { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = std::numeric_limits::max(); st[sfPublicKey] = pk; @@ -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; @@ -603,15 +603,15 @@ private: BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublisherKeys)); std::map> const lists = []() { - auto constexpr kLIST_SIZE = 20; - auto constexpr kNUM_LISTS = 9; + static constexpr auto kListSize = 20; + static constexpr auto kNumLists = 9; std::map> lists; // 1-based to correspond with the individually named blobs below. - for (auto i = 1; i <= kNUM_LISTS; ++i) + for (auto i = 1; i <= kNumLists; ++i) { auto& list = lists[i]; - list.reserve(kLIST_SIZE); - while (list.size() < kLIST_SIZE) + list.reserve(kListSize); + while (list.size() < kListSize) list.push_back(randomValidator()); } return lists; @@ -949,10 +949,10 @@ private: BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublisherKeys)); std::vector const list = []() { - auto constexpr kLIST_SIZE = 20; + static constexpr auto kListSize = 20; std::vector list; - list.reserve(kLIST_SIZE); - while (list.size() < kLIST_SIZE) + list.reserve(kListSize); + while (list.size() < kListSize) list.push_back(randomValidator()); return list; }(); @@ -1545,10 +1545,10 @@ private: // locals[0]: from 0 to maxKeys - 4 // locals[1]: from 1 to maxKeys - 2 // locals[2]: from 2 to maxKeys - constexpr static int kPUBLISHERS = 3; + static constexpr int kPublishers = 3; std::array< std::pair, - kPUBLISHERS> + kPublishers> locals = { std::make_pair(valKeys.cbegin(), valKeys.cend() - 4), std::make_pair(valKeys.cbegin() + 1, valKeys.cend() - 2), @@ -1588,7 +1588,7 @@ private: }; // Apply multiple published lists - for (auto i = 0; i < kPUBLISHERS; ++i) + for (auto i = 0; i < kPublishers; ++i) addPublishedList(i); BEAST_EXPECT(trustedKeys->getListThreshold() == 1); @@ -1635,10 +1635,10 @@ private: // locals[2]: from 2 to maxKeys // intersection of at least 2: same as locals[1] // intersection when 1 is dropped: from 2 to maxKeys - 4 - constexpr static int kPUBLISHERS = 3; + static constexpr int kPublishers = 3; std::array< std::pair, - kPUBLISHERS> + kPublishers> locals = { std::make_pair(valKeys.cbegin(), valKeys.cend() - 4), std::make_pair(valKeys.cbegin() + 1, valKeys.cend() - 2), @@ -1703,7 +1703,7 @@ private: // Apply multiple published lists // validUntil1 is expiration time for locals[1] NetClock::time_point validUntil1, validUntil2; - for (auto i = 0; i < kPUBLISHERS; ++i) + for (auto i = 0; i < kPublishers; ++i) addPublishedList(i, validUntil1, validUntil2); BEAST_EXPECT(trustedKeys->getListThreshold() == 2); @@ -2257,7 +2257,7 @@ private: auto extractProtocolMessage1 = [this, &extractHeader](Message& message) { auto [header, buffers] = extractHeader(message); if (BEAST_EXPECT(header) && - BEAST_EXPECT(header->message_type == protocol::mtVALIDATOR_LIST)) + BEAST_EXPECT(header->messageType == protocol::mtVALIDATOR_LIST)) { auto const msg = detail::parseMessageContent(*header, buffers.data()); @@ -2269,7 +2269,7 @@ private: auto extractProtocolMessage2 = [this, &extractHeader](Message& message) { auto [header, buffers] = extractHeader(message); if (BEAST_EXPECT(header) && - BEAST_EXPECT(header->message_type == protocol::mtVALIDATOR_LIST_COLLECTION)) + BEAST_EXPECT(header->messageType == protocol::mtVALIDATOR_LIST_COLLECTION)) { auto const msg = detail::parseMessageContent( *header, buffers.data()); @@ -2548,10 +2548,10 @@ private: jtx::Env env(*this); auto& app = env.app(); - constexpr std::size_t kMAX_KEYS = 20; + static constexpr std::size_t kMaxKeys = 20; hash_set activeValidators; std::vector valKeys; - while (valKeys.size() != kMAX_KEYS) + while (valKeys.size() != kMaxKeys) { valKeys.push_back(randomValidator()); activeValidators.emplace(calcNodeID(valKeys.back().masterPublic)); @@ -2592,13 +2592,13 @@ private: auto const pubSigningKeys = randomKeyPair(KeyType::Secp256k1); cfgPublishers.push_back(strHex(publisherPublic)); - constexpr auto kREVOKED = std::numeric_limits::max(); + constexpr auto kRevoked = std::numeric_limits::max(); auto const manifest = base64Encode(makeManifestString( publisherPublic, publisherSecret, pubSigningKeys.first, pubSigningKeys.second, - i < countRevoked ? kREVOKED : 1)); + i < countRevoked ? kRevoked : 1)); publishers.push_back( Publisher{ .revoked = i < countRevoked, @@ -2640,7 +2640,7 @@ private: }; // Test cases use 5 publishers. - constexpr auto kQUORUM_DISABLED = std::numeric_limits::max(); + constexpr auto kQuorumDisabled = std::numeric_limits::max(); { // List threshold = 5 (same as number of trusted publishers) ManifestCache pubManifests; @@ -2688,7 +2688,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -2746,7 +2746,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty()); hash_set removed; @@ -2811,7 +2811,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -2881,7 +2881,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -2947,7 +2947,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -3014,7 +3014,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty()); hash_set removed; @@ -3080,7 +3080,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal); BEAST_EXPECT(trustedKeys->trusted(self.masterPublic)); @@ -3139,7 +3139,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal); BEAST_EXPECT(trustedKeys->trusted(self.masterPublic)); @@ -3197,7 +3197,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal); BEAST_EXPECT(trustedKeys->trusted(self.masterPublic)); @@ -3253,7 +3253,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal); for (auto const& val : valKeys) @@ -3298,7 +3298,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal); hash_set added; @@ -3319,7 +3319,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -3365,7 +3365,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal); hash_set added; @@ -3385,7 +3385,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -3432,7 +3432,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal); hash_set added; @@ -3452,7 +3452,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty()); hash_set removed; @@ -3512,7 +3512,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -3573,7 +3573,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -3634,7 +3634,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty()); hash_set removed; @@ -3696,7 +3696,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -3843,7 +3843,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; @@ -3911,7 +3911,7 @@ private: env.app().getOPs(), env.app().getOverlay(), env.app().getHashRouter()); - BEAST_EXPECT(trustedKeys->quorum() == kQUORUM_DISABLED); + BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled); BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1); hash_set removed; diff --git a/src/test/app/ValidatorSite_test.cpp b/src/test/app/ValidatorSite_test.cpp index 4145b4f8b1..f7f805faa2 100644 --- a/src/test/app/ValidatorSite_test.cpp +++ b/src/test/app/ValidatorSite_test.cpp @@ -45,8 +45,8 @@ realValidatorContents() )vl"; } -auto constexpr kDEFAULT_EXPIRES = std::chrono::seconds{3600}; -auto constexpr kDEFAULT_EFFECTIVE_OVERLAP = std::chrono::seconds{30}; +constexpr auto kDefaultExpires = std::chrono::seconds{3600}; +constexpr auto kDefaultEffectiveOverlap = std::chrono::seconds{30}; } // namespace detail namespace test { @@ -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 @@ -78,7 +78,7 @@ private: "http://207.261.33.37:8080/validators", "https://ripple.com/validators", "https://ripple.com:443/validators", - "file:///etc/opt/xrpld/validators.txt", + "file:///etc/xrpld/validators.txt", "file:///C:/Lib/validators.txt" #if !_MSC_VER , @@ -129,8 +129,8 @@ private: bool failFetch = false; bool failApply = false; int serverVersion = 1; - std::chrono::seconds expiresFromNow = detail::kDEFAULT_EXPIRES; - std::chrono::seconds effectiveOverlap = detail::kDEFAULT_EFFECTIVE_OVERLAP; + std::chrono::seconds expiresFromNow = detail::kDefaultExpires; + std::chrono::seconds effectiveOverlap = detail::kDefaultEffectiveOverlap; int expectedRefreshMin = 0; }; void @@ -172,7 +172,7 @@ private: }; std::vector servers; - auto constexpr kLIST_SIZE = 20; + static constexpr auto kListSize = 20; std::vector cfgPublishers; for (auto const& cfg : paths) @@ -180,8 +180,8 @@ private: servers.emplace_back(cfg); auto& item = servers.back(); item.isRetry = cfg.path == "/bad-resource"; - item.list.reserve(kLIST_SIZE); - while (item.list.size() < kLIST_SIZE) + item.list.reserve(kListSize); + while (item.list.size() < kListSize) item.list.push_back(TrustedPublisherServer::randomValidator()); NetClock::time_point const expires = env.timeKeeper().now() + cfg.expiresFromNow; @@ -405,7 +405,7 @@ public: false, false, 1, - detail::kDEFAULT_EXPIRES, + detail::kDefaultExpires, std::chrono::seconds{-90}}}); // fetch single site with unending redirect (fails to load) testFetchList( @@ -495,7 +495,7 @@ public: false, true, 1, - std::chrono::seconds{json::Value::kMIN_INT}}}); + std::chrono::seconds{json::Value::kMinInt}}}); // force an out-of-range validUntil value on the future list // The first list is accepted. The second fails. The parser // returns the "best" result, so this looks like a success. @@ -507,7 +507,7 @@ public: false, false, 1, - std::chrono::seconds{json::Value::kMAX_INT - 300}, + std::chrono::seconds{json::Value::kMaxInt - 300}, 299s}}); // force an out-of-range validFrom value // The first list is accepted. The second fails. The parser @@ -520,7 +520,7 @@ public: false, false, 1, - std::chrono::seconds{json::Value::kMAX_INT - 300}, + std::chrono::seconds{json::Value::kMaxInt - 300}, 301s}}); // force an out-of-range validUntil value on _both_ lists testFetchList( @@ -531,8 +531,8 @@ public: false, true, 1, - std::chrono::seconds{json::Value::kMIN_INT}, - std::chrono::seconds{json::Value::kMAX_INT - 6000}}}); + std::chrono::seconds{json::Value::kMinInt}, + std::chrono::seconds{json::Value::kMaxInt - 6000}}}); // verify refresh intervals are properly clamped testFetchList( good, @@ -542,8 +542,8 @@ public: false, false, 1, - detail::kDEFAULT_EXPIRES, - detail::kDEFAULT_EFFECTIVE_OVERLAP, + detail::kDefaultExpires, + detail::kDefaultEffectiveOverlap, 1}}); // minimum of 1 minute testFetchList( good, @@ -553,8 +553,8 @@ public: false, false, 1, - detail::kDEFAULT_EXPIRES, - detail::kDEFAULT_EFFECTIVE_OVERLAP, + detail::kDefaultExpires, + detail::kDefaultEffectiveOverlap, 1}}); // minimum of 1 minute testFetchList( good, @@ -564,8 +564,8 @@ public: false, false, 1, - detail::kDEFAULT_EXPIRES, - detail::kDEFAULT_EFFECTIVE_OVERLAP, + detail::kDefaultExpires, + detail::kDefaultEffectiveOverlap, 10}}); // 10 minutes is fine testFetchList( good, @@ -575,8 +575,8 @@ public: false, false, 1, - detail::kDEFAULT_EXPIRES, - detail::kDEFAULT_EFFECTIVE_OVERLAP, + detail::kDefaultExpires, + detail::kDefaultEffectiveOverlap, 10}}); // 10 minutes is fine testFetchList( good, @@ -586,8 +586,8 @@ public: false, false, 1, - detail::kDEFAULT_EXPIRES, - detail::kDEFAULT_EFFECTIVE_OVERLAP, + detail::kDefaultExpires, + detail::kDefaultEffectiveOverlap, 60 * 24}}); // max of 24 hours testFetchList( good, @@ -597,8 +597,8 @@ public: false, false, 1, - detail::kDEFAULT_EXPIRES, - detail::kDEFAULT_EFFECTIVE_OVERLAP, + detail::kDefaultExpires, + detail::kDefaultEffectiveOverlap, 60 * 24}}); // max of 24 hours } using namespace boost::filesystem; diff --git a/src/test/app/Vault_test.cpp b/src/test/app/Vault_test.cpp index b0b93e0b3f..c6a9a54a53 100644 --- a/src/test/app/Vault_test.cpp +++ b/src/test/app/Vault_test.cpp @@ -9,9 +9,12 @@ #include #include #include +#include +#include #include #include #include +#include #include #include #include @@ -69,7 +72,7 @@ class Vault_test : public beast::unit_test::Suite using PrettyAsset = xrpl::test::jtx::PrettyAsset; using PrettyAmount = xrpl::test::jtx::PrettyAmount; - static auto constexpr kNEGATIVE_AMOUNT = [](PrettyAsset const& asset) -> PrettyAmount { + static constexpr auto kNegativeAmount = [](PrettyAsset const& asset) -> PrettyAmount { return {STAmount{asset.raw(), 1ul, 0, true, STAmount::Unchecked{}}, ""}; }; @@ -206,7 +209,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(); } @@ -570,7 +573,7 @@ class Vault_test : public beast::unit_test::Suite }); testCases("MPT", [&](Env& env) -> Asset { - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); PrettyAsset const asset = mptt.issuanceID(); mptt.authorize({.account = depositor}); @@ -634,7 +637,7 @@ class Vault_test : public beast::unit_test::Suite { auto tx = vault.set({.owner = owner, .id = keylet.key}); - env(tx, kDATA("test"), Ter{resultAfterCreate}); + env(tx, kData("test"), Ter{resultAfterCreate}); } { @@ -678,14 +681,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")); + env(tx, kData("Test")); - tx[sfDomainID] = to_string(BaseUint<256>(13ul)); + tx[sfDomainID] = to_string(BaseUInt<256>(13ul)); env(tx, Ter{temDISABLED}); } }, @@ -786,12 +789,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}); } @@ -815,33 +818,33 @@ class Vault_test : public beast::unit_test::Suite { auto tx = vault.set({ .owner = owner, - .id = beast::kZERO, + .id = beast::kZero, }); env(tx, Ter{temMALFORMED}); } { auto tx = - vault.deposit({.depositor = owner, .id = beast::kZERO, .amount = asset(10)}); + vault.deposit({.depositor = owner, .id = beast::kZero, .amount = asset(10)}); env(tx, Ter(temMALFORMED)); } { auto tx = - vault.withdraw({.depositor = owner, .id = beast::kZERO, .amount = asset(10)}); + vault.withdraw({.depositor = owner, .id = beast::kZero, .amount = asset(10)}); env(tx, Ter{temMALFORMED}); } { auto tx = vault.clawback( - {.issuer = issuer, .id = beast::kZERO, .holder = owner, .amount = asset(10)}); + {.issuer = issuer, .id = beast::kZero, .holder = owner, .amount = asset(10)}); env(tx, Ter{temMALFORMED}); } { auto tx = vault.del({ .owner = owner, - .id = beast::kZERO, + .id = beast::kZero, }); env(tx, Ter{temMALFORMED}); } @@ -982,7 +985,7 @@ class Vault_test : public beast::unit_test::Suite { auto tx = vault.set({.owner = owner, .id = keylet.key}); - tx[sfAssetsMaximum] = kNEGATIVE_AMOUNT(asset).number(); + tx[sfAssetsMaximum] = kNegativeAmount(asset).number(); env(tx, Ter{temMALFORMED}); } }); @@ -995,7 +998,7 @@ class Vault_test : public beast::unit_test::Suite { auto tx = vault.deposit( - {.depositor = owner, .id = keylet.key, .amount = kNEGATIVE_AMOUNT(asset)}); + {.depositor = owner, .id = keylet.key, .amount = kNegativeAmount(asset)}); env(tx, Ter(temBAD_AMOUNT)); } @@ -1027,7 +1030,7 @@ class Vault_test : public beast::unit_test::Suite { auto tx = vault.withdraw( - {.depositor = owner, .id = keylet.key, .amount = kNEGATIVE_AMOUNT(asset)}); + {.depositor = owner, .id = keylet.key, .amount = kNegativeAmount(asset)}); env(tx, Ter(temBAD_AMOUNT)); } @@ -1060,7 +1063,7 @@ class Vault_test : public beast::unit_test::Suite {.issuer = issuer, .id = keylet.key, .holder = owner, - .amount = kNEGATIVE_AMOUNT(asset)}); + .amount = kNegativeAmount(asset)}); env(tx, Ter(temBAD_AMOUNT)); } }); @@ -1079,13 +1082,13 @@ 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}); } { auto tx = tx1; - tx[sfAssetsMaximum] = kNEGATIVE_AMOUNT(asset).number(); + tx[sfAssetsMaximum] = kNegativeAmount(asset).number(); env(tx, Ter{temMALFORMED}); } @@ -1238,7 +1241,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}); }); @@ -1415,7 +1418,7 @@ class Vault_test : public beast::unit_test::Suite env.fund(XRP(1000), issuer, owner, depositor); env.close(); Vault vault{env}; - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; // Locked because that is the default flag. mptt.create(); Asset const asset = mptt.issuanceID(); @@ -1588,12 +1591,12 @@ class Vault_test : public beast::unit_test::Suite env.close(); Vault vault{env}; - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; - auto const kNONE = LedgerSpecificFlags(0); + MPTTester mptt{env, issuer, kMptInitNoFund}; + auto const kNone = LedgerSpecificFlags(0); mptt.create( {.flags = tfMPTCanTransfer | tfMPTCanLock | - (args.enableClawback ? tfMPTCanClawback : kNONE) | - (args.requireAuth ? tfMPTRequireAuth : kNONE), + (args.enableClawback ? tfMPTCanClawback : kNone) | + (args.requireAuth ? tfMPTRequireAuth : kNone), .mutableFlags = tmfMPTCanMutateCanTransfer}); PrettyAsset const asset = mptt.issuanceID(); mptt.authorize({.account = owner}); @@ -1872,8 +1875,8 @@ class Vault_test : public beast::unit_test::Suite auto const [acctReserve, incReserve] = [this]() -> std::pair { Env const env{*this, testableAmendments()}; return { - env.current()->fees().accountReserve(0).drops() / kDROPS_PER_XRP.drops(), - env.current()->fees().increment.drops() / kDROPS_PER_XRP.drops()}; + env.current()->fees().accountReserve(0).drops() / kDropsPerXrp.drops(), + env.current()->fees().increment.drops() / kDropsPerXrp.drops()}; }(); testCase( @@ -2211,7 +2214,7 @@ class Vault_test : public beast::unit_test::Suite env.close(); Vault const vault{env}; - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create( {.flags = tfMPTCanTransfer | tfMPTCanLock | lsfMPTCanClawback | tfMPTRequireAuth}); mptt.authorize({.account = owner}); @@ -2241,7 +2244,7 @@ class Vault_test : public beast::unit_test::Suite PrettyAsset const& asset, Vault& vault, MPTTester& mptt) { - testcase("MPT non-transferable"); + testcase("MPT non-transferable: block deposit, allow withdraw"); auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); env(tx); @@ -2251,22 +2254,19 @@ class Vault_test : public beast::unit_test::Suite env(tx); env.close(); - // Remove CanTransfer + // Issuer governance: clear CanTransfer. New exposure must be + // blocked, but recovery paths must remain open so existing + // depositors are not trapped. mptt.set({.mutableFlags = tmfMPTClearCanTransfer}); env.close(); + // New deposit is blocked. env(tx, Ter{tecNO_AUTH}); env.close(); + // Existing depositor can always withdraw, even though the asset + // is no longer freely transferable. tx = vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(100)}); - - env(tx, Ter{tecNO_AUTH}); - env.close(); - - // Restore CanTransfer - mptt.set({.mutableFlags = tmfMPTSetCanTransfer}); - env.close(); - env(tx); env.close(); @@ -2274,6 +2274,322 @@ class Vault_test : public beast::unit_test::Suite env(vault.del({.owner = owner, .id = keylet.key})); }); + { + testcase("MPT non-transferable: pre-fixCleanup3_2_0 withdraw blocked"); + + // Regression: before fixCleanup3_2_0 a depositor was trapped if + // the issuer cleared lsfMPTCanTransfer. Verify that the legacy + // (broken) behavior is preserved when the amendment is disabled. + Env env{*this, testableAmendments() - fixCleanup3_2_0}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + Account const depositor{"depositor"}; + env.fund(XRP(10'000), issuer, owner, depositor); + env.close(); + Vault const vault{env}; + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create( + {.flags = tfMPTCanTransfer | tfMPTCanLock, + .mutableFlags = tmfMPTCanMutateCanTransfer}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + mptt.authorize({.account = depositor}); + env(pay(issuer, depositor, asset(1'000))); + env.close(); + + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)})); + env.close(); + + mptt.set({.mutableFlags = tmfMPTClearCanTransfer}); + env.close(); + + // Pre-amendment: deposit blocked (matches new behavior). + env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)}), + Ter{tecNO_AUTH}); + env.close(); + + // Pre-amendment: withdraw is also blocked - this is the bug + // that fixCleanup3_2_0 fixes. + env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(100)}), + Ter{tecNO_AUTH}); + env.close(); + } + + { + testcase("MPT non-transferable: vault shares inherit restriction"); + + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + Account const alice{"alice"}; + Account const bob{"bob"}; + env.fund(XRP(10'000), issuer, owner, alice, bob); + env.close(); + Vault const vault{env}; + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create( + {.flags = tfMPTCanTransfer | tfMPTCanLock, + .mutableFlags = tmfMPTCanMutateCanTransfer}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + mptt.authorize({.account = alice}); + mptt.authorize({.account = bob}); + env(pay(issuer, alice, asset(1'000))); + env(pay(issuer, bob, asset(1'000))); + env.close(); + + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)})); + // Bob also deposits so he has a share MPToken to receive into. + env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)})); + env.close(); + + auto const shares = [&]() -> PrettyAsset { + auto const sle = env.le(keylet); + BEAST_EXPECT(sle != nullptr); + return MPTIssue(sle->at(sfShareMPTID)); + }(); + + // Sanity: while CanTransfer is set on the underlying, peer-to-peer + // share transfers are allowed. + env(pay(alice, bob, shares(1))); + env.close(); + + // Issuer governance: clear CanTransfer on the underlying. + mptt.set({.mutableFlags = tmfMPTClearCanTransfer}); + env.close(); + + // Vault shares inherit the restriction: third-party share-to-share + // payments are blocked. + env(pay(alice, bob, shares(1)), Ter{tecNO_AUTH}); + env.close(); + + // Recovery path: existing share holders can still redeem shares + // for the underlying asset via VaultWithdraw. + env(vault.withdraw({.depositor = alice, .id = keylet.key, .amount = shares(1)})); + env.close(); + } + + { + testcase("MPT locked: vault shares inherit underlying lock"); + + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + Account const alice{"alice"}; + Account const bob{"bob"}; + Account const carol{"carol"}; + env.fund(XRP(10'000), issuer, owner, alice, bob, carol); + env.close(); + Vault const vault{env}; + + MPTTester asset{ + {.env = env, + .issuer = issuer, + .holders = {owner, alice, bob, carol}, + .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanLock}}; + env(pay(issuer, alice, asset(1'000))); + env(pay(issuer, bob, asset(1'000))); + env.close(); + + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)})); + // Bob also deposits so he has a share MPToken to receive into. + env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)})); + env.close(); + + auto const shares = [&]() -> PrettyAsset { + auto const sle = env.le(keylet); + BEAST_EXPECT(sle != nullptr); + return MPTIssue(sle->at(sfShareMPTID)); + }(); + auto const shareMptID = shares.raw().get().getMptID(); + auto const shareBalance = [&](Account const& account) { + auto const sle = env.le(keylet::mptoken(shareMptID, account)); + return sle ? sle->at(sfMPTAmount) : 0; + }; + + // Sanity: before the underlying lock, peer-to-peer share + // transfers are allowed. + env(pay(alice, bob, shares(1))); + env.close(); + + // Create the offer while shares are spendable, then lock the + // underlying to test whether a stale offer can still be crossed. + env(offer(alice, XRP(1), shares(1))); + env.close(); + + // Lock the underlying after the vault and share balances exist. + asset.set({.account = issuer, .flags = tfMPTLock}); + env.close(); + + // Direct vault share payment inherits the underlying lock via + // sfReferenceHolding. + BEAST_EXPECT(shareBalance(alice) == 499); + BEAST_EXPECT(shareBalance(bob) == 501); + env(pay(alice, bob, shares(1)), Ter{tecLOCKED}); + env.close(); + BEAST_EXPECT(shareBalance(alice) == 499); + BEAST_EXPECT(shareBalance(bob) == 501); + + // The same inherited lock must also block DEX payment paths that + // would consume an offer selling vault shares. + env(pay(carol, bob, shares(1)), + Sendmax(XRP(1)), + Path(BookSpec{shares.raw()}), + Ter{tecPATH_PARTIAL}); + env.close(); + BEAST_EXPECT(shareBalance(alice) == 499); + BEAST_EXPECT(shareBalance(bob) == 501); + BEAST_EXPECT(expectOffers(env, alice, 1)); + } + + { + testcase("MPT non-transferable: pre-fixCleanup3_2_0 share transfer succeeds"); + + // Regression: before fixCleanup3_2_0 a peer-to-peer share Payment + // succeeded even when the underlying asset's lsfMPTCanTransfer + // was cleared. Verify that the legacy (non-inheriting) behavior + // is preserved when the amendment is disabled. + Env env{*this, testableAmendments() - fixCleanup3_2_0}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + Account const alice{"alice"}; + Account const bob{"bob"}; + env.fund(XRP(10'000), issuer, owner, alice, bob); + env.close(); + Vault const vault{env}; + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create( + {.flags = tfMPTCanTransfer | tfMPTCanLock, + .mutableFlags = tmfMPTCanMutateCanTransfer}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + mptt.authorize({.account = alice}); + mptt.authorize({.account = bob}); + env(pay(issuer, alice, asset(1'000))); + env(pay(issuer, bob, asset(1'000))); + env.close(); + + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)})); + env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)})); + env.close(); + + auto const shares = [&]() -> PrettyAsset { + auto const sle = env.le(keylet); + BEAST_EXPECT(sle != nullptr); + return MPTIssue(sle->at(sfShareMPTID)); + }(); + + mptt.set({.mutableFlags = tmfMPTClearCanTransfer}); + env.close(); + + // Pre-amendment: share transfer leaks past underlying restriction. + env(pay(alice, bob, shares(1))); + env.close(); + } + + { + testcase("MPT CanTrade governance: share inherits underlying on DEX and AMM"); + + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + Account const alice{"alice"}; + Account const bob{"bob"}; + env.fund(XRP(100'000), issuer, owner, alice, bob); + env.close(); + Vault const vault{env}; + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create( + {.flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanLock, + .mutableFlags = tmfMPTCanMutateCanTrade}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + mptt.authorize({.account = alice}); + mptt.authorize({.account = bob}); + env(pay(issuer, alice, asset(10'000))); + env(pay(issuer, bob, asset(10'000))); + env.close(); + + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + // Seed shares so we can later place them on trading venues. + env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(5'000)})); + env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(5'000)})); + env.close(); + + auto const shares = [&]() -> PrettyAsset { + auto const sle = env.le(keylet); + BEAST_EXPECT(sle != nullptr); + return MPTIssue(sle->at(sfShareMPTID)); + }(); + + // Sanity: while CanTrade is set on the underlying, both the asset + // and the vault share can be placed on the DEX. + env(offer(alice, XRP(1), asset(10))); + env(offer(alice, XRP(1), shares(1))); + env.close(); + + // Issuer governance: clear CanTrade on the underlying. + mptt.set({.mutableFlags = tmfMPTClearCanTrade}); + env.close(); + + // Control: clearing CanTrade on the underlying is observable on + // the DEX path for that asset. + env(offer(alice, XRP(1), asset(10)), Ter{tecNO_PERMISSION}); + env.close(); + + // Control: clearing CanTrade on the underlying is also observable + // on the AMM path for that asset. + AMM const ammUnderlyingFails( + env, alice, XRP(1'000), asset(1'000), Ter{tecNO_PERMISSION}); + + // Post-fixCleanup3_2_0: vault shares inherit the underlying's + // CanTrade restriction on the DEX path (canTrade reads the + // share's sfReferenceHolding and dispatches to the underlying). + env(offer(bob, XRP(1), shares(1)), Ter{tecNO_PERMISSION}); + env.close(); + + // checkMPTAllowed mirrors the inheritance for AMM/Offer- + // crossing/Check paths, so a share AMM also cannot be created + // when the underlying CanTrade is cleared. + AMM const ammShares(env, alice, XRP(1'000), shares(100), Ter{tecNO_PERMISSION}); + + // Deposit still works (canAddHolding does not consult the field). + env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(100)})); + env.close(); + + // Peer-to-peer share transfers still work (CanTransfer is set on + // both layers). + env(pay(alice, bob, shares(1))); + env.close(); + + // Withdraw still works. + env(vault.withdraw({.depositor = alice, .id = keylet.key, .amount = asset(100)})); + env.close(); + } + { testcase("MPT OutstandingAmount > MaximumAmount"); @@ -2400,7 +2716,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 +2769,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 +3052,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()); @@ -2743,16 +3060,17 @@ class Vault_test : public beast::unit_test::Suite env(tx); env.close(); } - env(pay(owner, charlie, shares(100))); - env.close(); - - // Charlie cannot withdraw - auto tx3 = vault.withdraw( - {.depositor = charlie, .id = keylet.key, .amount = shares(100)}); - env(tx3, Ter{terNO_RIPPLE}); - env.close(); - - env(pay(charlie, owner, shares(100))); + // Behavioral shift introduced by share inheritance: + // before fixCleanup3_2_0 this share Payment succeeded + // and the underlying IOU's NoRipple restriction surfaced + // only later on Charlie's withdrawal (terNO_RIPPLE). + // Post-amendment, canTransfer reads the share's + // sfReferenceHolding and dispatches to the underlying IOU; + // rippling is disabled between owner and charlie so the + // share payment itself is now blocked. tecPATH_DRY is + // the path-find layer's translation of the underlying + // terNO_RIPPLE under featureMPTokensV2. + env(pay(owner, charlie, shares(100)), Ter{tecPATH_DRY}); env.close(); } @@ -2819,10 +3137,10 @@ class Vault_test : public beast::unit_test::Suite { BEAST_EXPECT(env.balance(owner, asset) == startingOwnerBalance.value()); - BEAST_EXPECT(env.balance(vaultAccount(keylet), asset) == beast::kZERO); + BEAST_EXPECT(env.balance(vaultAccount(keylet), asset) == beast::kZero); auto const vault = env.le(keylet); - BEAST_EXPECT(vault->at(sfAssetsAvailable) == beast::kZERO); - BEAST_EXPECT(vault->at(sfAssetsTotal) == beast::kZERO); + BEAST_EXPECT(vault->at(sfAssetsAvailable) == beast::kZero); + BEAST_EXPECT(vault->at(sfAssetsTotal) == beast::kZero); } env(vault.del({.owner = owner, .id = keylet.key})); @@ -2833,8 +3151,8 @@ class Vault_test : public beast::unit_test::Suite auto const [acctReserve, incReserve] = [this]() -> std::pair { Env const env{*this, testableAmendments()}; return { - env.current()->fees().accountReserve(0).drops() / kDROPS_PER_XRP.drops(), - env.current()->fees().increment.drops() / kDROPS_PER_XRP.drops()}; + env.current()->fees().accountReserve(0).drops() / kDropsPerXrp.drops(), + env.current()->fees().increment.drops() / kDropsPerXrp.drops()}; }(); testCase( @@ -3065,7 +3383,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 +3396,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 +3417,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 +3634,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()); }(); @@ -3375,9 +3693,9 @@ class Vault_test : public beast::unit_test::Suite AccountID const accountId = xrpl::pseudoAccountAddress(*env.current(), keylet.key); env(pay(env.master.id(), accountId, XRP(1000)), - Seq(kAUTOFILL), - Fee(kAUTOFILL), - Sig(kAUTOFILL)); + Seq(kAutofill), + Fee(kAutofill), + Sig(kAutofill)); } auto [tx, keylet1] = vault.create({.owner = owner, .asset = xrpIssue()}); @@ -4197,10 +4515,10 @@ class Vault_test : public beast::unit_test::Suite // Borrow 40: assetsAvailable=60, assetsTotal=100 env(set(d.depositor, brokerKeylet.key, STAmount(d.asset, Number(40, 0))), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, d.owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -4276,20 +4594,20 @@ 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 = + static constexpr auto kCheckString = [](auto& node, SField const& field, std::string v) -> bool { return node.isMember(field.fieldName) && node[field.fieldName].isString() && node[field.fieldName] == v; }; - constexpr auto kCHECK_OBJECT = + static constexpr auto kCheckObject = [](auto& node, SField const& field, json::Value v) -> bool { return node.isMember(field.fieldName) && node[field.fieldName].isObject() && node[field.fieldName] == v; }; - constexpr auto kCHECK_INT = [](auto& node, SField const& field, int v) -> bool { + static constexpr auto kCheckInt = [](auto& node, SField const& field, int v) -> bool { return node.isMember(field.fieldName) && ((node[field.fieldName].isInt() && node[field.fieldName] == json::Int(v)) || (node[field.fieldName].isUInt() && node[field.fieldName] == json::UInt(v))); @@ -4297,31 +4615,30 @@ class Vault_test : public beast::unit_test::Suite BEAST_EXPECT(vault["LedgerEntryType"].asString() == "Vault"); BEAST_EXPECT(vault[jss::index].asString() == strHex(keylet.key)); - BEAST_EXPECT(kCHECK_INT(vault, sfFlags, 0)); + BEAST_EXPECT(kCheckInt(vault, sfFlags, 0)); // Ignore all other standard fields, this test doesn't care - BEAST_EXPECT(kCHECK_STRING(vault, sfAccount, toBase58(sle->at(sfAccount)))); - BEAST_EXPECT(kCHECK_OBJECT(vault, sfAsset, toJson(sle->at(sfAsset)))); - BEAST_EXPECT(kCHECK_STRING(vault, sfAssetsAvailable, "50")); - BEAST_EXPECT(kCHECK_STRING(vault, sfAssetsMaximum, "1000")); - BEAST_EXPECT(kCHECK_STRING(vault, sfAssetsTotal, "50")); + BEAST_EXPECT(kCheckString(vault, sfAccount, toBase58(sle->at(sfAccount)))); + BEAST_EXPECT(kCheckObject(vault, sfAsset, toJson(sle->at(sfAsset)))); + BEAST_EXPECT(kCheckString(vault, sfAssetsAvailable, "50")); + BEAST_EXPECT(kCheckString(vault, sfAssetsMaximum, "1000")); + BEAST_EXPECT(kCheckString(vault, sfAssetsTotal, "50")); BEAST_EXPECT(!vault.isMember(sfLossUnrealized.getJsonName())); auto const strShareID = strHex(sle->at(sfShareMPTID)); - BEAST_EXPECT(kCHECK_STRING(vault, sfShareMPTID, strShareID)); - BEAST_EXPECT(kCHECK_STRING(vault, sfOwner, toBase58(owner.id()))); - BEAST_EXPECT(kCHECK_INT(vault, sfSequence, sequence)); - BEAST_EXPECT( - kCHECK_INT(vault, sfWithdrawalPolicy, kVAULT_STRATEGY_FIRST_COME_FIRST_SERVE)); + BEAST_EXPECT(kCheckString(vault, sfShareMPTID, strShareID)); + BEAST_EXPECT(kCheckString(vault, sfOwner, toBase58(owner.id()))); + BEAST_EXPECT(kCheckInt(vault, sfSequence, sequence)); + BEAST_EXPECT(kCheckInt(vault, sfWithdrawalPolicy, kVaultStrategyFirstComeFirstServe)); if (issuance.isObject()) { BEAST_EXPECT(issuance["LedgerEntryType"].asString() == "MPTokenIssuance"); BEAST_EXPECT(issuance[jss::mpt_issuance_id].asString() == strShareID); - BEAST_EXPECT(kCHECK_INT(issuance, sfSequence, 1)); - BEAST_EXPECT(kCHECK_INT( + BEAST_EXPECT(kCheckInt(issuance, sfSequence, 1)); + BEAST_EXPECT(kCheckInt( issuance, sfFlags, int(lsfMPTCanEscrow | lsfMPTCanTrade | lsfMPTCanTransfer))); - BEAST_EXPECT(kCHECK_STRING(issuance, sfOutstandingAmount, "50000000")); + BEAST_EXPECT(kCheckString(issuance, sfOutstandingAmount, "50000000")); } }; @@ -4654,7 +4971,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); @@ -4715,10 +5032,10 @@ class Vault_test : public beast::unit_test::Suite // Create a simple Loan for the full amount of Vault assets env(set(depositor, brokerKeylet.key, asset(100).value()), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -4896,7 +5213,7 @@ class Vault_test : public beast::unit_test::Suite testCase(iou, "IOU (owner is issuer)", issuer, depositor); // Test MPT - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); PrettyAsset const mpt = mptt.issuanceID(); mptt.authorize({.account = owner}); @@ -4915,7 +5232,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, @@ -5106,10 +5423,10 @@ class Vault_test : public beast::unit_test::Suite // Depositor borrows 40 units, reducing assetsAvailable to 60 // while assetsTotal stays at 100 env(set(depositor, brokerKeylet.key, asset(40).value()), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -5163,10 +5480,10 @@ class Vault_test : public beast::unit_test::Suite // Depositor borrows 40 units env(set(depositor, brokerKeylet.key, asset(40).value()), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -5218,10 +5535,10 @@ class Vault_test : public beast::unit_test::Suite // Depositor borrows 40 units: assetsAvailable=60, assetsTotal=100 env(set(depositor, brokerKeylet.key, asset(40).value()), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -5272,10 +5589,10 @@ class Vault_test : public beast::unit_test::Suite // Depositor borrows 40 units: assetsAvailable=60, assetsTotal=100 env(set(depositor, brokerKeylet.key, asset(40).value()), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -5320,10 +5637,10 @@ class Vault_test : public beast::unit_test::Suite // Depositor borrows all 100 units: assetsAvailable=0, assetsTotal=100 env(set(depositor, brokerKeylet.key, asset(100).value()), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -5392,7 +5709,7 @@ class Vault_test : public beast::unit_test::Suite testCase(iou, "IOU", owner, depositor, issuer); // Test MPT - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); PrettyAsset const mpt = mptt.issuanceID(); @@ -5402,14 +5719,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); @@ -5428,10 +5745,10 @@ class Vault_test : public beast::unit_test::Suite // Depositor borrows 40 units, reducing assetsAvailable to 60 // while assetsTotal stays at 100 env(set(depositor, brokerKeylet.key, iou(40).value()), - loan::kINTEREST_RATE(TenthBips32(0)), - kGRACE_PERIOD(60), - kPAYMENT_INTERVAL(120), - kPAYMENT_TOTAL(10), + loan::kInterestRate(TenthBips32(0)), + kGracePeriod(60), + kPaymentInterval(120), + kPaymentTotal(10), Sig(sfCounterpartySignature, owner), Fee(env.current()->fees().base * 2), Ter(tesSUCCESS)); @@ -5467,7 +5784,7 @@ class Vault_test : public beast::unit_test::Suite BEAST_EXPECT(sharesAfter == sharesBefore); } - env.enableFeature(fixSecurity3_1_3); + env.enableFeature(fixCleanup3_1_3); } } @@ -5494,10 +5811,10 @@ class Vault_test : public beast::unit_test::Suite static_cast(std::numeric_limits::max()) + 1); BEAST_EXPECT(maxInt64Plus1 == "9223372036854775808"); - auto const initialXRP = to_string(kINITIAL_XRP); + auto const initialXRP = to_string(kInitialXrp); BEAST_EXPECT(initialXRP == "100000000000000000"); - auto const initialXRPPlus1 = to_string(kINITIAL_XRP + 1); + auto const initialXRPPlus1 = to_string(kInitialXrp + 1); BEAST_EXPECT(initialXRPPlus1 == "100000000000000001"); { @@ -5545,7 +5862,7 @@ class Vault_test : public beast::unit_test::Suite testcase("Assets Maximum: MPT"); PrettyAsset const mptAsset = [&]() { - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock}); env.close(); PrettyAsset const mptAsset = mptt["MPT"]; @@ -5685,7 +6002,7 @@ class Vault_test : public beast::unit_test::Suite if (!BEAST_EXPECT(vaultSle)) return; - BEAST_EXPECT(vaultSle->at(sfAssetsMaximum) == kNUM_ZERO); + BEAST_EXPECT(vaultSle->at(sfAssetsMaximum) == kNumZero); } // What _can't_ IOUs do? @@ -5737,7 +6054,7 @@ class Vault_test : public beast::unit_test::Suite env.fund(XRP(10000), issuer, owner, depositor, bob); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create( {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow}); mptt.authorize({.account = owner}); @@ -5750,8 +6067,8 @@ class Vault_test : public beast::unit_test::Suite // Escrow 60 of 100 MPT tokens: sfMPTAmount drops to 40 auto const escrowSeq = env.seq(depositor); env(escrow::create(depositor, bob, asset(60)), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -5779,8 +6096,8 @@ class Vault_test : public beast::unit_test::Suite // Clean up escrow env(escrow::finish(bob, depositor, escrowSeq), - escrow::kCONDITION(escrow::kCB1), - escrow::kFULFILLMENT(escrow::kFB1), + escrow::kCondition(escrow::kCb1), + escrow::kFulfillment(escrow::kFb1), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -5799,7 +6116,7 @@ class Vault_test : public beast::unit_test::Suite env.fund(XRP(10000), issuer, owner, depositor, bob); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create( {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow}); mptt.authorize({.account = owner}); @@ -5839,8 +6156,8 @@ class Vault_test : public beast::unit_test::Suite // Escrow 60% of shares auto const escrowAmount = shares(Number{6, vaultSle->at(sfScale) + 1}); env(escrow::create(depositor, bob, escrowAmount), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -5866,7 +6183,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"}; @@ -5876,7 +6193,7 @@ class Vault_test : public beast::unit_test::Suite env.fund(XRP(10000), issuer, owner, depositor, bob); env.close(); - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create( {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow}); mptt.authorize({.account = owner}); @@ -5916,8 +6233,8 @@ class Vault_test : public beast::unit_test::Suite // Escrow 60% of shares auto const escrowAmount = shares(Number{6, vaultSle->at(sfScale) + 1}); env(escrow::create(depositor, bob, escrowAmount), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -5956,9 +6273,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"}; @@ -6065,7 +6382,7 @@ class Vault_test : public beast::unit_test::Suite Vault const vault{env}; // Create an MPT asset for the vault - MPTTester mptt{env, issuer, kMPT_INIT_NO_FUND}; + MPTTester mptt{env, issuer, kMptInitNoFund}; mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); PrettyAsset const asset = mptt.issuanceID(); mptt.authorize({.account = owner}); @@ -6096,8 +6413,8 @@ class Vault_test : public beast::unit_test::Suite // Escrow 500 of those shares env(escrow::create(depositor, bob, STAmount{shareIssue, 500}), - escrow::kCONDITION(escrow::kCB1), - escrow::kFINISH_TIME(env.now() + 1s), + escrow::kCondition(escrow::kCb1), + escrow::kFinishTime(env.now() + 1s), Fee(baseFee * 150), Ter(tesSUCCESS)); env.close(); @@ -6116,7 +6433,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,14 +6453,494 @@ class Vault_test : public beast::unit_test::Suite } }; - runTest(amendments - fixSecurity3_1_3); + runTest(amendments - fixCleanup3_1_3); runTest(amendments); } + void + testReferenceHolding() + { + using namespace test::jtx; + + auto readReferenceHolding = [&](Env const& env, + Keylet const& vaultKeylet) -> std::optional { + auto const sleVault = env.le(vaultKeylet); + if (!sleVault) + return std::nullopt; + auto const sleIssuance = env.le(keylet::mptIssuance(sleVault->at(sfShareMPTID))); + if (!sleIssuance || !sleIssuance->isFieldPresent(sfReferenceHolding)) + return std::nullopt; + return sleIssuance->getFieldH256(sfReferenceHolding); + }; + + // Post-fixCleanup3_2_0: vault share carries sfReferenceHolding + // pointing to the vault pseudo's MPToken (for MPT-backed vaults) + // or RippleState (for IOU-backed vaults). + { + testcase("sfReferenceHolding: MPT-backed vault, post-amendment"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + env.fund(XRP(10'000), issuer, owner); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + auto const sleVault = env.le(keylet); + BEAST_EXPECT(sleVault != nullptr); + auto const pseudoId = sleVault->at(sfAccount); + auto const expected = keylet::mptoken(mptt.issuanceID(), pseudoId).key; + + auto const stored = readReferenceHolding(env, keylet); + BEAST_EXPECT(stored.has_value()); + BEAST_EXPECT(stored && *stored == expected); + // The pointed-to MPToken must actually exist. + BEAST_EXPECT(env.le(keylet::mptoken(mptt.issuanceID(), pseudoId)) != nullptr); + } + + { + testcase("sfReferenceHolding: IOU-backed vault, post-amendment"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + env.fund(XRP(10'000), issuer, owner); + env(fset(issuer, asfDefaultRipple)); + env.close(); + + PrettyAsset const asset = issuer["IOU"]; + env.trust(asset(1'000'000), owner); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + auto const sleVault = env.le(keylet); + BEAST_EXPECT(sleVault != nullptr); + auto const pseudoId = sleVault->at(sfAccount); + auto const expected = keylet::line(pseudoId, asset.raw().get()).key; + + auto const stored = readReferenceHolding(env, keylet); + BEAST_EXPECT(stored.has_value()); + BEAST_EXPECT(stored && *stored == expected); + // The pointed-to RippleState must actually exist. + BEAST_EXPECT(env.le(keylet::line(pseudoId, asset.raw().get())) != nullptr); + } + + // XRP-backed vaults leave the field absent: XRP has no separate + // holding ledger entry and no transferability concept to inherit. + { + testcase("sfReferenceHolding: XRP-backed vault, field absent"); + Env env{*this, testableAmendments()}; + Account const owner{"owner"}; + env.fund(XRP(10'000), owner); + env.close(); + + PrettyAsset const asset{xrpIssue(), 1'000'000}; + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + BEAST_EXPECT(!readReferenceHolding(env, keylet).has_value()); + } + + // Pre-fixCleanup3_2_0: vault share has the field absent regardless + // of underlying type. + { + testcase("sfReferenceHolding: vault share, pre-amendment"); + Env env{*this, testableAmendments() - fixCleanup3_2_0}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + env.fund(XRP(10'000), issuer, owner); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + BEAST_EXPECT(!readReferenceHolding(env, keylet).has_value()); + } + + // Plain MPTokenIssuanceCreate (not a vault share) must never + // populate the field. Only the post-amendment case is + // interesting; pre-amendment nothing writes the field at all. + { + testcase("sfReferenceHolding: plain MPT issuance never set"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + env.fund(XRP(10'000), issuer); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); + env.close(); + + auto const sleIssuance = env.le(keylet::mptIssuance(mptt.issuanceID())); + if (BEAST_EXPECT(sleIssuance)) + BEAST_EXPECT(!sleIssuance->isFieldPresent(sfReferenceHolding)); + } + } + + // Probe every transactor surface that might delete the vault pseudo- + // account's underlying holding (the MPToken or RippleState pointed to + // by sfReferenceHolding). Each scenario asserts either that the + // existing pseudo-account guards stop the deletion at preclaim, or + // that the ledger leaves the holding intact afterwards. This is a + // regression guard: if any of these guards regresses, the share's + // sfReferenceHolding pointer would dangle and the new ValidMPTIssuance + // invariant would catch it - but we want to fail much earlier, at + // the transactor's preclaim / doApply, not at invariant time. + void + testHoldingDeletionBlocked() + { + using namespace test::jtx; + + // Helper: read the share's referenced holding and confirm the + // pointed-to SLE still exists after the probe. + auto referencedHoldingExists = [&](Env const& env, Keylet const& vaultKeylet) -> bool { + auto const sleVault = env.le(vaultKeylet); + if (!sleVault) + return false; + auto const sleIssuance = env.le(keylet::mptIssuance(sleVault->at(sfShareMPTID))); + if (!sleIssuance || !sleIssuance->isFieldPresent(sfReferenceHolding)) + return false; + auto const holdingKey = sleIssuance->getFieldH256(sfReferenceHolding); + return env.le(keylet::unchecked(holdingKey)) != nullptr; + }; + + // ---- MPT-backed vault ---------------------------------------- + { + testcase("vault pseudo MPToken: Clawback blocked by tecPSEUDO_ACCOUNT"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + Account const depositor{"depositor"}; + env.fund(XRP(10'000), issuer, owner, depositor); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTCanClawback}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + mptt.authorize({.account = depositor}); + env(pay(issuer, depositor, asset(1'000))); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(500)})); + env.close(); + + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + + Account const pseudoAccount{"vault-pseudo", env.le(keylet)->at(sfAccount)}; + // Issuer attempts to claw back the FULL underlying balance + // (500) directly from the vault pseudo-account. With the + // full amount, the doApply path would drain the pseudo's + // MPToken to zero and removeEmptyHolding would erase it - + // if doApply ever ran. SAV's pseudo-account guard at + // Clawback.cpp:201 refuses at preclaim with + // tecPSEUDO_ACCOUNT before any state change. + env(claw(issuer, asset(500), pseudoAccount), Ter{tecPSEUDO_ACCOUNT}); + env.close(); + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + // Sanity: pseudo's full balance is intact. + BEAST_EXPECT(env.balance(pseudoAccount, asset).number() == 500); + } + + { + testcase("vault pseudo MPToken: Issuer cannot Unauthorize pseudo"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + env.fund(XRP(10'000), issuer, owner); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTRequireAuth}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + mptt.authorize({.account = issuer, .holder = owner}); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + + auto const pseudoId = env.le(keylet)->at(sfAccount); + // Issuer attempts MPTokenAuthorize against the pseudo with + // tfMPTUnauthorize. MPTokenAuthorize.cpp blocks pseudo + // accounts via isPseudoAccount; the pseudo's MPToken is + // preserved. Construct the tx manually since the pseudo + // lacks a signing key, and the issuer-driven flavour is + // expressed via sfHolder. + json::Value jv; + jv[sfAccount] = issuer.human(); + jv[sfHolder] = toBase58(pseudoId); + jv[sfMPTokenIssuanceID] = to_string(mptt.issuanceID()); + jv[sfFlags] = tfMPTUnauthorize; + jv[sfTransactionType] = jss::MPTokenAuthorize; + env(jv, Ter{tecNO_PERMISSION}); + env.close(); + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + } + + { + testcase("vault pseudo MPToken: MPTokenIssuanceDestroy blocked while vault holds"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + Account const depositor{"depositor"}; + env.fund(XRP(10'000), issuer, owner, depositor); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + mptt.authorize({.account = depositor}); + env(pay(issuer, depositor, asset(1'000))); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(500)})); + env.close(); + + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + + // While the vault holds outstanding underlying, the issuer + // cannot destroy the issuance. tecHAS_OBLIGATIONS confirms + // the protection - and as a side effect, the share's + // sfReferenceHolding pointer cannot be left pointing at a + // ghost issuance. + mptt.destroy({.id = mptt.issuanceID(), .err = tecHAS_OBLIGATIONS}); + env.close(); + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + } + + // ---- IOU-backed vault ---------------------------------------- + { + testcase("vault pseudo trust line: Clawback blocked by tecPSEUDO_ACCOUNT"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + env.fund(XRP(10'000), issuer, owner); + env(fset(issuer, asfAllowTrustLineClawback)); + env.close(); + + PrettyAsset const asset = issuer["IOU"]; + env.trust(asset(1'000'000), owner); + env(pay(issuer, owner, asset(1'000))); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(500)})); + env.close(); + + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + + Account const pseudoAccount{"vault-pseudo", env.le(keylet)->at(sfAccount)}; + // Issuer attempts to claw back the FULL IOU balance (500) + // directly from the vault pseudo. With the full amount, the + // doApply path would drain the trust line to zero and (if + // both reserve flags clear) trustDelete would erase it - if + // doApply ever ran. The same SAV pseudo-account guard + // refuses at preclaim with tecPSEUDO_ACCOUNT. The amount's + // STAmount issuer field is the holder, per IOU clawback + // convention. + env(claw(issuer, pseudoAccount["IOU"](500)), Ter{tecPSEUDO_ACCOUNT}); + env.close(); + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + // Sanity: pseudo's full balance is intact. + BEAST_EXPECT(env.balance(pseudoAccount, asset).number() == 500); + } + + { + testcase("vault pseudo trust line: TrustSet limit=0 from issuer preserves line"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + env.fund(XRP(10'000), issuer, owner); + env(fset(issuer, asfDefaultRipple)); + env.close(); + + PrettyAsset const asset = issuer["IOU"]; + env.trust(asset(1'000'000), owner); + env(pay(issuer, owner, asset(1'000))); + env.close(); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(500)})); + env.close(); + + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + + // Issuer submits TrustSet with limit=0 against the vault + // pseudo. The pseudo's side of the line still has the + // original (non-zero) limit and a non-zero balance, so the + // line is preserved - even though the issuer cleared its + // own side. trustDelete only fires when both limits clear + // and the balance is zero. + Account const pseudoAccount{"vault-pseudo", env.le(keylet)->at(sfAccount)}; + env(trust(issuer, pseudoAccount["IOU"](0))); + env.close(); + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + } + + // ---- Positive control: VaultDelete is the only legitimate path + { + testcase("vault pseudo holding: VaultDelete is the legitimate cleanup path"); + Env env{*this, testableAmendments()}; + Account const issuer{"issuer"}; + Account const owner{"owner"}; + env.fund(XRP(10'000), issuer, owner); + env.close(); + + MPTTester mptt{env, issuer, kMptInitNoFund}; + mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock}); + PrettyAsset const asset = mptt.issuanceID(); + mptt.authorize({.account = owner}); + + Vault const vault{env}; + auto [tx, keylet] = vault.create({.owner = owner, .asset = asset}); + env(tx); + env.close(); + + BEAST_EXPECT(referencedHoldingExists(env, keylet)); + auto const pseudoId = env.le(keylet)->at(sfAccount); + auto const sharedMptId = env.le(keylet)->at(sfShareMPTID); + auto const holdingKeylet = keylet::mptoken(mptt.issuanceID(), pseudoId); + + // VaultDelete tears down the vault pseudo's holding, the + // share issuance, and the pseudo-account itself. Invariant + // permits this because the tx is ttVAULT_DELETE. + env(vault.del({.owner = owner, .id = keylet.key})); + env.close(); + + BEAST_EXPECT(env.le(keylet) == nullptr); + BEAST_EXPECT(env.le(holdingKeylet) == nullptr); + BEAST_EXPECT(env.le(keylet::mptIssuance(sharedMptId)) == nullptr); + } + } + + // VaultDeposit::preclaim uses accountHolds(..., SpendableHandling:: + // shFULL_BALANCE), which for an IOU asset adds the counterparty's + // LowLimit/HighLimit to the depositor's raw balance (TokenHelpers.cpp: + // getTrustLineBalance with includeOppositeLimit=true). When the + // depositor's raw balance < deposit amount but raw + opposite limit >= + // amount, preclaim is satisfied. doApply then calls + // directSendNoFeeIOU, which unconditionally subtracts saAmount from + // saBalance — driving the trust line negative — and returns tesSUCCESS. + // The post-send sanity check uses the default shSIMPLE_BALANCE (no + // opposite-limit add), sees a negative balance, and returns tefINTERNAL. + void + testVaultDepositNegativeBalanceFromOppositeLimit() + { + auto runTest = [&](FeatureBitset f, TER expected) { + using namespace test::jtx; + using namespace std::literals; + + Env env{*this, f}; + Account const gw{"gateway"}; + Account const owner{"owner"}; + Account const depositor{"depositor"}; + + env.fund(XRP(10000), gw, owner, depositor); + env.close(); + + // Gateway with DefaultRipple so vault creation on its IOU works. + env(fset(gw, asfDefaultRipple)); + env.close(); + + // Depositor opens a trust line to gateway and receives a small + // balance. + PrettyAsset const usd = gw["USD"]; + env.trust(usd(1000), depositor); + env(pay(gw, depositor, usd(100))); // raw trust-line balance: 100 + env.close(); + + // Key precondition: gateway sets a non-zero limit on the same + // RippleState — the "opposite field" from depositor's perspective. + // This is what inflates shFULL_BALANCE in preclaim above the raw + // balance. + env(trust(gw, depositor["USD"](1000))); + env.close(); + + // Create the IOU vault. + Vault const vault{env}; + auto [vaultTx, keylet] = vault.create({.owner = owner, .asset = usd}); + env(vaultTx); + env.close(); + + // Submit a deposit of 500 USD: + // - raw balance: 100 USD + // - opposite limit (gw's side): 1000 USD + // - preclaim sees 100 + 1000 = 1100, passes (>= 500) + // - doApply transfers 500, depositor's trust-line balance + // becomes -400 + // - sanity check at VaultDeposit.cpp:256 fires + // - tx returns tefINTERNAL (BUG — should be tesSUCCESS. + auto depositTx = + vault.deposit({.depositor = depositor, .id = keylet.key, .amount = usd(500)}); + env(depositTx, Ter(expected)); + env.close(); + }; + + { + testcase( + "IOU vault deposit exceeding depositor's balance but " + "within counterparty's trust limit, pre-fixCleanup3_2_0 " + "(tefINTERNAL)"); + runTest(test::jtx::testableAmendments() - fixCleanup3_2_0, tefINTERNAL); + } + { + testcase( + "IOU vault deposit exceeding depositor's balance but " + "within counterparty's trust limit, post-fixCleanup3_2_0 " + "(tesSUCCESS)"); + runTest(test::jtx::testableAmendments(), tesSUCCESS); + } + } + public: void run() override { + testVaultDepositNegativeBalanceFromOppositeLimit(); testSequences(); testPreflight(); testCreateFailXRP(); @@ -6163,6 +6960,8 @@ public: testAssetsMaximum(); testBug6LimitBypassWithShares(); testRemoveEmptyHoldingLockedAmount(); + testReferenceHolding(); + testHoldingDeletionBlocked(); } }; diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp index a8899e4e43..0198a36e96 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) { } @@ -231,7 +231,7 @@ struct XEnv : public jtx::XChainBridgeObjects, public SEnv this->fund(xrpFunds, s.account); // Signer's list must match the attestation signers - // env_(jtx::signers(Account::kMASTER, quorum, signers)); + // env_(jtx::signers(Account::kMaster, quorum, signers)); } this->close(); } @@ -266,8 +266,8 @@ struct BalanceTransfer balance from; balance to; - balance payer; // pays the rewards - std::vector reward_accounts; // receives the reward + balance payer; // pays the rewards + std::vector rewardAccounts; // receives the reward XRPAmount txFees; BalanceTransfer( @@ -281,7 +281,7 @@ struct BalanceTransfer : from(env, fromAcct) , to(env, toAcct) , payer(env, payer) - , reward_accounts([&]() { + , rewardAccounts([&]() { std::vector r; r.reserve(numPayees); for (size_t i = 0; i < numPayees; ++i) @@ -306,7 +306,7 @@ struct BalanceTransfer [[nodiscard]] bool payeesReceived(STAmount const& reward) const { - return std::all_of(reward_accounts.begin(), reward_accounts.end(), [&](balance const& b) { + return std::all_of(rewardAccounts.begin(), rewardAccounts.end(), [&](balance const& b) { return b.diff() == reward; }); } @@ -320,7 +320,7 @@ struct BalanceTransfer bool hasHappened(STAmount const& amt, STAmount const& reward, bool checkPayer = true) { - auto rewardCost = multiply(reward, STAmount(reward_accounts.size()), reward.asset()); + auto rewardCost = multiply(reward, STAmount(rewardAccounts.size()), reward.asset()); return checkMostBalances(amt, reward) && (!checkPayer || payer.diff() == -(rewardCost + txFees)); } @@ -500,7 +500,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // disabled. { Env env(*this, testableAmendments() - featureXChainBridge); - env(createBridge(Account::kMASTER, jvb), Ter(temDISABLED)); + env(createBridge(Account::kMaster, jvb), Ter(temDISABLED)); } // coverage test: BridgeCreate::preclaim() returns tecNO_ISSUER. @@ -772,7 +772,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj "Issuing chain is XRP and issuing chain door account is " "the root account ", [&](auto& env, bool) { - b = Account::kMASTER; + b = Account::kMaster; ib = xrpIssue(); })}; @@ -974,8 +974,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -987,11 +987,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); scEnv @@ -1007,7 +1007,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj scEnv.tx(xchainClaim(scAlice, jvb, claimID, amt, scBob)).close(); } - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum)); } // Check that the reward paid from a claim Id was the reward when @@ -1020,8 +1020,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1033,15 +1033,15 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // Now modify the reward on the bridge mcEnv.tx(bridgeModify(mcDoor, jvb, XRP(2), XRP(10))).close(); - scEnv.tx(bridgeModify(Account::kMASTER, jvb, XRP(2), XRP(10))).close(); + scEnv.tx(bridgeModify(Account::kMaster, jvb, XRP(2), XRP(10))).close(); BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); scEnv @@ -1059,7 +1059,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // make sure the reward accounts indeed received the original // split reward (1 split 5 ways) instead of the updated 2 XRP. - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum)); } // Check that the signatures used to verify attestations and decide @@ -1073,8 +1073,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1086,15 +1086,15 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // change signers - claim should not be processed is the batch // is signed by original signers - scEnv.tx(jtx::signers(Account::kMASTER, quorum, alt_signers)).close(); + scEnv.tx(jtx::signers(Account::kMaster, quorum, altSigners)).close(); BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); // submit claim using outdated signers - should fail @@ -1120,7 +1120,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // submit claim using current signers - should succeed scEnv .multiTx(claimAttestations( - scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, alt_signers)) + scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, altSigners)) .close(); if (withClaim) { @@ -1132,7 +1132,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // make sure the transfer went through as we sent attestations // using new signers - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum, false)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum, false)); } // coverage test: bridge_modify transaction with incorrect flag @@ -1191,7 +1191,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // normal bridge create for sanity check with the exact necessary // account balance XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) + .tx(createBridge(Account::kMaster, jvb)) .fund(res1, scuAlice) // acct reserve + 1 object .close() .tx(xchainCreateClaimId(scuAlice, jvb, reward, mcAlice)) @@ -1203,7 +1203,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj test::Balance const scAliceBal(xenv, scAlice); - xenv.tx(createBridge(Account::kMASTER, jvb)) + xenv.tx(createBridge(Account::kMaster, jvb)) .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1219,8 +1219,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // Creating the new object would put the account below the reserve XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) - .fund(res1 - xrp_dust, scuAlice) // barely not enough + .tx(createBridge(Account::kMaster, jvb)) + .fund(res1 - xrpDust, scuAlice) // barely not enough .close() .tx(xchainCreateClaimId(scuAlice, jvb, reward, mcAlice), Ter(tecINSUFFICIENT_RESERVE)) .close(); @@ -1229,15 +1229,15 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // by giving the reward amount for the other side, as well as a // completely non-matching reward) XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) + .tx(createBridge(Account::kMaster, jvb)) .close() - .tx(xchainCreateClaimId(scAlice, jvb, split_reward_quorum, mcAlice), + .tx(xchainCreateClaimId(scAlice, jvb, splitRewardQuorum, mcAlice), Ter(tecXCHAIN_REWARD_MISMATCH)) .close(); // A reward amount that isn't XRP XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) + .tx(createBridge(Account::kMaster, jvb)) .close() .tx(xchainCreateClaimId(scAlice, jvb, mcUSD(1), mcAlice), Ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT)) @@ -1246,7 +1246,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // coverage test: xchain_create_claim_id transaction with incorrect // flag XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) + .tx(createBridge(Account::kMaster, jvb)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice), Txflags(tfFillOrKill), @@ -1256,7 +1256,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // coverage test: xchain_create_claim_id transaction with xchain // feature disabled XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) + .tx(createBridge(Account::kMaster, jvb)) .disableFeature(featureXChainBridge) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice), Ter(temDISABLED)) @@ -1273,7 +1273,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj testcase("Commit"); // Commit to a non-existent bridge - XEnv(*this).tx(xchainCommit(mcAlice, jvb, 1, one_xrp, scBob), Ter(tecNO_ENTRY)); + XEnv(*this).tx(xchainCommit(mcAlice, jvb, 1, oneXrp, scBob), Ter(tecNO_ENTRY)); // check that reward not deducted when doing the commit { @@ -1309,17 +1309,17 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // reserve (if XRP) XEnv(*this) .tx(createBridge(mcDoor, jvb)) - .fund(res0 + one_xrp - xrp_dust, mcuAlice) // barely not enough + .fund(res0 + oneXrp - xrpDust, mcuAlice) // barely not enough .close() - .tx(xchainCommit(mcuAlice, jvb, 1, one_xrp, scBob), Ter(tecUNFUNDED_PAYMENT)); + .tx(xchainCommit(mcuAlice, jvb, 1, oneXrp, scBob), Ter(tecUNFUNDED_PAYMENT)); XEnv(*this) .tx(createBridge(mcDoor, jvb)) .fund( - res0 + one_xrp + xrp_dust, // "xrp_dust" for tx fees - mcuAlice) // exactly enough => should succeed + res0 + oneXrp + xrpDust, // "xrp_dust" for tx fees + mcuAlice) // exactly enough => should succeed .close() - .tx(xchainCommit(mcuAlice, jvb, 1, one_xrp, scBob)); + .tx(xchainCommit(mcuAlice, jvb, 1, oneXrp, scBob)); // Commit an amount above the account's balance (for both XRP and // IOUs) @@ -1327,7 +1327,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj .tx(createBridge(mcDoor, jvb)) .fund(res0, mcuAlice) // barely not enough .close() - .tx(xchainCommit(mcuAlice, jvb, 1, res0 + one_xrp, scBob), Ter(tecUNFUNDED_PAYMENT)); + .tx(xchainCommit(mcuAlice, jvb, 1, res0 + oneXrp, scBob), Ter(tecUNFUNDED_PAYMENT)); auto jvbUsd = bridge(mcDoor, mcUSD, scGw, scUSD); @@ -1377,7 +1377,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj XEnv(*this) .tx(createBridge(mcDoor)) .close() - .tx(xchainCommit(mcAlice, jvb, 1, one_xrp, scBob), + .tx(xchainCommit(mcAlice, jvb, 1, oneXrp, scBob), Txflags(tfFillOrKill), Ter(temINVALID_FLAG)); @@ -1387,7 +1387,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj .tx(createBridge(mcDoor)) .disableFeature(featureXChainBridge) .close() - .tx(xchainCommit(mcAlice, jvb, 1, one_xrp, scBob), Ter(temDISABLED)); + .tx(xchainCommit(mcAlice, jvb, 1, oneXrp, scBob), Ter(temDISABLED)); } void @@ -1417,8 +1417,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1429,7 +1429,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj auto const amt = XRP(1000); mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); - BalanceTransfer transfer(scEnv, Account::kMASTER, scBob, scAlice, payees, withClaim); + BalanceTransfer transfer(scEnv, Account::kMaster, scBob, scAlice, payees, withClaim); scEnv .multiTx(claimAttestations( @@ -1442,7 +1442,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj claimID, dst, signers, - kUT_XCHAIN_DEFAULT_QUORUM)) + kUtXchainDefaultQuorum)) .close(); scEnv .tx(claimAttestation( @@ -1450,11 +1450,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj jvb, mcAlice, amt, - payees[kUT_XCHAIN_DEFAULT_QUORUM], + payees[kUtXchainDefaultQuorum], true, claimID, dst, - signers[kUT_XCHAIN_DEFAULT_QUORUM])) + signers[kUtXchainDefaultQuorum])) .close(); if (withClaim) @@ -1467,7 +1467,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BEAST_EXPECT(scEnv.claimID(jvb) == claimID); } - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_everyone)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardEveryone)); } // Test that signature weights are correctly handled. Assign @@ -1483,12 +1483,12 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const quorum7 = 7; std::vector const signers = [] { - constexpr int kNUM_SIGNERS = 4; + static constexpr int kNumSigners = 4; std::uint32_t const weights[] = {1, 2, 4, 4}; std::vector result; - result.reserve(kNUM_SIGNERS); - for (int i = 0; i < kNUM_SIGNERS; ++i) + result.reserve(kNumSigners); + for (int i = 0; i < kNumSigners; ++i) { using namespace std::literals; auto const a = Account("signer_"s + std::to_string(i)); @@ -1499,8 +1499,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum7, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum7, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1513,7 +1513,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); BalanceTransfer transfer( - scEnv, Account::kMASTER, scBob, scAlice, &payees[0], 3, withClaim); + scEnv, Account::kMaster, scBob, scAlice, &payees[0], 3, withClaim); scEnv .multiTx(claimAttestations( @@ -1541,12 +1541,12 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const quorum7 = 7; std::vector const signers = [] { - constexpr int kNUM_SIGNERS = 4; + static constexpr int kNumSigners = 4; std::uint32_t const weights[] = {1, 2, 4, 4}; std::vector result; - result.reserve(kNUM_SIGNERS); - for (int i = 0; i < kNUM_SIGNERS; ++i) + result.reserve(kNumSigners); + for (int i = 0; i < kNumSigners; ++i) { using namespace std::literals; auto const a = Account("signer_"s + std::to_string(i)); @@ -1558,8 +1558,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum7, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum7, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1572,7 +1572,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); BalanceTransfer transfer( - scEnv, Account::kMASTER, scBob, scAlice, &payees[2], 2, withClaim); + scEnv, Account::kMaster, scBob, scAlice, &payees[2], 2, withClaim); scEnv .multiTx(claimAttestations( @@ -1600,12 +1600,12 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const quorum7 = 7; std::vector const signers = [] { - constexpr int kNUM_SIGNERS = 4; + static constexpr int kNumSigners = 4; std::uint32_t const weights[] = {1, 2, 4, 4}; std::vector result; - result.reserve(kNUM_SIGNERS); - for (int i = 0; i < kNUM_SIGNERS; ++i) + result.reserve(kNumSigners); + for (int i = 0; i < kNumSigners; ++i) { using namespace std::literals; auto const a = Account("signer_"s + std::to_string(i)); @@ -1616,8 +1616,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum7, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum7, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1630,7 +1630,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); BalanceTransfer transfer( - scEnv, Account::kMASTER, scBob, scAlice, &payees[0], 2, withClaim); + scEnv, Account::kMaster, scBob, scAlice, &payees[0], 2, withClaim); scEnv .multiTx(claimAttestations( @@ -1659,12 +1659,12 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const quorum7 = 7; std::vector const signers = [] { - constexpr int kNUM_SIGNERS = 4; + static constexpr int kNumSigners = 4; std::uint32_t const weights[] = {1, 2, 4, 4}; std::vector result; - result.reserve(kNUM_SIGNERS); - for (int i = 0; i < kNUM_SIGNERS; ++i) + result.reserve(kNumSigners); + for (int i = 0; i < kNumSigners; ++i) { using namespace std::literals; auto const a = Account("signer_"s + std::to_string(i)); @@ -1675,8 +1675,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum7, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum7, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -1690,7 +1690,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); BalanceTransfer transfer( - scEnv, Account::kMASTER, scBob, scAlice, &payees[1], 2, withClaim); + scEnv, Account::kMaster, scBob, scAlice, &payees[1], 2, withClaim); scEnv .multiTx(claimAttestations( @@ -1738,15 +1738,15 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BEAST_EXPECT(carol.diff() == -(amt + reward + fee)); } - scEnv.tx(createBridge(Account::kMASTER, jvb, reward, XRP(20))) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb, reward, XRP(20))) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close(); { // send first batch of account create attest for all 3 // account create test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(1, amt, scuAlice, 2)) .multiTx(attCreateAcctVec(3, amt, scuCarol, 2)) @@ -1767,7 +1767,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // complete attestations for 2nd account create => should // not complete test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(2, amt, scuBob, 3, 2)).close(); @@ -1783,7 +1783,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // complete attestations for 3rd account create => should // not complete test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(3, amt, scuCarol, 3, 2)).close(); @@ -1799,7 +1799,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // complete attestations for 1st account create => account // should be created test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(1, amt, scuAlice, 3, 1)).close(); @@ -1818,7 +1818,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // resend attestations for 3rd account create => still // should not complete test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(3, amt, scuCarol, 3, 2)).close(); @@ -1835,7 +1835,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // resend attestations for 2nd account create => account // should be created test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(2, amt, scuBob, 1)).close(); @@ -1851,7 +1851,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // resend attestations for 3rc account create => account // should be created test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(3, amt, scuCarol, 1)).close(); @@ -1885,12 +1885,12 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BEAST_EXPECT(carol.diff() == -(amtPlusReward + fee)); } - scEnv.tx(createBridge(Account::kMASTER, jvb, reward, XRP(20))) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb, reward, XRP(20))) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close(); test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); scEnv.multiTx(attCreateAcctVec(1, amt, scuAlice, 2)).close(); BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present @@ -1926,12 +1926,12 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BEAST_EXPECT(carol.diff() == -(amtPlusReward + fee)); } - scEnv.tx(createBridge(Account::kMASTER, jvb, reward, XRP(20))) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb, reward, XRP(20))) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close(); test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); test::Balance const alice(scEnv, scAlice); scEnv.multiTx(attCreateAcctVec(1, amt, scAlice, 2)).close(); @@ -1968,13 +1968,13 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BEAST_EXPECT(carol.diff() == -(amtPlusReward + fee)); } - scEnv.tx(createBridge(Account::kMASTER, jvb, reward, XRP(20))) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb, reward, XRP(20))) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .tx(fset("scAlice", asfDepositAuth)) // set deposit auth .close(); test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); test::Balance const alice(scEnv, scAlice); scEnv.multiTx(attCreateAcctVec(1, amt, scAlice, 2)).close(); @@ -2020,13 +2020,13 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj } std::uint32_t const redQuorum = 2; - scEnv.tx(createBridge(Account::kMASTER, jvb, reward, XRP(20))) - .tx(jtx::signers(Account::kMASTER, redQuorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb, reward, XRP(20))) + .tx(jtx::signers(Account::kMaster, redQuorum, signers)) .close(); { test::Balance const attester(scEnv, scAttester); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); auto const badAmt = XRP(10); std::uint32_t txCount = 0; @@ -2105,8 +2105,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // coverage test: add_attestation transaction with incorrect flag { XEnv scEnv(*this, true); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(claimAttestation( scAttester, jvb, mcAlice, XRP(1000), payees[0], true, 1, {}, signers[0]), @@ -2119,8 +2119,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // disabled { XEnv scEnv(*this, true); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .disableFeature(featureXChainBridge) .close() .tx(claimAttestation( @@ -2144,8 +2144,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2207,13 +2207,13 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj auto const amt = XRP(1000); std::uint32_t const claimID = 1; - for (auto i = 0; i < kUT_XCHAIN_DEFAULT_NUM_SIGNERS - 2; ++i) - scEnv.fund(amt, alt_signers[i].account); + for (auto i = 0; i < kUtXchainDefaultNumSigners - 2; ++i) + scEnv.fund(amt, altSigners[i].account); mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, alt_signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, altSigners)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2225,30 +2225,30 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj { // G1: master key auto att = claimAttestation( - scAttester, jvb, mcAlice, amt, payees[0], true, claimID, dst, alt_signers[0]); + scAttester, jvb, mcAlice, amt, payees[0], true, claimID, dst, altSigners[0]); scEnv.tx(att).close(); } { // G2: regular key // alt_signers[0] is the regular key of alt_signers[1] // There should be 2 attestations after the transaction - scEnv.tx(jtx::regkey(alt_signers[1].account, alt_signers[0].account)).close(); + scEnv.tx(jtx::regkey(altSigners[1].account, altSigners[0].account)).close(); auto att = claimAttestation( - scAttester, jvb, mcAlice, amt, payees[1], true, claimID, dst, alt_signers[0]); - att[sfAttestationSignerAccount.getJsonName()] = alt_signers[1].account.human(); + scAttester, jvb, mcAlice, amt, payees[1], true, claimID, dst, altSigners[0]); + att[sfAttestationSignerAccount.getJsonName()] = altSigners[1].account.human(); scEnv.tx(att).close(); } { // B3: public key and non-exist (unfunded) account mismatch // G3: public key and non-exist (unfunded) account match - auto const unfundedSigner1 = alt_signers[kUT_XCHAIN_DEFAULT_NUM_SIGNERS - 1]; - auto const unfundedSigner2 = alt_signers[kUT_XCHAIN_DEFAULT_NUM_SIGNERS - 2]; + auto const unfundedSigner1 = altSigners[kUtXchainDefaultNumSigners - 1]; + auto const unfundedSigner2 = altSigners[kUtXchainDefaultNumSigners - 2]; auto att = claimAttestation( scAttester, jvb, mcAlice, amt, - payees[kUT_XCHAIN_DEFAULT_NUM_SIGNERS - 1], + payees[kUtXchainDefaultNumSigners - 1], true, claimID, dst, @@ -2261,7 +2261,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj { // B2: single item signer list std::vector tempSignerList = {signers[0]}; - scEnv.tx(jtx::signers(alt_signers[2].account, 1, tempSignerList)); + scEnv.tx(jtx::signers(altSigners[2].account, 1, tempSignerList)); auto att = claimAttestation( scAttester, jvb, @@ -2272,14 +2272,14 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj claimID, dst, tempSignerList.front()); - att[sfAttestationSignerAccount.getJsonName()] = alt_signers[2].account.human(); + att[sfAttestationSignerAccount.getJsonName()] = altSigners[2].account.human(); scEnv.tx(att, Ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR)).close(); } { // B1: disabled master key - scEnv.tx(fset(alt_signers[2].account, asfDisableMaster, 0)).close(); + scEnv.tx(fset(altSigners[2].account, asfDisableMaster, 0)).close(); auto att = claimAttestation( - scAttester, jvb, mcAlice, amt, payees[2], true, claimID, dst, alt_signers[2]); + scAttester, jvb, mcAlice, amt, payees[2], true, claimID, dst, altSigners[2]); scEnv.tx(att, Ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR)).close(); } { @@ -2292,11 +2292,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // --B5: missing sfAttestationSignerAccount field // Then submit the one with the field. Should reach quorum. auto att = claimAttestation( - scAttester, jvb, mcAlice, amt, payees[3], true, claimID, dst, alt_signers[3]); + scAttester, jvb, mcAlice, amt, payees[3], true, claimID, dst, altSigners[3]); att.removeMember(sfAttestationSignerAccount.getJsonName()); scEnv.tx(att, Ter(temMALFORMED)).close(); BEAST_EXPECT(dstStartBalance == scEnv.env.balance(dst)); - att[sfAttestationSignerAccount.getJsonName()] = alt_signers[3].account.human(); + att[sfAttestationSignerAccount.getJsonName()] = altSigners[3].account.human(); scEnv.tx(att).close(); BEAST_EXPECT(dstStartBalance + amt == scEnv.env.balance(dst)); } @@ -2327,13 +2327,13 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BridgeDef xrpB{ .doorA = doorA, .issueA = xrpIssue(), - .doorB = Account::kMASTER, + .doorB = Account::kMaster, .issueB = xrpIssue(), .reward = XRP(1), // reward .minAccountCreate = XRP(20), // minAccountCreate .quorum = 4, // quorum .signers = signers, - .jvb = json::NullValue}; + .jvb = json::ValueType::Null}; xrpB.initBridge(mcEnv, scEnv); @@ -2399,8 +2399,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2412,11 +2412,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); scEnv @@ -2431,7 +2431,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj scEnv.tx(xchainClaim(scAlice, jvb, claimID, amt, scBob)).close(); } - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum)); } // Claim with just one attestation signed by the Master key @@ -2445,8 +2445,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); scEnv - .tx(createBridge(Account::kMASTER, jvb)) - //.tx(jtx::signers(Account::kMASTER, quorum, signers)) + .tx(createBridge(Account::kMaster, jvb)) + //.tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2457,9 +2457,9 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); BalanceTransfer transfer( - scEnv, Account::kMASTER, scBob, scAlice, &payees[0], 1, withClaim); + scEnv, Account::kMaster, scBob, scAlice, &payees[0], 1, withClaim); - jtx::Signer const masterSigner(Account::kMASTER); + jtx::Signer const masterSigner(Account::kMaster); scEnv .tx(claimAttestation( scAttester, jvb, mcAlice, amt, payees[0], true, claimID, dst, masterSigner), @@ -2481,9 +2481,9 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); scEnv - .tx(createBridge(Account::kMASTER, jvb)) - //.tx(jtx::signers(Account::kMASTER, quorum, signers)) - .tx(jtx::regkey(Account::kMASTER, payees[0])) + .tx(createBridge(Account::kMaster, jvb)) + //.tx(jtx::signers(Account::kMaster, quorum, signers)) + .tx(jtx::regkey(Account::kMaster, payees[0])) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2494,7 +2494,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); BalanceTransfer transfer( - scEnv, Account::kMASTER, scBob, scAlice, &payees[0], 1, withClaim); + scEnv, Account::kMaster, scBob, scAlice, &payees[0], 1, withClaim); jtx::Signer const masterSigner(payees[0]); scEnv @@ -2515,10 +2515,10 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - auto jvbUnknown = bridge(mcBob, xrpIssue(), Account::kMASTER, xrpIssue()); + auto jvbUnknown = bridge(mcBob, xrpIssue(), Account::kMaster, xrpIssue()); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvbUnknown, reward, mcAlice), Ter(tecNO_ENTRY)) .close(); @@ -2529,7 +2529,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(xchainCommit(mcAlice, jvbUnknown, claimID, amt, dst), Ter(tecNO_ENTRY)) .close(); - BalanceTransfer transfer(scEnv, Account::kMASTER, scBob, scAlice, payees, withClaim); + BalanceTransfer transfer(scEnv, Account::kMaster, scBob, scAlice, payees, withClaim); scEnv .tx(claimAttestation( scAttester, @@ -2565,8 +2565,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2576,7 +2576,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const claimID = 1; mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); - BalanceTransfer transfer(scEnv, Account::kMASTER, scBob, scAlice, payees, withClaim); + BalanceTransfer transfer(scEnv, Account::kMaster, scBob, scAlice, payees, withClaim); // attest using non-existent claim id scEnv @@ -2605,8 +2605,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2618,11 +2618,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); scEnv @@ -2641,7 +2641,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj } else { - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum)); } } @@ -2654,8 +2654,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2665,7 +2665,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const claimID = 1; mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); - BalanceTransfer transfer(scEnv, Account::kMASTER, scBob, scAlice, payees, withClaim); + BalanceTransfer transfer(scEnv, Account::kMaster, scBob, scAlice, payees, withClaim); // don't send any attestations @@ -2693,8 +2693,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2704,7 +2704,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const claimID = 1; mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); - BalanceTransfer transfer(scEnv, Account::kMASTER, scBob, scAlice, payees, withClaim); + BalanceTransfer transfer(scEnv, Account::kMaster, scBob, scAlice, payees, withClaim); auto tooFew = quorum - 1; scEnv @@ -2734,8 +2734,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2745,7 +2745,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const claimID = 1; mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); - BalanceTransfer transfer(scEnv, Account::kMASTER, scBob, scAlice, payees, withClaim); + BalanceTransfer transfer(scEnv, Account::kMaster, scBob, scAlice, payees, withClaim); scEnv .multiTx( @@ -2776,8 +2776,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2789,11 +2789,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); scEnv @@ -2822,8 +2822,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -2835,11 +2835,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); scEnv @@ -2869,8 +2869,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj STAmount const hugeReward{XRP(20000)}; BEAST_EXPECT(hugeReward > scEnv.balance(scAlice)); - scEnv.tx(createBridge(Account::kMASTER, jvb, hugeReward)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb, hugeReward)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, hugeReward, mcAlice)) .close(); @@ -2882,11 +2882,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); if (withClaim) @@ -2905,7 +2905,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj { auto txns = claimAttestations( scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers); - for (int i = 0; i < kUT_XCHAIN_DEFAULT_QUORUM - 1; ++i) + for (int i = 0; i < kUtXchainDefaultQuorum - 1; ++i) { scEnv.tx(txns[i]).close(); } @@ -2931,8 +2931,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .fund( res0 + reward, scuAlice) // just not enough because of fees @@ -2946,7 +2946,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const claimID = 1; mcEnv.tx(xchainCommit(mcAlice, jvb, claimID, amt, dst)).close(); - BalanceTransfer transfer(scEnv, Account::kMASTER, scBob, scuAlice, payees, withClaim); + BalanceTransfer transfer(scEnv, Account::kMaster, scBob, scuAlice, payees, withClaim); scEnv .tx(claimAttestation( @@ -2975,8 +2975,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .tx(fset("scBob", asfDepositAuth)) // set deposit auth .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) @@ -2989,15 +2989,15 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); auto txns = claimAttestations( scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers); - for (int i = 0; i < kUT_XCHAIN_DEFAULT_QUORUM - 1; ++i) + for (int i = 0; i < kUtXchainDefaultQuorum - 1; ++i) { scEnv.tx(txns[i]).close(); } @@ -3045,8 +3045,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .tx(fset("scBob", asfRequireDest)) // set dest tag .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) @@ -3059,15 +3059,15 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); auto txns = claimAttestations( scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers); - for (int i = 0; i < kUT_XCHAIN_DEFAULT_QUORUM - 1; ++i) + for (int i = 0; i < kUtXchainDefaultQuorum - 1; ++i) { scEnv.tx(txns[i]).close(); } @@ -3116,8 +3116,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .tx(fset("scBob", asfDepositAuth)) // set deposit auth .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) @@ -3153,8 +3153,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -3166,11 +3166,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); scEnv.multiTx(claimAttestations( scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers)); @@ -3180,7 +3180,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // claim wrong amount scEnv - .tx(xchainClaim(scAlice, jvb, claimID, one_xrp, scBob), + .tx(xchainClaim(scAlice, jvb, claimID, oneXrp, scBob), Ter(tecXCHAIN_CLAIM_NO_QUORUM)) .close(); } @@ -3198,8 +3198,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcEnv.tx(createBridge(mcDoor, jvb)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -3211,11 +3211,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); test::Balance const scAliceBal(scEnv, scAlice); scEnv.multiTx(claimAttestations( @@ -3232,7 +3232,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj claimCost += fee; } - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum)); BEAST_EXPECT(scAliceBal.diff() == -claimCost); // because reward % 4 == 0 } @@ -3244,12 +3244,12 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj XEnv mcEnv(*this); XEnv scEnv(*this, true); - mcEnv.tx(createBridge(mcDoor, jvb, tiny_reward)).close(); + mcEnv.tx(createBridge(mcDoor, jvb, tinyReward)).close(); - scEnv.tx(createBridge(Account::kMASTER, jvb, tiny_reward)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb, tinyReward)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() - .tx(xchainCreateClaimId(scAlice, jvb, tiny_reward, mcAlice)) + .tx(xchainCreateClaimId(scAlice, jvb, tinyReward, mcAlice)) .close(); auto dst(withClaim ? std::nullopt : std::optional{scBob}); @@ -3259,16 +3259,16 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM, + kUtXchainDefaultQuorum, withClaim); test::Balance const scAliceBal(scEnv, scAlice); scEnv.multiTx(claimAttestations( scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers)); - STAmount claimCost = tiny_reward; + STAmount claimCost = tinyReward; if (withClaim) { @@ -3279,8 +3279,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj claimCost += fee; } - BEAST_EXPECT(transfer.hasHappened(amt, tiny_reward_split)); - BEAST_EXPECT(scAliceBal.diff() == -(claimCost - tiny_reward_remainder)); + BEAST_EXPECT(transfer.hasHappened(amt, tinyRewardSplit)); + BEAST_EXPECT(scAliceBal.diff() == -(claimCost - tinyRewardRemainder)); } // If a reward distribution fails for one of the reward accounts @@ -3298,8 +3298,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::vector altPayees{payees.begin(), payees.end() - 1}; altPayees.back() = Account("inexistent"); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -3311,11 +3311,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM - 1, + kUtXchainDefaultQuorum - 1, withClaim); scEnv.multiTx(claimAttestations( scAttester, jvb, mcAlice, amt, altPayees, true, claimID, dst, signers)); @@ -3331,7 +3331,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // this also checks that only 3 * split_reward was deducted from // scAlice (the payer account), since we passed alt_payees to // BalanceTransfer - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum)); } for (auto withClaim : {false, true}) @@ -3340,9 +3340,9 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj XEnv scEnv(*this, true); mcEnv.tx(createBridge(mcDoor, jvb)).close(); - auto& unpaid = payees[kUT_XCHAIN_DEFAULT_QUORUM - 1]; - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + auto& unpaid = payees[kUtXchainDefaultQuorum - 1]; + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .tx(fset(unpaid, asfDepositAuth)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) @@ -3361,11 +3361,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj BalanceTransfer transfer( scEnv, - Account::kMASTER, + Account::kMaster, scBob, scAlice, &payees[0], - kUT_XCHAIN_DEFAULT_QUORUM - 1, + kUtXchainDefaultQuorum - 1, withClaim); scEnv.multiTx(claimAttestations( scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers)); @@ -3381,7 +3381,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // this also checks that only 3 * split_reward was deducted from // scAlice (the payer account), since we passed payees.size() - // 1 to BalanceTransfer - BEAST_EXPECT(transfer.hasHappened(amt, split_reward_quorum)); + BEAST_EXPECT(transfer.hasHappened(amt, splitRewardQuorum)); // and make sure the account with deposit auth received nothing BEAST_EXPECT(lastSigner.diff() == STAmount(0)); @@ -3389,7 +3389,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // coverage test: xchain_claim transaction with incorrect flag XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) + .tx(createBridge(Account::kMaster, jvb)) .close() .tx(xchainClaim(scAlice, jvb, 1, XRP(1000), scBob), Txflags(tfFillOrKill), @@ -3399,7 +3399,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // coverage test: xchain_claim transaction with xchain feature // disabled XEnv(*this, true) - .tx(createBridge(Account::kMASTER, jvb)) + .tx(createBridge(Account::kMaster, jvb)) .disableFeature(featureXChainBridge) .close() .tx(xchainClaim(scAlice, jvb, 1, XRP(1000), scBob), Ter(temDISABLED)) @@ -3427,21 +3427,21 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj auto const amt = XRP(111); auto const amtPlusReward = amt + reward; - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close(); - test::Balance const door(scEnv, Account::kMASTER); + test::Balance const door(scEnv, Account::kMaster); // scEnv.tx(att_create_acct_batch1(1, amt, - // Account::kMASTER)).close(); - scEnv.multiTx(attCreateAcctVec(1, amt, Account::kMASTER, 2)).close(); + // Account::kMaster)).close(); + scEnv.multiTx(attCreateAcctVec(1, amt, Account::kMaster, 2)).close(); BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present BEAST_EXPECT(scEnv.claimCount(jvb) == 0); // claim count is one less // scEnv.tx(att_create_acct_batch2(1, amt, - // Account::kMASTER)).close(); - scEnv.multiTx(attCreateAcctVec(1, amt, Account::kMASTER, 2, 2)).close(); + // Account::kMaster)).close(); + scEnv.multiTx(attCreateAcctVec(1, amt, Account::kMaster, 2, 2)).close(); BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted BEAST_EXPECT(scEnv.claimCount(jvb) == 1); // claim count was incremented @@ -3578,17 +3578,17 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj // commit where the fee dips into the reserve, this should succeed XEnv(*this) .tx(createBridge(mcDoor, jvb)) - .fund(res0 + one_xrp + fee - drops(1), mcuAlice) + .fund(res0 + oneXrp + fee - drops(1), mcuAlice) .close() - .tx(xchainCommit(mcuAlice, jvb, 1, one_xrp, scBob), Ter(tesSUCCESS)); + .tx(xchainCommit(mcuAlice, jvb, 1, oneXrp, scBob), Ter(tesSUCCESS)); // commit where the commit amount drips into the reserve, this should // fail XEnv(*this) .tx(createBridge(mcDoor, jvb)) - .fund(res0 + one_xrp - drops(1), mcuAlice) + .fund(res0 + oneXrp - drops(1), mcuAlice) .close() - .tx(xchainCommit(mcuAlice, jvb, 1, one_xrp, scBob), Ter(tecUNFUNDED_PAYMENT)); + .tx(xchainCommit(mcuAlice, jvb, 1, oneXrp, scBob), Ter(tecUNFUNDED_PAYMENT)); auto const minAccountCreate = XRP(20); @@ -3639,7 +3639,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj { XEnv scEnv(*this, true); - scEnv.tx(createBridge(Account::kMASTER, jvb)) + scEnv.tx(createBridge(Account::kMaster, jvb)) .close() .tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)) .close(); @@ -3666,8 +3666,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj std::uint32_t const claimID = 1; std::optional const dst{scBob}; auto const amt = XRP(1000); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close(); scEnv.tx(xchainCreateClaimId(scAlice, jvb, reward, mcAlice)).close(); auto jvAtt = claimAttestation( @@ -3675,11 +3675,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj jvb, mcAlice, amt, - payees[kUT_XCHAIN_DEFAULT_QUORUM], + payees[kUtXchainDefaultQuorum], true, claimID, dst, - signers[kUT_XCHAIN_DEFAULT_QUORUM]); + signers[kUtXchainDefaultQuorum]); { // Change to an invalid keytype auto k = jvAtt["PublicKey"].asString(); @@ -3696,8 +3696,8 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj Account const dst{scBob}; auto const amt = XRP(1000); auto const rewardAmt = XRP(1); - scEnv.tx(createBridge(Account::kMASTER, jvb)) - .tx(jtx::signers(Account::kMASTER, quorum, signers)) + scEnv.tx(createBridge(Account::kMaster, jvb)) + .tx(jtx::signers(Account::kMaster, quorum, signers)) .close(); auto jvAtt = createAccountAttestation( scAttester, @@ -3705,11 +3705,11 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj mcAlice, amt, rewardAmt, - payees[kUT_XCHAIN_DEFAULT_QUORUM], + payees[kUtXchainDefaultQuorum], true, createCount, dst, - signers[kUT_XCHAIN_DEFAULT_QUORUM]); + signers[kUtXchainDefaultQuorum]); { // Change to an invalid keytype auto k = jvAtt["PublicKey"].asString(); @@ -3746,7 +3746,7 @@ struct XChain_test : public beast::unit_test::Suite, public jtx::XChainBridgeObj struct XChainSim_test : public beast::unit_test::Suite, public jtx::XChainBridgeObjects { private: - static constexpr size_t kNUM_SIGNERS = 5; + static constexpr size_t kNumSigners = 5; // -------------------------------------------------- enum class WithClaim { No, Yes }; @@ -3757,9 +3757,9 @@ private: jtx::Account finaldest; STAmount amt; bool a2b; // direction of transfer - WithClaim with_claim{WithClaim::No}; - uint32_t claim_id{0}; - std::array attested{}; + WithClaim withClaim{WithClaim::No}; + uint32_t claimId{0}; + std::array attested{}; }; struct AccountCreate @@ -3769,8 +3769,8 @@ private: STAmount amt; STAmount reward; bool a2b; - uint32_t claim_id{0}; - std::array attested{}; + uint32_t claimId{0}; + std::array attested{}; }; using ENV = XEnv; @@ -3806,7 +3806,7 @@ private: using CreateClaimVec = jtx::JValueVec; using CreateClaimMap = std::map; - ChainStateTrack(ENV& env) : env(env), tx_fee(env.env.current()->fees().base) + ChainStateTrack(ENV& env) : env(env), txFee(env.env.current()->fees().base) { } @@ -3851,31 +3851,30 @@ private: { callbackCalled = false; // cspell: ignore attns - for (size_t i = 0; i < signers_attns.size(); ++i) + for (size_t i = 0; i < signersAttns.size(); ++i) { - for (auto& [bridge, claims] : signers_attns[i]) + for (auto& [bridge, claims] : signersAttns[i]) { - sendAttestations(i, bridge, claims.xfer_claims); + sendAttestations(i, bridge, claims.xferClaims); auto& c = counters[bridge]; - auto& createClaims = claims.create_claims[c.claim_count]; + auto& createClaims = claims.createClaims[c.claimCount]; auto numAttns = createClaims.size(); if (numAttns != 0u) { - c.num_create_attn_sent += - sendCreateAttestations(i, bridge, createClaims); + c.numCreateAttnSent += sendCreateAttestations(i, bridge, createClaims); } - assert(claims.create_claims[c.claim_count].empty()); + assert(claims.createClaims[c.claimCount].empty()); } } for (auto& [bridge, c] : counters) { - if (c.num_create_attn_sent >= bridge->quorum) + if (c.numCreateAttnSent >= bridge->quorum) { callbackCalled = true; - c.create_callbacks[c.claim_count](c.signers); - ++c.claim_count; - c.num_create_attn_sent = 0; + c.createCallbacks[c.claimCount](c.signers); + ++c.claimCount; + c.numCreateAttnSent = 0; c.signers.clear(); } } @@ -3926,7 +3925,7 @@ private: void spendFee(jtx::Account const& acct, size_t times = 1) { - spend(acct, tx_fee, times); + spend(acct, txFee, times); } [[nodiscard]] bool @@ -3944,30 +3943,30 @@ private: { using complete_cb = std::function const& signers)>; - uint32_t claim_id{0}; - uint32_t create_count{0}; // for account create. First should be 1 - uint32_t claim_count{0}; // for account create. Increments after quorum for - // current create_count (starts at 1) is reached. + uint32_t claimId{0}; + uint32_t createCount{0}; // for account create. First should be 1 + uint32_t claimCount{0}; // for account create. Increments after quorum for + // current createCount (starts at 1) is reached. - uint32_t num_create_attn_sent{0}; // for current claim_count + uint32_t numCreateAttnSent{0}; // for current claimCount std::vector signers; - std::vector create_callbacks; + std::vector createCallbacks; }; struct Claims { - ClaimVec xfer_claims; - CreateClaimMap create_claims; + ClaimVec xferClaims; + CreateClaimMap createClaims; }; using SignerAttns = std::unordered_map; - using SignersAttns = std::array; + using SignersAttns = std::array; ENV& env; std::map accounts; - SignersAttns signers_attns; + SignersAttns signersAttns; std::map counters; - STAmount tx_fee; + STAmount txFee; }; struct ChainStateTracker @@ -4086,7 +4085,7 @@ private: st.transfer(cr_.from, srcdoor, cr_.amt); st.transfer(cr_.from, srcdoor, cr_.reward); - return ++st.counters[&bridge_].create_count; + return ++st.counters[&bridge_].createCount; } void @@ -4096,18 +4095,17 @@ private: // check all signers, but start at a random one size_t i = 0; - for (i = 0; i < kNUM_SIGNERS; ++i) + for (i = 0; i < kNumSigners; ++i) { - size_t const signerIdx = (rnd + i) % kNUM_SIGNERS; + size_t const signerIdx = (rnd + i) % kNumSigners; if (!(cr_.attested[signerIdx])) { // enqueue one attestation for this signer cr_.attested[signerIdx] = true; - st.signers_attns[signerIdx][&bridge_] - .create_claims[cr_.claim_id - 1] - .emplace_back(createAccountAttestation( + st.signersAttns[signerIdx][&bridge_].createClaims[cr_.claimId - 1].emplace_back( + createAccountAttestation( bridge_.signers[signerIdx].account, bridge_.jvb, cr_.from, @@ -4115,26 +4113,26 @@ private: cr_.reward, bridge_.signers[signerIdx].account, cr_.a2b, - cr_.claim_id, + cr_.claimId, cr_.to, bridge_.signers[signerIdx])); break; } } - if (i == kNUM_SIGNERS) + if (i == kNumSigners) return; // did not attest auto& counters = st.counters[&bridge_]; - if (counters.create_callbacks.size() < cr_.claim_id) - counters.create_callbacks.resize(cr_.claim_id); + if (counters.createCallbacks.size() < cr_.claimId) + counters.createCallbacks.resize(cr_.claimId); auto completeCb = [&](std::vector const& signers) { auto numAttestors = signers.size(); st.env.close(); assert(numAttestors <= std::count(cr_.attested.begin(), cr_.attested.end(), true)); assert(numAttestors >= bridge_.quorum); - assert(cr_.claim_id - 1 == counters.claim_count); + assert(cr_.claimId - 1 == counters.claimCount); auto r = cr_.reward; auto reward = divide(r, STAmount(numAttestors), r.asset()); @@ -4145,20 +4143,20 @@ private: st.spend(dstDoor(), reward, numAttestors); st.transfer(dstDoor(), cr_.to, cr_.amt); st.env.env.memoize(cr_.to); - sm_state_ = SmState::Completed; + smState_ = SmState::Completed; }; - counters.create_callbacks[cr_.claim_id - 1] = std::move(completeCb); + counters.createCallbacks[cr_.claimId - 1] = std::move(completeCb); } SmState advance(uint64_t time, uint32_t rnd) { - switch (sm_state_) + switch (smState_) { case SmState::Initial: - cr_.claim_id = issueAccountCreate(); - sm_state_ = SmState::Attesting; + cr_.claimId = issueAccountCreate(); + smState_ = SmState::Attesting; break; case SmState::Attesting: @@ -4172,11 +4170,11 @@ private: case SmState::Completed: break; // will get this once } - return sm_state_; + return smState_; } private: - SmState sm_state_{SmState::Initial}; + SmState smState_{SmState::Initial}; AccountCreate cr_; }; @@ -4209,7 +4207,7 @@ private: .close(); // needed for claim_id sequence to be // correct' st.spendFee(xfer_.to); - return ++st.counters[&bridge_].claim_id; + return ++st.counters[&bridge_].claimId; } void @@ -4226,10 +4224,10 @@ private: st.env.tx(xchainCommit( xfer_.from, bridge_.jvb, - xfer_.claim_id, + xfer_.claimId, xfer_.amt, - xfer_.with_claim == WithClaim::Yes ? std::nullopt - : std::optional(xfer_.finaldest))); + xfer_.withClaim == WithClaim::Yes ? std::nullopt + : std::optional(xfer_.finaldest))); st.spendFee(xfer_.from); st.transfer(xfer_.from, srcdoor, xfer_.amt); } @@ -4240,7 +4238,7 @@ private: auto r = bridge_.reward; auto reward = divide(r, STAmount(bridge_.quorum), r.asset()); - for (size_t i = 0; i < kNUM_SIGNERS; ++i) + for (size_t i = 0; i < kNumSigners; ++i) { if (xfer_.attested[i]) st.receive(bridge_.signers[i].account, reward); @@ -4254,23 +4252,23 @@ private: ChainStateTrack& st = destState(); // check all signers, but start at a random one - for (size_t i = 0; i < kNUM_SIGNERS; ++i) + for (size_t i = 0; i < kNumSigners; ++i) { - size_t const signerIdx = (rnd + i) % kNUM_SIGNERS; + size_t const signerIdx = (rnd + i) % kNumSigners; if (!(xfer_.attested[signerIdx])) { // enqueue one attestation for this signer xfer_.attested[signerIdx] = true; - st.signers_attns[signerIdx][&bridge_].xfer_claims.emplace_back(claimAttestation( + st.signersAttns[signerIdx][&bridge_].xferClaims.emplace_back(claimAttestation( bridge_.signers[signerIdx].account, bridge_.jvb, xfer_.from, xfer_.amt, bridge_.signers[signerIdx].account, xfer_.a2b, - xfer_.claim_id, - xfer_.with_claim == WithClaim::Yes + xfer_.claimId, + xfer_.withClaim == WithClaim::Yes ? std::nullopt : std::optional(xfer_.finaldest), bridge_.signers[signerIdx])); @@ -4281,7 +4279,7 @@ private: // return true if quorum was reached, false otherwise bool const quorum = std::count(xfer_.attested.begin(), xfer_.attested.end(), true) >= bridge_.quorum; - if (quorum && xfer_.with_claim == WithClaim::No) + if (quorum && xfer_.withClaim == WithClaim::No) { distributeReward(st); st.transfer(dstDoor(), xfer_.finaldest, xfer_.amt); @@ -4294,7 +4292,7 @@ private: { ChainStateTrack& st = destState(); st.env.tx( - xchainClaim(xfer_.to, bridge_.jvb, xfer_.claim_id, xfer_.amt, xfer_.finaldest)); + xchainClaim(xfer_.to, bridge_.jvb, xfer_.claimId, xfer_.amt, xfer_.finaldest)); distributeReward(st); st.transfer(dstDoor(), xfer_.finaldest, xfer_.amt); st.spendFee(xfer_.to); @@ -4303,34 +4301,34 @@ private: SmState advance(uint64_t time, uint32_t rnd) { - switch (sm_state_) + switch (smState_) { case SmState::Initial: - xfer_.claim_id = createClaimId(); - sm_state_ = SmState::ClaimIdCreated; + xfer_.claimId = createClaimId(); + smState_ = SmState::ClaimIdCreated; break; case SmState::ClaimIdCreated: commit(); - sm_state_ = SmState::Attesting; + smState_ = SmState::Attesting; break; case SmState::Attesting: if (attest(time, rnd)) { - sm_state_ = xfer_.with_claim == WithClaim::Yes ? SmState::Attested - : SmState::Completed; + smState_ = xfer_.withClaim == WithClaim::Yes ? SmState::Attested + : SmState::Completed; } else { - sm_state_ = SmState::Attesting; + smState_ = SmState::Attesting; } break; case SmState::Attested: - assert(xfer_.with_claim == WithClaim::Yes); + assert(xfer_.withClaim == WithClaim::Yes); claim(); - sm_state_ = SmState::Completed; + smState_ = SmState::Completed; break; default: @@ -4338,12 +4336,12 @@ private: assert(0); // should have been removed break; } - return sm_state_; + return smState_; } private: Transfer xfer_; - SmState sm_state_{SmState::Initial}; + SmState smState_{SmState::Initial}; }; // -------------------------------------------------- @@ -4431,12 +4429,12 @@ public: Account doorXRPLocking("doorXRPLocking"), doorUSDLocking("doorUSDLocking"), doorUSDIssuing("doorUSDIssuing"); - constexpr size_t kNUM_ACCT = 10; + static constexpr size_t kNumAcct = 10; auto a = [&doorXRPLocking, &doorUSDLocking, &doorUSDIssuing]() { using namespace std::literals; std::vector result; - result.reserve(kNUM_ACCT); - for (int i = 0; i < kNUM_ACCT; ++i) + result.reserve(kNumAcct); + for (int i = 0; i < kNumAcct; ++i) { result.emplace_back( "a"s + std::to_string(i), (i % 2) ? KeyType::Ed25519 : KeyType::Secp256k1); @@ -4470,7 +4468,7 @@ public: for (int i = 0; i < a.size(); ++i) { auto& acct{a[i]}; - if (i < kNUM_ACCT) + if (i < kNumAcct) { mcEnv.tx(trust(acct, usdLocking(100000))); scEnv.tx(trust(acct, usdIssuing(100000))); @@ -4480,15 +4478,15 @@ public: for (auto& s : signers) st->init(s.account); - st->b.init(Account::kMASTER); + st->b.init(Account::kMaster); // also create some unfunded accounts - constexpr size_t kNUM_UA = 20; + static constexpr size_t kNumUa = 20; auto ua = []() { using namespace std::literals; std::vector result; - result.reserve(kNUM_UA); - for (int i = 0; i < kNUM_UA; ++i) + result.reserve(kNumUa); + for (int i = 0; i < kNumUa; ++i) { result.emplace_back( "ua"s + std::to_string(i), (i % 2) ? KeyType::Ed25519 : KeyType::Secp256k1); @@ -4508,13 +4506,13 @@ public: BridgeDef xrpB{ .doorA = doorXRPLocking, .issueA = xrpIssue(), - .doorB = Account::kMASTER, + .doorB = Account::kMaster, .issueB = xrpIssue(), .reward = XRP(1), .minAccountCreate = XRP(20), .quorum = quorum, .signers = signers, - .jvb = json::NullValue}; + .jvb = json::ValueType::Null}; initBridge(xrpB); @@ -4529,7 +4527,7 @@ public: .minAccountCreate = XRP(20), .quorum = quorum, .signers = signers, - .jvb = json::NullValue}; + .jvb = json::ValueType::Null}; initBridge(usdB); @@ -4573,7 +4571,7 @@ public: .finaldest = a[1], .amt = XRP(6), .a2b = true, - .with_claim = WithClaim::No}); + .withClaim = WithClaim::No}); xfer( 1, st, @@ -4583,7 +4581,7 @@ public: .finaldest = a[1], .amt = XRP(8), .a2b = false, - .with_claim = WithClaim::No}); + .withClaim = WithClaim::No}); xfer( 1, st, xrpB, {.from = a[1], .to = a[1], .finaldest = a[1], .amt = XRP(1), .a2b = true}); xfer( @@ -4605,7 +4603,7 @@ public: .finaldest = a[1], .amt = XRP(7), .a2b = false, - .with_claim = WithClaim::No}); + .withClaim = WithClaim::No}); xfer( 2, st, xrpB, {.from = a[1], .to = a[1], .finaldest = a[1], .amt = XRP(9), .a2b = true}); runSimulation(st); diff --git a/src/test/basics/FileUtilities_test.cpp b/src/test/basics/FileUtilities_test.cpp index 959d3ca695..0e050b5168 100644 --- a/src/test/basics/FileUtilities_test.cpp +++ b/src/test/basics/FileUtilities_test.cpp @@ -18,7 +18,8 @@ public: using namespace xrpl::detail; using namespace boost::system; - constexpr char const* kEXPECTED_CONTENTS = "This file is very short. That's all we need."; + static constexpr char const* kExpectedContents = + "This file is very short. That's all we need."; FileDirGuard const file( *this, "test_file", "test.txt", "This is temporary text that should get overwritten"); @@ -26,21 +27,21 @@ public: error_code ec; auto const path = file.file(); - writeFileContents(ec, path, kEXPECTED_CONTENTS); + writeFileContents(ec, path, kExpectedContents); BEAST_EXPECT(!ec); { // Test with no max auto const good = getFileContents(ec, path); BEAST_EXPECT(!ec); - BEAST_EXPECT(good == kEXPECTED_CONTENTS); + BEAST_EXPECT(good == kExpectedContents); } { // Test with large max auto const good = getFileContents(ec, path, kilobytes(1)); BEAST_EXPECT(!ec); - BEAST_EXPECT(good == kEXPECTED_CONTENTS); + BEAST_EXPECT(good == kExpectedContents); } { diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp index 738990aac2..ef053449a5 100644 --- a/src/test/basics/IOUAmount_test.cpp +++ b/src/test/basics/IOUAmount_test.cpp @@ -23,18 +23,18 @@ public: BEAST_EXPECT(z.exponent() == -100); BEAST_EXPECT(!z); BEAST_EXPECT(z.signum() == 0); - BEAST_EXPECT(z == beast::kZERO); + BEAST_EXPECT(z == beast::kZero); BEAST_EXPECT((z + z) == z); BEAST_EXPECT((z - z) == z); BEAST_EXPECT(z == -z); - IOUAmount const zz(beast::kZERO); + IOUAmount const zz(beast::kZero); BEAST_EXPECT(z == zz); // https://github.com/XRPLF/rippled/issues/5170 IOUAmount const zzz{}; - BEAST_EXPECT(zzz == beast::kZERO); + BEAST_EXPECT(zzz == beast::kZero); // BEAST_EXPECT(zzz == zz); } @@ -58,32 +58,32 @@ public: { testcase("beast::Zero Comparisons"); - using beast::kZERO; + using beast::kZero; { - IOUAmount const z(kZERO); - BEAST_EXPECT(z == kZERO); - BEAST_EXPECT(z >= kZERO); - BEAST_EXPECT(z <= kZERO); - unexpected(z != kZERO); - unexpected(z > kZERO); - unexpected(z < kZERO); + IOUAmount const z(kZero); + BEAST_EXPECT(z == kZero); + BEAST_EXPECT(z >= kZero); + BEAST_EXPECT(z <= kZero); + unexpected(z != kZero); + unexpected(z > kZero); + unexpected(z < kZero); } { IOUAmount const neg(-2, 0); - BEAST_EXPECT(neg < kZERO); - BEAST_EXPECT(neg <= kZERO); - BEAST_EXPECT(neg != kZERO); - unexpected(neg == kZERO); + BEAST_EXPECT(neg < kZero); + BEAST_EXPECT(neg <= kZero); + BEAST_EXPECT(neg != kZero); + unexpected(neg == kZero); } { IOUAmount const pos(2, 0); - BEAST_EXPECT(pos > kZERO); - BEAST_EXPECT(pos >= kZERO); - BEAST_EXPECT(pos != kZERO); - unexpected(pos == kZERO); + BEAST_EXPECT(pos > kZero); + BEAST_EXPECT(pos >= kZero); + BEAST_EXPECT(pos != kZero); + unexpected(pos == kZero); } } @@ -179,68 +179,68 @@ public: testcase("mulRatio"); /* The range for the mantissa when normalized */ - constexpr std::int64_t kMIN_MANTISSA = 1000000000000000ull; - constexpr std::int64_t kMAX_MANTISSA = 9999999999999999ull; + static constexpr std::int64_t kMinMantissa = 1000000000000000ull; + static constexpr std::int64_t kMaxMantissa = 9999999999999999ull; // log(2,maxMantissa) ~ 53.15 /* 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(); + static constexpr int kMinExponent = -96; + static constexpr int kMaxExponent = 80; + constexpr auto kMaxUInt = 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)); + IOUAmount const bigMan(kMaxMantissa, 0); + BEAST_EXPECT(bigMan == mulRatio(bigMan, kMaxUInt, kMaxUInt, 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, kMaxUInt, kMaxUInt, 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)); + IOUAmount const bigMan(-kMaxMantissa, 0); + BEAST_EXPECT(bigMan == mulRatio(bigMan, kMaxUInt, kMaxUInt, 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, kMaxUInt, kMaxUInt, false)); } { // small amounts - IOUAmount const tiny(kMIN_MANTISSA, kMIN_EXPONENT); + IOUAmount const tiny(kMinMantissa, kMinExponent); // 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, kMaxUInt, true)); + BEAST_EXPECT(tiny == mulRatio(tiny, kMaxUInt - 1, kMaxUInt, 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, kMaxUInt, false)); + BEAST_EXPECT(beast::kZero == mulRatio(tiny, kMaxUInt - 1, kMaxUInt, false)); // tiny negative numbers - IOUAmount const tinyNeg(-kMIN_MANTISSA, kMIN_EXPONENT); + IOUAmount const tinyNeg(-kMinMantissa, kMinExponent); // 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, kMaxUInt, true)); + BEAST_EXPECT(beast::kZero == mulRatio(tinyNeg, kMaxUInt - 1, kMaxUInt, 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, kMaxUInt, false)); + BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMaxUInt - 1, kMaxUInt, 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, kMaxUInt - 1, kMaxUInt, true); + auto const rdown = mulRatio(one, kMaxUInt - 1, kMaxUInt, 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); + IOUAmount const big(kMaxMantissa, kMaxExponent); + auto const rup = mulRatio(big, kMaxUInt - 1, kMaxUInt, true); + auto const rdown = mulRatio(big, kMaxUInt - 1, kMaxUInt, 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, kMaxUInt - 1, kMaxUInt, true); + auto const rdown = mulRatio(negOne, kMaxUInt - 1, kMaxUInt, false); BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1); } } @@ -253,7 +253,7 @@ public: { // overflow - IOUAmount big(kMAX_MANTISSA, kMAX_EXPONENT); + IOUAmount big(kMaxMantissa, kMaxExponent); except([&] { mulRatio(big, 2, 0, true); }); } } // namespace xrpl diff --git a/src/test/basics/IntrusiveShared_test.cpp b/src/test/basics/IntrusiveShared_test.cpp index 50d3fab7a2..185b877f23 100644 --- a/src/test/basics/IntrusiveShared_test.cpp +++ b/src/test/basics/IntrusiveShared_test.cpp @@ -87,8 +87,8 @@ enum class TrackedState : std::uint8_t { class TIBase : public IntrusiveRefCounts { public: - static constexpr std::size_t kMAX_STATES = 128; - static std::array, kMAX_STATES> state; + static constexpr std::size_t kMaxStates = 128; + static std::array, kMaxStates> state; static std::atomic nextId; static TrackedState getState(int id) @@ -99,7 +99,7 @@ public: static void resetStates(bool resetCallback) { - for (int i = 0; i < kMAX_STATES; ++i) + for (int i = 0; i < kMaxStates; ++i) { state[i].store(TrackedState::Uninitialized, std::memory_order_release); } @@ -179,7 +179,7 @@ private: } }; -std::array, TIBase::kMAX_STATES> TIBase::state; +std::array, TIBase::kMaxStates> TIBase::state; std::atomic TIBase::nextId{0}; std::function)> TIBase::tracingCallback = @@ -539,17 +539,17 @@ public: } return result; }; - constexpr int kLOOP_ITERS = 2 * 1024; - constexpr int kNUM_THREADS = 16; + static constexpr int kLoopIters = 2 * 1024; + static constexpr int kNumThreads = 16; std::vector> toClone; - Barrier loopStartSyncPoint{kNUM_THREADS}; - Barrier postCreateToCloneSyncPoint{kNUM_THREADS}; - Barrier postCreateVecOfPointersSyncPoint{kNUM_THREADS}; + Barrier loopStartSyncPoint{kNumThreads}; + Barrier postCreateToCloneSyncPoint{kNumThreads}; + Barrier postCreateVecOfPointersSyncPoint{kNumThreads}; auto engines = [&]() -> std::vector { std::random_device rd; std::vector result; - result.reserve(kNUM_THREADS); - for (int i = 0; i < kNUM_THREADS; ++i) + result.reserve(kNumThreads); + for (int i = 0; i < kNumThreads; ++i) result.emplace_back(rd()); return result; }(); @@ -558,7 +558,7 @@ public: // strong and weak pointers and destroys them all at once. // threadId==0 is special. auto cloneAndDestroy = [&](int threadId) { - for (int i = 0; i < kLOOP_ITERS; ++i) + for (int i = 0; i < kLoopIters; ++i) { // ------ Sync Point ------ loopStartSyncPoint.arriveAndWait(); @@ -578,7 +578,7 @@ public: destructionState.store(0, std::memory_order_release); toClone.clear(); - toClone.resize(kNUM_THREADS); + toClone.resize(kNumThreads); auto strong = makeSharedIntrusive(); strong->tracingCallback = tracingCallback; std::ranges::fill(toClone, strong); @@ -597,12 +597,12 @@ public: } }; std::vector threads; - threads.reserve(kNUM_THREADS); - for (int i = 0; i < kNUM_THREADS; ++i) + threads.reserve(kNumThreads); + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back(cloneAndDestroy, i); } - for (int i = 0; i < kNUM_THREADS; ++i) + for (int i = 0; i < kNumThreads; ++i) { threads[i].join(); } @@ -664,19 +664,19 @@ public: result.emplace_back(SharedIntrusive(toClone)); return result; }; - constexpr int kLOOP_ITERS = 2 * 1024; - constexpr int kFLIP_POINTERS_LOOP_ITERS = 256; - constexpr int kNUM_THREADS = 16; + static constexpr int kLoopIters = 2 * 1024; + static constexpr int kFlipPointersLoopIters = 256; + static constexpr int kNumThreads = 16; std::vector> toClone; - Barrier loopStartSyncPoint{kNUM_THREADS}; - Barrier postCreateToCloneSyncPoint{kNUM_THREADS}; - Barrier postCreateVecOfPointersSyncPoint{kNUM_THREADS}; - Barrier postFlipPointersLoopSyncPoint{kNUM_THREADS}; + Barrier loopStartSyncPoint{kNumThreads}; + Barrier postCreateToCloneSyncPoint{kNumThreads}; + Barrier postCreateVecOfPointersSyncPoint{kNumThreads}; + Barrier postFlipPointersLoopSyncPoint{kNumThreads}; auto engines = [&]() -> std::vector { std::random_device rd; std::vector result; - result.reserve(kNUM_THREADS); - for (int i = 0; i < kNUM_THREADS; ++i) + result.reserve(kNumThreads); + for (int i = 0; i < kNumThreads; ++i) result.emplace_back(rd()); return result; }(); @@ -686,7 +686,7 @@ public: // changes strong pointers to weak pointers, and destroys them // all at once. auto cloneAndDestroy = [&](int threadId) { - for (int i = 0; i < kLOOP_ITERS; ++i) + for (int i = 0; i < kLoopIters; ++i) { // ------ Sync Point ------ loopStartSyncPoint.arriveAndWait(); @@ -705,7 +705,7 @@ public: destructionState.store(0, std::memory_order_release); toClone.clear(); - toClone.resize(kNUM_THREADS); + toClone.resize(kNumThreads); auto strong = makeSharedIntrusive(); strong->tracingCallback = tracingCallback; std::ranges::fill(toClone, strong); @@ -721,7 +721,7 @@ public: postCreateVecOfPointersSyncPoint.arriveAndWait(); std::uniform_int_distribution<> isStrongDist(0, 1); - for (int f = 0; f < kFLIP_POINTERS_LOOP_ITERS; ++f) + for (int f = 0; f < kFlipPointersLoopIters; ++f) { for (auto& p : v) { @@ -743,12 +743,12 @@ public: } }; std::vector threads; - threads.reserve(kNUM_THREADS); - for (int i = 0; i < kNUM_THREADS; ++i) + threads.reserve(kNumThreads); + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back(cloneAndDestroy, i); } - for (int i = 0; i < kNUM_THREADS; ++i) + for (int i = 0; i < kNumThreads; ++i) { threads[i].join(); } @@ -795,19 +795,19 @@ public: } }; - constexpr int kLOOP_ITERS = 2 * 1024; - constexpr int kLOCK_WEAK_LOOP_ITERS = 256; - constexpr int kNUM_THREADS = 16; + static constexpr int kLoopIters = 2 * 1024; + static constexpr int kLockWeakLoopIters = 256; + static constexpr int kNumThreads = 16; std::vector> toLock; - Barrier loopStartSyncPoint{kNUM_THREADS}; - Barrier postCreateToLockSyncPoint{kNUM_THREADS}; - Barrier postLockWeakLoopSyncPoint{kNUM_THREADS}; + Barrier loopStartSyncPoint{kNumThreads}; + Barrier postCreateToLockSyncPoint{kNumThreads}; + Barrier postLockWeakLoopSyncPoint{kNumThreads}; // lockAndDestroy creates weak pointers from the strong pointer // and runs a loop that locks the weak pointer. At the end of the loop // all the pointers are destroyed all at once. auto lockAndDestroy = [&](int threadId) { - for (int i = 0; i < kLOOP_ITERS; ++i) + for (int i = 0; i < kLoopIters; ++i) { // ------ Sync Point ------ loopStartSyncPoint.arriveAndWait(); @@ -826,7 +826,7 @@ public: destructionState.store(0, std::memory_order_release); toLock.clear(); - toLock.resize(kNUM_THREADS); + toLock.resize(kNumThreads); auto strong = makeSharedIntrusive(); strong->tracingCallback = tracingCallback; std::ranges::fill(toLock, strong); @@ -838,7 +838,7 @@ public: // Multiple threads all create a weak pointer from the same // strong pointer WeakIntrusive const weak{toLock[threadId]}; - for (int wi = 0; wi < kLOCK_WEAK_LOOP_ITERS; ++wi) + for (int wi = 0; wi < kLockWeakLoopIters; ++wi) { BEAST_EXPECT(!weak.expired()); auto strong = weak.lock(); @@ -852,12 +852,12 @@ public: } }; std::vector threads; - threads.reserve(kNUM_THREADS); - for (int i = 0; i < kNUM_THREADS; ++i) + threads.reserve(kNumThreads); + for (int i = 0; i < kNumThreads; ++i) { threads.emplace_back(lockAndDestroy, i); } - for (int i = 0; i < kNUM_THREADS; ++i) + for (int i = 0; i < kNumThreads; ++i) { threads[i].join(); } diff --git a/src/test/basics/Number_test.cpp b/src/test/basics/Number_test.cpp index bc336d07a4..961b38151a 100644 --- a/src/test/basics/Number_test.cpp +++ b/src/test/basics/Number_test.cpp @@ -178,8 +178,8 @@ public: {Number{true, 9'999'999'999'999'999'999ULL, -37, Number::Normalized{}}, Number{1'000'000'000'000'000'000, -18}, Number{false, 9'999'999'999'999'999'990ULL, -19, Number::Normalized{}}}, - {Number{Number::kMAX_REP}, Number{6, -1}, Number{Number::kMAX_REP / 10, 1}}, - {Number{Number::kMAX_REP - 1}, Number{1, 0}, Number{Number::kMAX_REP}}, + {Number{Number::kMaxRep}, Number{6, -1}, Number{Number::kMaxRep / 10, 1}}, + {Number{Number::kMaxRep - 1}, Number{1, 0}, Number{Number::kMaxRep}}, // Test extremes { // Each Number operand rounds up, so the actual mantissa is @@ -286,14 +286,14 @@ public: {Number{1'000'000'000'000'000'001, -18}, Number{1'000'000'000'000'000'000, -18}, Number{1'000'000'000'000'000'000, -36}}, - {Number{Number::kMAX_REP}, Number{6, -1}, Number{Number::kMAX_REP - 1}}, - {Number{false, Number::kMAX_REP + 1, 0, Number::Normalized{}}, + {Number{Number::kMaxRep}, Number{6, -1}, Number{Number::kMaxRep - 1}}, + {Number{false, Number::kMaxRep + 1, 0, Number::Normalized{}}, Number{1, 0}, - Number{(Number::kMAX_REP / 10) + 1, 1}}, - {Number{false, Number::kMAX_REP + 1, 0, Number::Normalized{}}, + Number{(Number::kMaxRep / 10) + 1, 1}}, + {Number{false, Number::kMaxRep + 1, 0, Number::Normalized{}}, Number{3, 0}, - Number{Number::kMAX_REP}}, - {power(2, 63), Number{3, 0}, Number{Number::kMAX_REP}}, + Number{Number::kMaxRep}}, + {power(2, 63), Number{3, 0}, Number{Number::kMaxRep}}, }); auto test = [this](auto const& c) { for (auto const& [x, y, z] : c) @@ -402,8 +402,8 @@ public: Number{false, maxMantissa, 0, Number::Normalized{}}, Number{1, 38}}, // Maximum int64 range - {Number{Number::kMAX_REP, 0}, - Number{Number::kMAX_REP, 0}, + {Number{Number::kMaxRep, 0}, + Number{Number::kMaxRep, 0}, Number{85'070'591'730'234'615'85, 19}}, }); tests(cSmall, cLarge); @@ -469,8 +469,8 @@ public: Number{false, (maxMantissa / 10) - 1, 20, Number::Normalized{}}}, // Maximum int64 range // 85'070'591'730'234'615'847'396'907'784'232'501'249 - {Number{Number::kMAX_REP, 0}, - Number{Number::kMAX_REP, 0}, + {Number{Number::kMaxRep, 0}, + Number{Number::kMaxRep, 0}, Number{85'070'591'730'234'615'84, 19}}, }); tests(cSmall, cLarge); @@ -536,8 +536,8 @@ public: Number{false, (maxMantissa / 10) - 1, 20, Number::Normalized{}}}, // Maximum int64 range // 85'070'591'730'234'615'847'396'907'784'232'501'249 - {Number{Number::kMAX_REP, 0}, - Number{Number::kMAX_REP, 0}, + {Number{Number::kMaxRep, 0}, + Number{Number::kMaxRep, 0}, Number{85'070'591'730'234'615'84, 19}}, }); tests(cSmall, cLarge); @@ -603,8 +603,8 @@ public: Number{1, 38}}, // Maximum int64 range // 85'070'591'730'234'615'847'396'907'784'232'501'249 - {Number{Number::kMAX_REP, 0}, - Number{Number::kMAX_REP, 0}, + {Number{Number::kMaxRep, 0}, + Number{Number::kMaxRep, 0}, Number{85'070'591'730'234'615'85, 19}}, }); tests(cSmall, cLarge); @@ -857,10 +857,10 @@ public: {Number{false, Number::maxMantissa() - 9, 0, Number::Normalized{}}, 2, Number{false, 3'162'277'660'168'379'330, -9, Number::Normalized{}}}, - {Number{Number::kMAX_REP}, + {Number{Number::kMaxRep}, 2, Number{false, 3'037'000'499'976049692, -9, Number::Normalized{}}}, - {Number{Number::kMAX_REP}, + {Number{Number::kMaxRep}, 4, Number{false, 55'108'98747006743627, -14, Number::Normalized{}}}, }); @@ -918,7 +918,7 @@ public: Number{5, -1}, Number{0}, Number{5625, -4}, - Number{Number::kMAX_REP}, + Number{Number::kMaxRep}, }); test(cSmall); bool caught = false; @@ -1510,12 +1510,12 @@ public: if (scale == MantissaRange::MantissaScale::Small) { - BEAST_EXPECT(std::numeric_limits::max() > kINITIAL_XRP.drops()); - BEAST_EXPECT(Number::maxMantissa() < kINITIAL_XRP.drops()); - Number const initalXrp{kINITIAL_XRP}; + BEAST_EXPECT(std::numeric_limits::max() > kInitialXrp.drops()); + BEAST_EXPECT(Number::maxMantissa() < kInitialXrp.drops()); + Number const initalXrp{kInitialXrp}; BEAST_EXPECT(initalXrp.exponent() > 0); - Number const maxInt64{Number::kMAX_REP}; + Number const maxInt64{Number::kMaxRep}; BEAST_EXPECT(maxInt64.exponent() > 0); // 85'070'591'730'234'615'865'843'651'857'942'052'864 - 38 digits BEAST_EXPECT((power(maxInt64, 2) == Number{85'070'591'730'234'62, 22})); @@ -1527,12 +1527,12 @@ public: } else { - BEAST_EXPECT(std::numeric_limits::max() > kINITIAL_XRP.drops()); - BEAST_EXPECT(Number::maxMantissa() > kINITIAL_XRP.drops()); - Number const initalXrp{kINITIAL_XRP}; + BEAST_EXPECT(std::numeric_limits::max() > kInitialXrp.drops()); + BEAST_EXPECT(Number::maxMantissa() > kInitialXrp.drops()); + Number const initalXrp{kInitialXrp}; BEAST_EXPECT(initalXrp.exponent() <= 0); - Number const maxInt64{Number::kMAX_REP}; + Number const maxInt64{Number::kMaxRep}; BEAST_EXPECT(maxInt64.exponent() <= 0); // 85'070'591'730'234'615'847'396'907'784'232'501'249 - 38 digits BEAST_EXPECT((power(maxInt64, 2) == Number{85'070'591'730'234'615'85, 19})); 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..dc780166c6 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()}); } } @@ -166,10 +166,10 @@ private: FeeLevel64 test{0}; BEAST_EXPECT(test.fee() == 0); - test = explicitmake(beast::kZERO); + test = explicitmake(beast::kZero); BEAST_EXPECT(test.fee() == 0); - test = beast::kZERO; + test = beast::kZero; BEAST_EXPECT(test.fee() == 0); test = explicitmake(100u); @@ -251,10 +251,10 @@ private: FeeLevelDouble test{0}; BEAST_EXPECT(test.fee() == 0); - test = explicitmake(beast::kZERO); + test = explicitmake(beast::kZero); BEAST_EXPECT(test.fee() == 0); - test = beast::kZERO; + test = beast::kZero; BEAST_EXPECT(test.fee() == 0); test = explicitmake(100.0); @@ -330,8 +330,8 @@ public: void run() override { - BEAST_EXPECT(kINITIAL_XRP.drops() == 100'000'000'000'000'000); - BEAST_EXPECT(kINITIAL_XRP == XRPAmount{100'000'000'000'000'000}); + BEAST_EXPECT(kInitialXrp.drops() == 100'000'000'000'000'000); + BEAST_EXPECT(kInitialXrp == XRPAmount{100'000'000'000'000'000}); testTypes(); testJson(); diff --git a/src/test/basics/XRPAmount_test.cpp b/src/test/basics/XRPAmount_test.cpp index 50cd17b3bc..f393003365 100644 --- a/src/test/basics/XRPAmount_test.cpp +++ b/src/test/basics/XRPAmount_test.cpp @@ -39,25 +39,25 @@ public: { testcase("beast::Zero Comparisons"); - using beast::kZERO; + using beast::kZero; for (auto i : {-1, 0, 1}) { XRPAmount const x(i); - BEAST_EXPECT((i == 0) == (x == kZERO)); - BEAST_EXPECT((i != 0) == (x != kZERO)); - BEAST_EXPECT((i < 0) == (x < kZERO)); - BEAST_EXPECT((i > 0) == (x > kZERO)); - BEAST_EXPECT((i <= 0) == (x <= kZERO)); - BEAST_EXPECT((i >= 0) == (x >= kZERO)); + BEAST_EXPECT((i == 0) == (x == kZero)); + BEAST_EXPECT((i != 0) == (x != kZero)); + BEAST_EXPECT((i < 0) == (x < kZero)); + BEAST_EXPECT((i > 0) == (x > kZero)); + BEAST_EXPECT((i <= 0) == (x <= kZero)); + BEAST_EXPECT((i >= 0) == (x >= kZero)); - BEAST_EXPECT((0 == i) == (kZERO == x)); - BEAST_EXPECT((0 != i) == (kZERO != x)); - BEAST_EXPECT((0 < i) == (kZERO < x)); - BEAST_EXPECT((0 > i) == (kZERO > x)); - BEAST_EXPECT((0 <= i) == (kZERO <= x)); - BEAST_EXPECT((0 >= i) == (kZERO >= x)); + BEAST_EXPECT((0 == i) == (kZero == x)); + BEAST_EXPECT((0 != i) == (kZero != x)); + BEAST_EXPECT((0 < i) == (kZero < x)); + BEAST_EXPECT((0 > i) == (kZero > x)); + BEAST_EXPECT((0 <= i) == (kZero <= x)); + BEAST_EXPECT((0 >= i) == (kZero >= x)); } } @@ -109,7 +109,7 @@ public: testDecimal() { // Tautology - BEAST_EXPECT(kDROPS_PER_XRP.decimalXRP() == 1); + BEAST_EXPECT(kDropsPerXrp.decimalXRP() == 1); XRPAmount test{1}; BEAST_EXPECT(test.decimalXRP() == 0.000001); @@ -136,10 +136,10 @@ public: XRPAmount test{0}; BEAST_EXPECT(test.drops() == 0); - test = make(beast::kZERO); + test = make(beast::kZero); BEAST_EXPECT(test.drops() == 0); - test = beast::kZERO; + test = beast::kZero; BEAST_EXPECT(test.drops() == 0); test = make(100); @@ -212,17 +212,17 @@ public: { testcase("mulRatio"); - constexpr auto kMAX_U_INT32 = std::numeric_limits::max(); - constexpr auto kMAX_XRP = std::numeric_limits::max(); - constexpr auto kMIN_XRP = std::numeric_limits::min(); + constexpr auto kMaxUInt32 = std::numeric_limits::max(); + constexpr auto kMaxXrp = std::numeric_limits::max(); + constexpr auto kMinXrp = std::numeric_limits::min(); { // 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)); + XRPAmount big(kMaxXrp); + BEAST_EXPECT(big == mulRatio(big, kMaxUInt32, kMaxUInt32, 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, kMaxUInt32, kMaxUInt32, false)); // multiply and divide by values that would overflow if done // naively, and check that it gives the correct answer @@ -234,10 +234,10 @@ 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)); + XRPAmount big(kMinXrp); // NOLINT TODO + BEAST_EXPECT(big == mulRatio(big, kMaxUInt32, kMaxUInt32, 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, kMaxUInt32, kMaxUInt32, 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, kMaxUInt32, 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, kMaxUInt32, false)); + BEAST_EXPECT(beast::kZero == mulRatio(tiny, kMaxUInt32 - 1, kMaxUInt32, 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, kMaxUInt32, true)); + BEAST_EXPECT(beast::kZero == mulRatio(tinyNeg, kMaxUInt32 - 1, kMaxUInt32, true)); // rounding down should be tiny - BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMAX_U_INT32 - 1, kMAX_U_INT32, false)); + BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMaxUInt32 - 1, kMaxUInt32, 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, kMaxUInt32 - 1, kMaxUInt32, true); + auto const rdown = mulRatio(one, kMaxUInt32 - 1, kMaxUInt32, 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); + XRPAmount const big(kMaxXrp); + auto const rup = mulRatio(big, kMaxUInt32 - 1, kMaxUInt32, true); + auto const rdown = mulRatio(big, kMaxUInt32 - 1, kMaxUInt32, 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, kMaxUInt32 - 1, kMaxUInt32, true); + auto const rdown = mulRatio(negOne, kMaxUInt32 - 1, kMaxUInt32, false); BEAST_EXPECT(rup.drops() - rdown.drops() == 1); } } @@ -295,14 +295,14 @@ public: { // overflow - XRPAmount big(kMAX_XRP); + XRPAmount big(kMaxXrp); except([&] { mulRatio(big, 2, 1, true); }); } { // underflow - XRPAmount const bigNegative(kMIN_XRP + 10); - BEAST_EXPECT(mulRatio(bigNegative, 2, 1, true) == kMIN_XRP); + XRPAmount const bigNegative(kMinXrp + 10); + BEAST_EXPECT(mulRatio(bigNegative, 2, 1, true) == kMinXrp); } } // namespace xrpl diff --git a/src/test/basics/base58_test.cpp b/src/test/basics/base58_test.cpp index e0a9433f4e..3c76308813 100644 --- a/src/test/basics/base58_test.cpp +++ b/src/test/basics/base58_test.cpp @@ -38,12 +38,12 @@ randEngine() -> std::mt19937& return kR; } -constexpr int kNUM_TOKEN_TYPE_INDEXES = 9; +constexpr int kNumTokenTypeIndexes = 9; [[nodiscard]] inline auto tokenTypeAndSize(int i) -> std::tuple { - assert(i < kNUM_TOKEN_TYPE_INDEXES); + assert(i < kNumTokenTypeIndexes); switch (i) { @@ -166,11 +166,11 @@ class base58_test : public beast::unit_test::Suite using namespace boost::multiprecision; - constexpr std::size_t kITERS = 100000; + static constexpr std::size_t kIters = 100000; auto eng = randEngine(); std::uniform_int_distribution dist; std::uniform_int_distribution dist1(1); - for (int i = 0; i < kITERS; ++i) + for (int i = 0; i < kIters; ++i) { std::uint64_t const d = dist(eng); if (d == 0u) @@ -188,7 +188,7 @@ class base58_test : public beast::unit_test::Suite BEAST_EXPECT(refMod.convert_to() == mod); BEAST_EXPECT(foundDiv == refDiv); } - for (int i = 0; i < kITERS; ++i) + for (int i = 0; i < kIters; ++i) { std::uint64_t const d = dist(eng); auto bigInt = multiprecision_utils::randomBigInt(/*minSize*/ 2); @@ -207,7 +207,7 @@ class base58_test : public beast::unit_test::Suite auto const foundAdd = multiprecision_utils::toBoostMP(bigInt); BEAST_EXPECT(refAdd == foundAdd); } - for (int i = 0; i < kITERS; ++i) + for (int i = 0; i < kIters; ++i) { std::uint64_t const d = dist1(eng); // Force overflow @@ -224,7 +224,7 @@ class base58_test : public beast::unit_test::Suite auto const foundAdd = multiprecision_utils::toBoostMP(bigInt); BEAST_EXPECT(refAdd != foundAdd); } - for (int i = 0; i < kITERS; ++i) + for (int i = 0; i < kIters; ++i) { std::uint64_t const d = dist(eng); auto bigInt = multiprecision_utils::randomBigInt(/* minSize */ 2); @@ -242,7 +242,7 @@ class base58_test : public beast::unit_test::Suite auto const foundMul = multiprecision_utils::toBoostMP(bigInt); BEAST_EXPECT(refMul == foundMul); } - for (int i = 0; i < kITERS; ++i) + for (int i = 0; i < kIters; ++i) { std::uint64_t const d = dist1(eng); // Force overflow @@ -403,7 +403,7 @@ class base58_test : public beast::unit_test::Suite // test every token type with data where every byte is the same and the // bytes range from 0-255 - for (int i = 0; i < kNUM_TOKEN_TYPE_INDEXES; ++i) + for (int i = 0; i < kNumTokenTypeIndexes; ++i) { std::array b256DataBuf{}; auto const [tokType, tokSize] = tokenTypeAndSize(i); @@ -415,8 +415,8 @@ class base58_test : public beast::unit_test::Suite } // test with random data - constexpr std::size_t kITERS = 100000; - for (int i = 0; i < kITERS; ++i) + static constexpr std::size_t kIters = 100000; + for (int i = 0; i < kIters; ++i) { std::array b256DataBuf{}; auto const [tokType, b256Data] = randomB256TestData(b256DataBuf); diff --git a/src/test/basics/base_uint_test.cpp b/src/test/basics/base_uint_test.cpp index cf5ece6240..5816b4eb59 100644 --- a/src/test/basics/base_uint_test.cpp +++ b/src/test/basics/base_uint_test.cpp @@ -26,30 +26,30 @@ namespace xrpl::test { template struct Nonhash { - static constexpr auto const kENDIAN = boost::endian::order::big; - static constexpr std::size_t kWIDTH = Bits / 8; + static constexpr auto kEndian = boost::endian::order::big; + static constexpr std::size_t kWidth = Bits / 8; - std::array data; + std::array data; Nonhash() = default; void operator()(void const* key, std::size_t len) noexcept { - assert(len == kWIDTH); + assert(len == kWidth); memcpy(data.data(), key, len); } explicit operator std::size_t() noexcept { - return kWIDTH; + return kWidth; } }; 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); @@ -57,18 +57,17 @@ struct base_uint_test : beast::unit_test::Suite testComparisons() { { - static constexpr std::array, 6> - kTEST_ARGS{ - {{"0000000000000000", "0000000000000001"}, - {"0000000000000000", "ffffffffffffffff"}, - {"1234567812345678", "2345678923456789"}, - {"8000000000000000", "8000000000000001"}, - {"aaaaaaaaaaaaaaa9", "aaaaaaaaaaaaaaaa"}, - {"fffffffffffffffe", "ffffffffffffffff"}}}; + static constexpr std::array, 6> kTestArgs{ + {{"0000000000000000", "0000000000000001"}, + {"0000000000000000", "ffffffffffffffff"}, + {"1234567812345678", "2345678923456789"}, + {"8000000000000000", "8000000000000001"}, + {"aaaaaaaaaaaaaaa9", "aaaaaaaaaaaaaaaa"}, + {"fffffffffffffffe", "ffffffffffffffff"}}}; - for (auto const& arg : kTEST_ARGS) + for (auto const& arg : kTestArgs) { - 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); @@ -87,8 +86,8 @@ struct base_uint_test : beast::unit_test::Suite } { - static constexpr std::array, 6> - kTEST_ARGS{{ + static constexpr std::array, 6> kTestArgs{ + { {"000000000000000000000000", "000000000000000000000001"}, {"000000000000000000000000", "ffffffffffffffffffffffff"}, {"0123456789ab0123456789ab", "123456789abc123456789abc"}, @@ -97,9 +96,9 @@ struct base_uint_test : beast::unit_test::Suite {"fffffffffffffffffffffffe", "ffffffffffffffffffffffff"}, }}; - for (auto const& arg : kTEST_ARGS) + for (auto const& arg : kTestArgs) { - 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); @@ -132,9 +131,9 @@ struct base_uint_test : beast::unit_test::Suite std::unordered_set> uset; Blob const raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - BEAST_EXPECT(test96::kBYTES == raw.size()); + 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 +154,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}; @@ -179,7 +178,7 @@ struct base_uint_test : beast::unit_test::Suite v = u; BEAST_EXPECT(v == u); - test96 z{beast::kZERO}; + test96 z{beast::kZero}; uset.insert(z); BEAST_EXPECT(to_string(z) == "000000000000000000000000"); BEAST_EXPECT(toShortString(z) == "00000000..."); @@ -199,12 +198,12 @@ struct base_uint_test : beast::unit_test::Suite n++; BEAST_EXPECT(n == test96(1)); n--; - BEAST_EXPECT(n == beast::kZERO); + BEAST_EXPECT(n == beast::kZero); BEAST_EXPECT(n == z); n--; BEAST_EXPECT(to_string(n) == "FFFFFFFFFFFFFFFFFFFFFFFF"); BEAST_EXPECT(toShortString(n) == "FFFFFFFF..."); - n = beast::kZERO; + n = beast::kZero; BEAST_EXPECT(n == z); test96 zp1{z}; @@ -327,16 +326,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[] = { + static constexpr StrBaseUInt kTestCases[] = { "000000000000000000000000", "000000000000000000000001", "fedcba9876543210ABCDEF91", @@ -344,7 +343,7 @@ struct base_uint_test : beast::unit_test::Suite "800000000000000000000000", "fFfFfFfFfFfFfFfFfFfFfFfF"}; - for (StrBaseUint const& t : kTEST_CASES) + for (StrBaseUInt const& t : kTestCases) { test96 t96; BEAST_EXPECT(t96.parseHex(t.str)); diff --git a/src/test/basics/hardened_hash_test.cpp b/src/test/basics/hardened_hash_test.cpp index a4ecdf7081..885ba9d60b 100644 --- a/src/test/basics/hardened_hash_test.cpp +++ b/src/test/basics/hardened_hash_test.cpp @@ -90,22 +90,22 @@ private: static_assert(Bits >= (8 * sizeof(UInt)), "Bits must be at least 8*sizeof(UInt)"); - static std::size_t const kSIZE = Bits / (8 * sizeof(UInt)); + static std::size_t const kSize = Bits / (8 * sizeof(UInt)); - std::array vec_; + std::array vec_; public: using value_type = UInt; - static std::size_t const kBITS = Bits; - static std::size_t const kBYTES = kBITS / 8; + static std::size_t const kBits = Bits; + static std::size_t const kBytes = kBits / 8; template static UnsignedInteger fronumber(Int v) { UnsignedInteger result; - for (std::size_t i(1); i < kSIZE; ++i) + for (std::size_t i(1); i < kSize; ++i) result.vec_[i] = 0; result.vec_[0] = v; return result; @@ -134,7 +134,7 @@ public: friend std::ostream& operator<<(std::ostream& s, UnsignedInteger const& v) { - for (std::size_t i(0); i < kSIZE; ++i) + for (std::size_t i(0); i < kSize; ++i) s << std::hex << std::setfill('0') << std::setw(2 * sizeof(UInt)) << v.vec_[i]; return s; } @@ -143,7 +143,7 @@ public: using sha256_t = UnsignedInteger<256, std::size_t>; #ifndef __INTELLISENSE__ -static_assert(sha256_t::kBITS == 256, "sha256_t must have 256 bits"); +static_assert(sha256_t::kBits == 256, "sha256_t must have 256 bits"); #endif } // namespace xrpl diff --git a/src/test/basics/join_test.cpp b/src/test/basics/join_test.cpp index cce8e19a92..1ee81f786a 100644 --- a/src/test/basics/join_test.cpp +++ b/src/test/basics/join_test.cpp @@ -58,8 +58,8 @@ struct join_test : beast::unit_test::Suite // vector with one item edge case using namespace jtx; test( - CollectionAndDelimiter(std::vector{Account::kMASTER}, "xxx"), - Account::kMASTER.human()); + CollectionAndDelimiter(std::vector{Account::kMaster}, "xxx"), + Account::kMaster.human()); } // empty vector edge case test(CollectionAndDelimiter(std::vector{}, ","), ""); diff --git a/src/test/beast/IPEndpoint_test.cpp b/src/test/beast/IPEndpoint_test.cpp index 0cf5e9794a..b1cd4709b4 100644 --- a/src/test/beast/IPEndpoint_test.cpp +++ b/src/test/beast/IPEndpoint_test.cpp @@ -375,14 +375,14 @@ public: // test with hashed container std::unordered_set eps; - constexpr auto kITEMS{100}; + static constexpr auto kItems{100}; float maxLf{0}; - for (auto i = 0; i < kITEMS; ++i) + for (auto i = 0; i < kItems; ++i) { eps.insert(randomEP(xrpl::randInt(0, 1) == 1)); maxLf = std::max(maxLf, eps.load_factor()); } - BEAST_EXPECT(eps.bucket_count() >= kITEMS); + BEAST_EXPECT(eps.bucket_count() >= kItems); BEAST_EXPECT(maxLf > 0.90); } diff --git a/src/test/beast/beast_CurrentThreadName_test.cpp b/src/test/beast/beast_CurrentThreadName_test.cpp index 570dcae0ba..1aed0fb426 100644 --- a/src/test/beast/beast_CurrentThreadName_test.cpp +++ b/src/test/beast/beast_CurrentThreadName_test.cpp @@ -52,7 +52,7 @@ private: beast::setCurrentThreadName(nameToSet); // Initialize buffer to be safe. - char actualName[beast::kMAX_THREAD_NAME_LENGTH + 1] = {}; + char actualName[beast::kMaxThreadNameLength + 1] = {}; pthread_getname_np(pthread_self(), actualName, sizeof(actualName)); BEAST_EXPECT(std::string(actualName) == expectedName); 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_Zero_test.cpp b/src/test/beast/beast_Zero_test.cpp index ca5f45ce6b..bb61844caa 100644 --- a/src/test/beast/beast_Zero_test.cpp +++ b/src/test/beast/beast_Zero_test.cpp @@ -55,12 +55,12 @@ public: void testLhsZero(IntegerWrapper x) { - expectSame(x >= kZERO, x.signum() >= 0, "lhs greater-than-or-equal-to"); - expectSame(x > kZERO, x.signum() > 0, "lhs greater than"); - expectSame(x == kZERO, x.signum() == 0, "lhs equal to"); - expectSame(x != kZERO, x.signum() != 0, "lhs not equal to"); - expectSame(x < kZERO, x.signum() < 0, "lhs less than"); - expectSame(x <= kZERO, x.signum() <= 0, "lhs less-than-or-equal-to"); + expectSame(x >= kZero, x.signum() >= 0, "lhs greater-than-or-equal-to"); + expectSame(x > kZero, x.signum() > 0, "lhs greater than"); + expectSame(x == kZero, x.signum() == 0, "lhs equal to"); + expectSame(x != kZero, x.signum() != 0, "lhs not equal to"); + expectSame(x < kZero, x.signum() < 0, "lhs less than"); + expectSame(x <= kZero, x.signum() <= 0, "lhs less-than-or-equal-to"); } void @@ -76,12 +76,12 @@ public: void testRhsZero(IntegerWrapper x) { - expectSame(kZERO >= x, 0 >= x.signum(), "rhs greater-than-or-equal-to"); - expectSame(kZERO > x, 0 > x.signum(), "rhs greater than"); - expectSame(kZERO == x, 0 == x.signum(), "rhs equal to"); - expectSame(kZERO != x, 0 != x.signum(), "rhs not equal to"); - expectSame(kZERO < x, 0 < x.signum(), "rhs less than"); - expectSame(kZERO <= x, 0 <= x.signum(), "rhs less-than-or-equal-to"); + expectSame(kZero >= x, 0 >= x.signum(), "rhs greater-than-or-equal-to"); + expectSame(kZero > x, 0 > x.signum(), "rhs greater than"); + expectSame(kZero == x, 0 == x.signum(), "rhs equal to"); + expectSame(kZero != x, 0 != x.signum(), "rhs not equal to"); + expectSame(kZero < x, 0 < x.signum(), "rhs less than"); + expectSame(kZero <= x, 0 <= x.signum(), "rhs less-than-or-equal-to"); } void @@ -97,8 +97,8 @@ public: void testAdl() { - expect(AdlTester{} == kZERO, "ADL failure!"); - expect(inner_adl_test::AdlTester2{} == kZERO, "ADL failure!"); + expect(AdlTester{} == kZero, "ADL failure!"); + expect(inner_adl_test::AdlTester2{} == kZero, "ADL failure!"); } void 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/conditions/PreimageSha256_test.cpp b/src/test/conditions/PreimageSha256_test.cpp index 055ba4b12e..e9c1de30b3 100644 --- a/src/test/conditions/PreimageSha256_test.cpp +++ b/src/test/conditions/PreimageSha256_test.cpp @@ -73,7 +73,7 @@ class PreimageSha256_test : public beast::unit_test::Suite BEAST_EXPECT(validate(*f2, *c2, makeSlice(known[0].first))); BEAST_EXPECT(validate(*f2, *c2, makeSlice(known[0].second))); - // Shouldn't validate if the kFULFILLMENT & condition don't match + // Shouldn't validate if the kFulfillment & condition don't match // regardless of the message. BEAST_EXPECT(!validate(*f2, *c1)); BEAST_EXPECT(!validate(*f2, *c1, makeSlice(known[0].first))); diff --git a/src/test/consensus/Consensus_test.cpp b/src/test/consensus/Consensus_test.cpp index 51d99367e7..6cc8d4fde1 100644 --- a/src/test/consensus/Consensus_test.cpp +++ b/src/test/consensus/Consensus_test.cpp @@ -453,7 +453,7 @@ public: // Vary the time it takes to process validations to exercise detecting // the wrong LCL at different phases of consensus - for (auto validationDelay : {0ms, parms.ledgerMIN_CLOSE}) + for (auto validationDelay : {0ms, parms.ledgerMinClose}) { // Consider 10 peers: // 0 1 2 3 4 5 6 7 8 9 @@ -492,7 +492,7 @@ public: CollectByNode jumps; sim.collectors.add(jumps); - BEAST_EXPECT(sim.trustGraph.canFork(parms.minCONSENSUS_PCT / 100.)); + BEAST_EXPECT(sim.trustGraph.canFork(parms.minConsensusPct / 100.)); // initial round to set prior state sim.run(1); @@ -637,7 +637,7 @@ public: slow.connect(network, round(1.1 * parms.ledgerGRANULARITY)); // Run to the ledger *prior* to decreasing the resolution - sim.run(kINCREASE_LEDGER_TIME_RESOLUTION_EVERY - 2); + sim.run(kIncreaseLedgerTimeResolutionEvery - 2); // In order to create the discrepancy, we want a case where if // X = effCloseTime(closeTime, resolution, parentCloseTime) @@ -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/consensus/LedgerTiming_test.cpp b/src/test/consensus/LedgerTiming_test.cpp index e56785a46a..632361c799 100644 --- a/src/test/consensus/LedgerTiming_test.cpp +++ b/src/test/consensus/LedgerTiming_test.cpp @@ -24,7 +24,7 @@ class LedgerTiming_test : public beast::unit_test::Suite run(bool previousAgree, std::uint32_t rounds) { TestRes res; - auto closeResolution = kLEDGER_DEFAULT_TIME_RESOLUTION; + auto closeResolution = kLedgerDefaultTimeResolution; auto nextCloseResolution = closeResolution; std::uint32_t round = 0; do diff --git a/src/test/consensus/NegativeUNL_test.cpp b/src/test/consensus/NegativeUNL_test.cpp index b4c98eadef..142077a42f 100644 --- a/src/test/consensus/NegativeUNL_test.cpp +++ b/src/test/consensus/NegativeUNL_test.cpp @@ -237,9 +237,9 @@ class NegativeUNL_test : public beast::unit_test::Suite std::vector publicKeys = createPublicKeys(3); // genesis ledger auto l = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -554,12 +554,12 @@ struct NetworkHistory createNodes() { assert(param.numNodes <= 256); - UNLKeys = createPublicKeys(param.numNodes); + unlKeys = createPublicKeys(param.numNodes); for (int i = 0; i < param.numNodes; ++i) { - UNLKeySet.insert(UNLKeys[i]); - UNLNodeIDs.push_back(calcNodeID(UNLKeys[i])); - UNLNodeIDSet.insert(UNLNodeIDs.back()); + unlKeySet.insert(unlKeys[i]); + unlNodeIDs.push_back(calcNodeID(unlKeys[i])); + unlNodeIdSet.insert(unlNodeIDs.back()); } } @@ -570,12 +570,12 @@ struct NetworkHistory bool createLedgerHistory() { - static uint256 kFAKE_AMENDMENT; // So we have different genesis ledgers + static uint256 kFakeAmendment; // So we have different genesis ledgers auto l = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), - std::vector{kFAKE_AMENDMENT++}, + env.app().config().fees.toFees(), + std::vector{kFakeAmendment++}, env.app().getNodeFamily()); history.push_back(l); @@ -593,7 +593,7 @@ struct NetworkHistory OpenView accum(&*l); if (l->negativeUNL().size() < param.negUNLSize) { - auto tx = createTx(true, l->seq(), UNLKeys[nidx]); + auto tx = createTx(true, l->seq(), unlKeys[nidx]); if (!applyAndTestResult(env, accum, tx, true)) break; ++nidx; @@ -602,14 +602,14 @@ struct NetworkHistory { if (param.hasToDisable) { - auto tx = createTx(true, l->seq(), UNLKeys[nidx]); + auto tx = createTx(true, l->seq(), unlKeys[nidx]); if (!applyAndTestResult(env, accum, tx, true)) break; ++nidx; } if (param.hasToReEnable) { - auto tx = createTx(false, l->seq(), UNLKeys[0]); + auto tx = createTx(false, l->seq(), unlKeys[0]); if (!applyAndTestResult(env, accum, tx, true)) break; } @@ -630,16 +630,16 @@ struct NetworkHistory std::shared_ptr createSTVal(std::shared_ptr const& ledger, NodeID const& v) { - static auto kEY_PAIR = randomKeyPair(KeyType::Secp256k1); + static auto kEyPair = randomKeyPair(KeyType::Secp256k1); return std::make_shared( env.app().getTimeKeeper().now(), - kEY_PAIR.first, - kEY_PAIR.second, + kEyPair.first, + kEyPair.second, v, [&](STValidation& v) { v.setFieldH256(sfLedgerHash, ledger->header().hash); v.setFieldU32(sfLedgerSequence, ledger->seq()); - v.setFlag(kVF_FULL_VALIDATION); + v.setFlag(kVfFullValidation); }); }; @@ -665,9 +665,9 @@ struct NetworkHistory { if (needVal(history[curr], i)) { - RCLValidation v(createSTVal(history[curr], UNLNodeIDs[i])); + RCLValidation v(createSTVal(history[curr], unlNodeIDs[i])); v.setTrusted(); - validations.add(UNLNodeIDs[i], v); + validations.add(unlNodeIDs[i], v); } } } @@ -682,10 +682,10 @@ struct NetworkHistory jtx::Env env; Parameter param; RCLValidations& validations; - std::vector UNLKeys; - hash_set UNLKeySet; - std::vector UNLNodeIDs; - hash_set UNLNodeIDSet; + std::vector unlKeys; + hash_set unlKeySet; + std::vector unlNodeIDs; + hash_set unlNodeIdSet; LedgerHistory history; bool goodHistory; }; @@ -714,7 +714,7 @@ voteAndCheck( pre(vote); auto txSet = std::make_shared(SHAMapType::TRANSACTION, history.env.app().getNodeFamily()); - vote.doVoting(history.lastLedger(), history.UNLKeySet, history.validations, txSet); + vote.doVoting(history.lastLedger(), history.unlKeySet, history.validations, txSet); return countTx(txSet) == expect; } @@ -795,9 +795,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite BEAST_EXPECT(history.goodHistory); if (history.goodHistory) { - NegativeUNLVote vote(history.UNLNodeIDs[3], history.env.journal); + NegativeUNLVote vote(history.unlNodeIDs[3], history.env.journal); BEAST_EXPECT(!vote.buildScoreTable( - history.lastLedger(), history.UNLNodeIDSet, history.validations)); + history.lastLedger(), history.unlNodeIdSet, history.validations)); } } @@ -813,9 +813,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite BEAST_EXPECT(history.goodHistory); if (history.goodHistory) { - NegativeUNLVote vote(history.UNLNodeIDs[3], history.env.journal); + NegativeUNLVote vote(history.unlNodeIDs[3], history.env.journal); BEAST_EXPECT(!vote.buildScoreTable( - history.lastLedger(), history.UNLNodeIDSet, history.validations)); + history.lastLedger(), history.unlNodeIdSet, history.validations)); } } @@ -831,15 +831,15 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite BEAST_EXPECT(history.goodHistory); if (history.goodHistory) { - NodeID myId = history.UNLNodeIDs[3]; + NodeID myId = history.unlNodeIDs[3]; history.walkHistoryAndAddValidations( [&](std::shared_ptr const& l, std::size_t idx) -> bool { // skip half my validations. - return history.UNLNodeIDs[idx] != myId || l->seq() % 2 != 0; + return history.unlNodeIDs[idx] != myId || l->seq() % 2 != 0; }); NegativeUNLVote vote(myId, history.env.journal); BEAST_EXPECT(!vote.buildScoreTable( - history.lastLedger(), history.UNLNodeIDSet, history.validations)); + history.lastLedger(), history.unlNodeIdSet, history.validations)); } } @@ -864,12 +864,12 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite if (history.goodHistory && wrongChainSuccess) { - NodeID myId = history.UNLNodeIDs[3]; - NodeID const badNode = history.UNLNodeIDs[4]; + NodeID myId = history.unlNodeIDs[3]; + NodeID const badNode = history.unlNodeIDs[4]; history.walkHistoryAndAddValidations( [&](std::shared_ptr const& l, std::size_t idx) -> bool { // everyone but me - return !(history.UNLNodeIDs[idx] == myId); + return !(history.unlNodeIDs[idx] == myId); }); // local node validate wrong chain @@ -887,7 +887,7 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite // local node still on wrong chain, can build a scoreTable, // but all other nodes' scores are zero auto scoreTable = vote.buildScoreTable( - wrongChain.back(), history.UNLNodeIDSet, history.validations); + wrongChain.back(), history.unlNodeIdSet, history.validations); BEAST_EXPECT(scoreTable); if (scoreTable) { @@ -907,7 +907,7 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite // if local node switched to right history, but cannot build // scoreTable because not enough local validations BEAST_EXPECT(!vote.buildScoreTable( - history.lastLedger(), history.UNLNodeIDSet, history.validations)); + history.lastLedger(), history.unlNodeIdSet, history.validations)); } } @@ -927,9 +927,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite [&](std::shared_ptr const& l, std::size_t idx) -> bool { return true; }); - NegativeUNLVote vote(history.UNLNodeIDs[3], history.env.journal); + NegativeUNLVote vote(history.unlNodeIDs[3], history.env.journal); auto scoreTable = vote.buildScoreTable( - history.lastLedger(), history.UNLNodeIDSet, history.validations); + history.lastLedger(), history.unlNodeIdSet, history.validations); BEAST_EXPECT(scoreTable); if (scoreTable) { @@ -1001,72 +1001,72 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite hash_set negUnl012; for (std::uint32_t i = 0; i < 3; ++i) - negUnl012.insert(history.UNLNodeIDs[i]); + negUnl012.insert(history.unlNodeIDs[i]); // build a good scoreTable to use, or copy and modify hash_map goodScoreTable; - for (auto const& n : history.UNLNodeIDs) - goodScoreTable[n] = NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK + 1; + for (auto const& n : history.unlNodeIDs) + goodScoreTable[n] = NegativeUNLVote::kNegativeUnlHighWaterMark + 1; - NegativeUNLVote vote(history.UNLNodeIDs[0], history.env.journal); + NegativeUNLVote vote(history.unlNodeIDs[0], history.env.journal); { // all good scores BEAST_EXPECT( - checkCandidateSizes(vote, history.UNLNodeIDSet, negUnl012, goodScoreTable, 0, 3)); + checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, goodScoreTable, 0, 3)); } { // all bad scores hash_map scoreTable; - for (auto& n : history.UNLNodeIDs) - scoreTable[n] = NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK - 1; + for (auto& n : history.unlNodeIDs) + scoreTable[n] = NegativeUNLVote::kNegativeUnlLowWaterMark - 1; BEAST_EXPECT( - checkCandidateSizes(vote, history.UNLNodeIDSet, negUnl012, scoreTable, 35 - 3, 0)); + checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 35 - 3, 0)); } { // all between watermarks hash_map scoreTable; - for (auto& n : history.UNLNodeIDs) - scoreTable[n] = NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK + 1; + for (auto& n : history.unlNodeIDs) + scoreTable[n] = NegativeUNLVote::kNegativeUnlLowWaterMark + 1; BEAST_EXPECT( - checkCandidateSizes(vote, history.UNLNodeIDSet, negUnl012, scoreTable, 0, 0)); + checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 0, 0)); } { // 2 good scorers in negUnl auto scoreTable = goodScoreTable; - scoreTable[*negUnl012.begin()] = NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK + 1; + scoreTable[*negUnl012.begin()] = NegativeUNLVote::kNegativeUnlLowWaterMark + 1; BEAST_EXPECT( - checkCandidateSizes(vote, history.UNLNodeIDSet, negUnl012, scoreTable, 0, 2)); + checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 0, 2)); } { // 2 bad scorers not in negUnl auto scoreTable = goodScoreTable; - scoreTable[history.UNLNodeIDs[11]] = NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK - 1; - scoreTable[history.UNLNodeIDs[12]] = NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK - 1; + scoreTable[history.unlNodeIDs[11]] = NegativeUNLVote::kNegativeUnlLowWaterMark - 1; + scoreTable[history.unlNodeIDs[12]] = NegativeUNLVote::kNegativeUnlLowWaterMark - 1; BEAST_EXPECT( - checkCandidateSizes(vote, history.UNLNodeIDSet, negUnl012, scoreTable, 2, 3)); + checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 2, 3)); } { // 2 in negUnl but not in unl, have a remove candidate from score // table - hash_set unlTemp = history.UNLNodeIDSet; - unlTemp.erase(history.UNLNodeIDs[0]); - unlTemp.erase(history.UNLNodeIDs[1]); + hash_set unlTemp = history.unlNodeIdSet; + unlTemp.erase(history.unlNodeIDs[0]); + unlTemp.erase(history.unlNodeIDs[1]); BEAST_EXPECT(checkCandidateSizes(vote, unlTemp, negUnl012, goodScoreTable, 0, 3)); } { // 2 in negUnl but not in unl, no remove candidate from score table auto scoreTable = goodScoreTable; - scoreTable.erase(history.UNLNodeIDs[0]); - scoreTable.erase(history.UNLNodeIDs[1]); - scoreTable[history.UNLNodeIDs[2]] = NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK + 1; - hash_set unlTemp = history.UNLNodeIDSet; - unlTemp.erase(history.UNLNodeIDs[0]); - unlTemp.erase(history.UNLNodeIDs[1]); + scoreTable.erase(history.unlNodeIDs[0]); + scoreTable.erase(history.unlNodeIDs[1]); + scoreTable[history.unlNodeIDs[2]] = NegativeUNLVote::kNegativeUnlLowWaterMark + 1; + hash_set unlTemp = history.unlNodeIdSet; + unlTemp.erase(history.unlNodeIDs[0]); + unlTemp.erase(history.unlNodeIDs[1]); BEAST_EXPECT(checkCandidateSizes(vote, unlTemp, negUnl012, scoreTable, 0, 2)); } @@ -1075,15 +1075,15 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite NodeID const new1(0xbead); NodeID const new2(0xbeef); hash_set const nowTrusted = {new1, new2}; - hash_set unlTemp = history.UNLNodeIDSet; + hash_set unlTemp = history.unlNodeIdSet; unlTemp.insert(new1); unlTemp.insert(new2); vote.newValidators(256, nowTrusted); { // 2 new validators have good scores, already in negUnl auto scoreTable = goodScoreTable; - scoreTable[new1] = NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK + 1; - scoreTable[new2] = NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK + 1; + scoreTable[new1] = NegativeUNLVote::kNegativeUnlHighWaterMark + 1; + scoreTable[new2] = NegativeUNLVote::kNegativeUnlHighWaterMark + 1; hash_set negUnlTemp = negUnl012; negUnlTemp.insert(new1); negUnlTemp.insert(new2); @@ -1098,7 +1098,7 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite } { // expired the new validators have bad scores, not in negUnl - vote.purgeNewValidators(256 + NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP + 1); + vote.purgeNewValidators(256 + NegativeUNLVote::kNewValidatorDisableSkip + 1); auto scoreTable = goodScoreTable; scoreTable[new1] = 0; scoreTable[new2] = 0; @@ -1136,13 +1136,13 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite std::array const nUnlPercent = {0, 50, 100}; std::array scores = { 0, - NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK - 1, - NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK, - NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK + 1, - NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK - 1, - NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK, - NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK + 1, - NegativeUNLVote::kNEGATIVE_UNL_MIN_LOCAL_VALS_TO_VOTE}; + NegativeUNLVote::kNegativeUnlLowWaterMark - 1, + NegativeUNLVote::kNegativeUnlLowWaterMark, + NegativeUNLVote::kNegativeUnlLowWaterMark + 1, + NegativeUNLVote::kNegativeUnlHighWaterMark - 1, + NegativeUNLVote::kNegativeUnlHighWaterMark, + NegativeUNLVote::kNegativeUnlHighWaterMark + 1, + NegativeUNLVote::kNegativeUnlMinLocalValsToVote}; //== combination 1: { @@ -1182,21 +1182,21 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite std::size_t toReEnableExpect = 0; if (np == 0) { - if (score < NegativeUNLVote::kNEGATIVE_UNL_LOW_WATER_MARK) + if (score < NegativeUNLVote::kNegativeUnlLowWaterMark) { toDisableExpect = us; } } else if (np == 50) { - if (score > NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK) + if (score > NegativeUNLVote::kNegativeUnlHighWaterMark) { toReEnableExpect = us * np / 100; } } else { - if (score > NegativeUNLVote::kNEGATIVE_UNL_HIGH_WATER_MARK) + if (score > NegativeUNLVote::kNegativeUnlHighWaterMark) { toReEnableExpect = us; } @@ -1314,24 +1314,24 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::Suite BEAST_EXPECT(vote.newValidators_[n2] == 3); } - vote.newValidators(NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP, {n1, n2, n3}); + vote.newValidators(NegativeUNLVote::kNewValidatorDisableSkip, {n1, n2, n3}); BEAST_EXPECT(vote.newValidators_.size() == 3); if (vote.newValidators_.size() == 3) { BEAST_EXPECT(vote.newValidators_[n1] == 2); BEAST_EXPECT(vote.newValidators_[n2] == 3); - BEAST_EXPECT(vote.newValidators_[n3] == NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP); + BEAST_EXPECT(vote.newValidators_[n3] == NegativeUNLVote::kNewValidatorDisableSkip); } - vote.purgeNewValidators(NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP + 2); + vote.purgeNewValidators(NegativeUNLVote::kNewValidatorDisableSkip + 2); BEAST_EXPECT(vote.newValidators_.size() == 3); - vote.purgeNewValidators(NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP + 3); + vote.purgeNewValidators(NegativeUNLVote::kNewValidatorDisableSkip + 3); BEAST_EXPECT(vote.newValidators_.size() == 2); - vote.purgeNewValidators(NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP + 4); + vote.purgeNewValidators(NegativeUNLVote::kNewValidatorDisableSkip + 4); BEAST_EXPECT(vote.newValidators_.size() == 1); BEAST_EXPECT(vote.newValidators_.begin()->first == n3); BEAST_EXPECT( - vote.newValidators_.begin()->second == NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP); + vote.newValidators_.begin()->second == NegativeUNLVote::kNewValidatorDisableSkip); } void @@ -1381,7 +1381,7 @@ class NegativeUNLVoteScoreTable_test : public beast::unit_test::Suite BEAST_EXPECT(history.goodHistory); if (history.goodHistory) { - NodeID myId = history.UNLNodeIDs[3]; + NodeID myId = history.unlNodeIDs[3]; history.walkHistoryAndAddValidations( [&](std::shared_ptr const& l, std::size_t idx) -> bool { std::size_t k = 0; @@ -1400,19 +1400,19 @@ class NegativeUNLVoteScoreTable_test : public beast::unit_test::Suite bool const add50 = scorePattern[sp][k] == 50 && l->seq() % 2 == 0; bool const add100 = scorePattern[sp][k] == 100; - bool const addMe = history.UNLNodeIDs[idx] == myId; + bool const addMe = history.unlNodeIDs[idx] == myId; return add50 || add100 || addMe; }); NegativeUNLVote vote(myId, history.env.journal); auto scoreTable = vote.buildScoreTable( - history.lastLedger(), history.UNLNodeIDSet, history.validations); + history.lastLedger(), history.unlNodeIdSet, history.validations); BEAST_EXPECT(scoreTable); if (scoreTable) { std::uint32_t i = 0; // looping unl auto checkScores = [&](std::uint32_t score, std::uint32_t k) -> bool { - if (history.UNLNodeIDs[i] == myId) + if (history.unlNodeIDs[i] == myId) return score == 256; if (scorePattern[sp][k] == 0) return score == 0; @@ -1427,15 +1427,15 @@ class NegativeUNLVoteScoreTable_test : public beast::unit_test::Suite }; for (; i < 2; ++i) { - BEAST_EXPECT(checkScores((*scoreTable)[history.UNLNodeIDs[i]], 0)); + BEAST_EXPECT(checkScores((*scoreTable)[history.unlNodeIDs[i]], 0)); } for (; i < 4; ++i) { - BEAST_EXPECT(checkScores((*scoreTable)[history.UNLNodeIDs[i]], 1)); + BEAST_EXPECT(checkScores((*scoreTable)[history.unlNodeIDs[i]], 1)); } for (; i < unlSize; ++i) { - BEAST_EXPECT(checkScores((*scoreTable)[history.UNLNodeIDs[i]], 2)); + BEAST_EXPECT(checkScores((*scoreTable)[history.unlNodeIDs[i]], 2)); } } } @@ -1506,7 +1506,7 @@ class NegativeUNLVoteGoodScore_test : public beast::unit_test::Suite [&](std::shared_ptr const& l, std::size_t idx) -> bool { return true; }); - BEAST_EXPECT(voteAndCheck(history, history.UNLNodeIDs[0], 0)); + BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs[0], 0)); } } @@ -1527,7 +1527,7 @@ class NegativeUNLVoteGoodScore_test : public beast::unit_test::Suite [&](std::shared_ptr const& l, std::size_t idx) -> bool { return true; }); - BEAST_EXPECT(voteAndCheck(history, history.UNLNodeIDs[0], 1)); + BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs[0], 1)); } } } @@ -1564,7 +1564,7 @@ class NegativeUNLVoteOffline_test : public beast::unit_test::Suite // skip node 0 and node 1 return idx > 1; }); - BEAST_EXPECT(voteAndCheck(history, history.UNLNodeIDs.back(), 1)); + BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs.back(), 1)); } } @@ -1587,9 +1587,9 @@ class NegativeUNLVoteOffline_test : public beast::unit_test::Suite history.walkHistoryAndAddValidations( [&](std::shared_ptr const& l, std::size_t idx) -> bool { // skip node 0 and node 1 - return history.UNLNodeIDs[idx] != n1 && history.UNLNodeIDs[idx] != n2; + return history.unlNodeIDs[idx] != n1 && history.unlNodeIDs[idx] != n2; }); - BEAST_EXPECT(voteAndCheck(history, history.UNLNodeIDs.back(), 0)); + BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs.back(), 0)); } } } @@ -1626,7 +1626,7 @@ class NegativeUNLVoteMaxListed_test : public beast::unit_test::Suite // skip node 0 ~ 10 return idx > 10; }); - BEAST_EXPECT(voteAndCheck(history, history.UNLNodeIDs.back(), 0)); + BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs.back(), 0)); } } } @@ -1662,7 +1662,7 @@ class NegativeUNLVoteRetiredValidator_test : public beast::unit_test::Suite [&](std::shared_ptr const& l, std::size_t idx) -> bool { return idx > 1; }); - BEAST_EXPECT(voteAndCheck(history, history.UNLNodeIDs[0], 0)); + BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs[0], 0)); } } @@ -1705,9 +1705,9 @@ class NegativeUNLVoteRetiredValidator_test : public beast::unit_test::Suite return idx > 1; }); BEAST_EXPECT( - voteAndCheck(history, history.UNLNodeIDs.back(), 1, [&](NegativeUNLVote& vote) { - history.UNLKeySet.erase(history.UNLKeys[0]); - history.UNLKeySet.erase(history.UNLKeys[1]); + voteAndCheck(history, history.unlNodeIDs.back(), 1, [&](NegativeUNLVote& vote) { + history.unlKeySet.erase(history.unlKeys[0]); + history.unlKeySet.erase(history.unlKeys[1]); })); } } @@ -1745,11 +1745,11 @@ class NegativeUNLVoteNewValidator_test : public beast::unit_test::Suite return true; }); BEAST_EXPECT( - voteAndCheck(history, history.UNLNodeIDs[0], 0, [&](NegativeUNLVote& vote) { + voteAndCheck(history, history.unlNodeIDs[0], 0, [&](NegativeUNLVote& vote) { auto extraKey1 = randomKeyPair(KeyType::Ed25519).first; auto extraKey2 = randomKeyPair(KeyType::Ed25519).first; - history.UNLKeySet.insert(extraKey1); - history.UNLKeySet.insert(extraKey2); + history.unlKeySet.insert(extraKey1); + history.unlKeySet.insert(extraKey2); hash_set nowTrusted; nowTrusted.insert(calcNodeID(extraKey1)); nowTrusted.insert(calcNodeID(extraKey2)); @@ -1767,7 +1767,7 @@ class NegativeUNLVoteNewValidator_test : public beast::unit_test::Suite .negUNLSize = 0, .hasToDisable = false, .hasToReEnable = false, - .numLedgers = NegativeUNLVote::kNEW_VALIDATOR_DISABLE_SKIP * 2}}; + .numLedgers = NegativeUNLVote::kNewValidatorDisableSkip * 2}}; BEAST_EXPECT(history.goodHistory); if (history.goodHistory) { @@ -1776,11 +1776,11 @@ class NegativeUNLVoteNewValidator_test : public beast::unit_test::Suite return true; }); BEAST_EXPECT( - voteAndCheck(history, history.UNLNodeIDs[0], 1, [&](NegativeUNLVote& vote) { + voteAndCheck(history, history.unlNodeIDs[0], 1, [&](NegativeUNLVote& vote) { auto extraKey1 = randomKeyPair(KeyType::Ed25519).first; auto extraKey2 = randomKeyPair(KeyType::Ed25519).first; - history.UNLKeySet.insert(extraKey1); - history.UNLKeySet.insert(extraKey2); + history.unlKeySet.insert(extraKey1); + history.unlKeySet.insert(extraKey2); hash_set nowTrusted; nowTrusted.insert(calcNodeID(extraKey1)); nowTrusted.insert(calcNodeID(extraKey2)); @@ -1805,9 +1805,9 @@ class NegativeUNLVoteFilterValidations_test : public beast::unit_test::Suite testcase("Filter Validations"); jtx::Env env(*this); auto l = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{env.app().config().features}, - env.app().config().FEES.toFees(), + env.app().config().fees.toFees(), std::vector{}, env.app().getNodeFamily()); @@ -1820,7 +1820,7 @@ class NegativeUNLVoteFilterValidations_test : public beast::unit_test::Suite [&](STValidation& v) { v.setFieldH256(sfLedgerHash, l->header().hash); v.setFieldU32(sfLedgerSequence, l->seq()); - v.setFlag(kVF_FULL_VALIDATION); + v.setFlag(kVfFullValidation); }); }; diff --git a/src/test/consensus/Validations_test.cpp b/src/test/consensus/Validations_test.cpp index 323f8fcb77..606c6f2824 100644 --- a/src/test/consensus/Validations_test.cpp +++ b/src/test/consensus/Validations_test.cpp @@ -324,15 +324,15 @@ class Validations_test : public beast::unit_test::Suite BEAST_EXPECT( ValStatus::Stale == - harness.add(n.validate(ledgerA, -harness.parms().validationCURRENT_EARLY, 0s))); + harness.add(n.validate(ledgerA, -harness.parms().validationCurrentEarly, 0s))); BEAST_EXPECT( ValStatus::Stale == - harness.add(n.validate(ledgerA, harness.parms().validationCURRENT_WALL, 0s))); + harness.add(n.validate(ledgerA, harness.parms().validationCurrentWall, 0s))); BEAST_EXPECT( ValStatus::Stale == - harness.add(n.validate(ledgerA, 0s, harness.parms().validationCURRENT_LOCAL))); + harness.add(n.validate(ledgerA, 0s, harness.parms().validationCurrentLocal))); } { @@ -357,7 +357,7 @@ class Validations_test : public beast::unit_test::Suite // If we advance far enough for AB to expire, we can fully // validate or partially validate that sequence number again BEAST_EXPECT(ValStatus::Conflicting == process(ledgerAZ)); - harness.clock().advance(harness.parms().validationSET_EXPIRES + 1ms); + harness.clock().advance(harness.parms().validationSetExpires + 1ms); BEAST_EXPECT(ValStatus::Current == process(ledgerAZ)); } } @@ -392,7 +392,7 @@ class Validations_test : public beast::unit_test::Suite BEAST_EXPECT( harness.vals().getPreferred(genesisLedger_) == std::make_pair(ledgerAB.seq(), ledgerAB.id())); - harness.clock().advance(harness.parms().validationCURRENT_LOCAL); + harness.clock().advance(harness.parms().validationCurrentLocal); // trigger check for stale trigger(harness.vals()); @@ -487,7 +487,7 @@ class Validations_test : public beast::unit_test::Suite BEAST_EXPECT(harness.vals().currentTrusted()[0].seq() == ledgerAC.seq()); // Pass enough time for it to go stale - harness.clock().advance(harness.parms().validationCURRENT_LOCAL); + harness.clock().advance(harness.parms().validationCurrentLocal); BEAST_EXPECT(harness.vals().currentTrusted().empty()); } @@ -528,7 +528,7 @@ class Validations_test : public beast::unit_test::Suite } // Pass enough time for them to go stale - harness.clock().advance(harness.parms().validationCURRENT_LOCAL); + harness.clock().advance(harness.parms().validationCurrentLocal); BEAST_EXPECT(harness.vals().getCurrentNodeIDs().empty()); } @@ -648,8 +648,8 @@ class Validations_test : public beast::unit_test::Suite LedgerHistoryHelper h; TestHarness harness(h.oracle); Node const a = harness.makeNode(); - constexpr Ledger::Seq kONE(1); - constexpr Ledger::Seq kTWO(2); + constexpr Ledger::Seq kOne(1); + constexpr Ledger::Seq kTwo(2); // simple cases Ledger const ledgerA = h["a"]; @@ -657,7 +657,7 @@ class Validations_test : public beast::unit_test::Suite BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 1); harness.vals().expire(j); BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 1); - harness.clock().advance(harness.parms().validationSET_EXPIRES); + harness.clock().advance(harness.parms().validationSetExpires); harness.vals().expire(j); BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 0); @@ -665,15 +665,15 @@ class Validations_test : public beast::unit_test::Suite Ledger const ledgerB = h["ab"]; BEAST_EXPECT(ValStatus::Current == harness.add(a.validate(ledgerB))); BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerB.id()) == 1); - harness.vals().setSeqToKeep(ledgerB.seq(), ledgerB.seq() + kONE); - harness.clock().advance(harness.parms().validationSET_EXPIRES); + harness.vals().setSeqToKeep(ledgerB.seq(), ledgerB.seq() + kOne); + harness.clock().advance(harness.parms().validationSetExpires); harness.vals().expire(j); BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerB.id()) == 1); // change toKeep - harness.vals().setSeqToKeep(ledgerB.seq() + kONE, ledgerB.seq() + kTWO); + harness.vals().setSeqToKeep(ledgerB.seq() + kOne, ledgerB.seq() + kTwo); // advance clock slowly int const loops = - harness.parms().validationSET_EXPIRES / harness.parms().validationFRESHNESS + 1; + harness.parms().validationSetExpires / harness.parms().validationFRESHNESS + 1; for (int i = 0; i < loops; ++i) { harness.clock().advance(harness.parms().validationFRESHNESS); @@ -685,8 +685,8 @@ class Validations_test : public beast::unit_test::Suite Ledger const ledgerC = h["abc"]; BEAST_EXPECT(ValStatus::Current == harness.add(a.validate(ledgerC))); BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerC.id()) == 1); - harness.vals().setSeqToKeep(ledgerC.seq() - kONE, ledgerC.seq()); - harness.clock().advance(harness.parms().validationSET_EXPIRES); + harness.vals().setSeqToKeep(ledgerC.seq() - kOne, ledgerC.seq()); + harness.clock().advance(harness.parms().validationSetExpires); harness.vals().expire(j); BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerC.id()) == 0); } @@ -934,7 +934,7 @@ class Validations_test : public beast::unit_test::Suite BEAST_EXPECT(enforcer(clock.now(), Seq{10}, p)); BEAST_EXPECT(!enforcer(clock.now(), Seq{5}, p)); BEAST_EXPECT(!enforcer(clock.now(), Seq{9}, p)); - clock.advance(p.validationSET_EXPIRES - 1ms); + clock.advance(p.validationSetExpires - 1ms); BEAST_EXPECT(!enforcer(clock.now(), Seq{1}, p)); clock.advance(2ms); BEAST_EXPECT(enforcer(clock.now(), Seq{1}, p)); diff --git a/src/test/core/ClosureCounter_test.cpp b/src/test/core/ClosureCounter_test.cpp index d859c71520..18729a7322 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 @@ -205,7 +205,7 @@ class ClosureCounter_test : public beast::unit_test::Suite BEAST_EXPECT(strCounter.count() == 0); auto wrapped = strCounter.wrap([](TrackedString&& in) { - // Note that kNONE of the compilers noticed that in was + // Note that kNone of the compilers noticed that in was // leaving scope. So, without intervention, they would // do a copy for the return (June 2017). An explicit // std::move() was required. diff --git a/src/test/core/Config_test.cpp b/src/test/core/Config_test.cpp index 95f277212d..ce6774827e 100644 --- a/src/test/core/Config_test.cpp +++ b/src/test/core/Config_test.cpp @@ -36,7 +36,7 @@ namespace detail { std::string configContents(std::string const& dbPath, std::string const& validatorsFile) { - static boost::format kCONFIG_CONTENTS_TEMPLATE(R"xrpldConfig( + static boost::format kConfigContentsTemplate(R"xrpldConfig( [server] port_rpc port_peer @@ -120,7 +120,7 @@ backend=sqlite std::string dbPathSection = dbPath.empty() ? "" : "[database_path]\n" + dbPath; std::string valFileSection = validatorsFile.empty() ? "" : "[validators_file]\n" + validatorsFile; - return boost::str(kCONFIG_CONTENTS_TEMPLATE % dbPathSection % valFileSection); + return boost::str(kConfigContentsTemplate % dbPathSection % valFileSection); } /** @@ -154,7 +154,7 @@ public: , dataDir_(dbPath) { if (dbPath.empty()) - dataDir_ = subdir() / path(Config::kDATABASE_DIR_NAME); + dataDir_ = subdir() / path(Config::kDatabaseDirName); rmDataDir_ = !exists(dataDir_); config_.setup( @@ -248,7 +248,7 @@ public: : FileDirGuard( test, std::move(subDir), - path(validatorsFileName.empty() ? Config::kVALIDATORS_FILE_NAME : validatorsFileName), + path(validatorsFileName.empty() ? Config::kValidatorsFileName : validatorsFileName), valFileContents(), useCounter) { @@ -313,8 +313,7 @@ port_wss_admin auto const cwd = current_path(); // Test both config file names. - std::string_view const configFiles[] = { - Config::kCONFIG_FILE_NAME, Config::kCONFIG_LEGACY_NAME}; + std::string_view const configFiles[] = {Config::kConfigFileName, Config::kConfigLegacyName}; // Config file in current directory. for (auto const& configFile : configFiles) @@ -461,7 +460,7 @@ port_wss_admin path const dataDirRel("test_data_dir"); path const dataDirAbs(cwd / g0.subdir() / dataDirRel); detail::FileCfgGuard const g( - *this, g0.subdir(), dataDirAbs, Config::kCONFIG_FILE_NAME, "", false); + *this, g0.subdir(), dataDirAbs, Config::kConfigFileName, "", false); auto const& c(g.config()); BEAST_EXPECT(g.dataDirExists()); BEAST_EXPECT(g.configFileExists()); @@ -470,7 +469,7 @@ port_wss_admin { // read from file relative path std::string const dbPath("my_db"); - detail::FileCfgGuard const g(*this, "test_db", dbPath, Config::kCONFIG_FILE_NAME, ""); + detail::FileCfgGuard const g(*this, "test_db", dbPath, Config::kConfigFileName, ""); auto const& c(g.config()); std::string const nativeDbPath = absolute(path(dbPath)).string(); BEAST_EXPECT(g.dataDirExists()); @@ -479,10 +478,10 @@ port_wss_admin } { // read from file no path - detail::FileCfgGuard const g(*this, "test_db", "", Config::kCONFIG_FILE_NAME, ""); + detail::FileCfgGuard const g(*this, "test_db", "", Config::kConfigFileName, ""); auto const& c(g.config()); std::string const nativeDbPath = - absolute(g.subdir() / path(Config::kDATABASE_DIR_NAME)).string(); + absolute(g.subdir() / path(Config::kDatabaseDirName)).string(); BEAST_EXPECT(g.dataDirExists()); BEAST_EXPECT(g.configFileExists()); BEAST_EXPECT(c.legacy("database_path") == nativeDbPath); @@ -509,7 +508,7 @@ port_wss_admin { Config c; - static boost::format kCONFIG_TEMPLATE(R"xrpldConfig( + static boost::format kConfigTemplate(R"xrpldConfig( [validation_seed] %1% @@ -522,7 +521,7 @@ port_wss_admin "and [validator_token] config sections"; try { - c.loadFromString(boost::str(kCONFIG_TEMPLATE % validationSeed % token)); + c.loadFromString(boost::str(kConfigTemplate % validationSeed % token)); } catch (std::runtime_error const& e) { @@ -551,7 +550,7 @@ main } BEAST_EXPECT(error.empty()); - BEAST_EXPECT(c.NETWORK_ID == 0); + BEAST_EXPECT(c.networkId == 0); try { @@ -564,7 +563,7 @@ main } BEAST_EXPECT(error.empty()); - BEAST_EXPECT(c.NETWORK_ID == 0); + BEAST_EXPECT(c.networkId == 0); try { @@ -579,7 +578,7 @@ main } BEAST_EXPECT(error.empty()); - BEAST_EXPECT(c.NETWORK_ID == 255); + BEAST_EXPECT(c.networkId == 255); try { @@ -594,7 +593,7 @@ main } BEAST_EXPECT(error.empty()); - BEAST_EXPECT(c.NETWORK_ID == 10000); + BEAST_EXPECT(c.networkId == 10000); } void @@ -656,7 +655,7 @@ nHBu9PTL9dn2GuZtdW4U2WzBwffyX9qsQCd9CNU4Z5YG3PQfViM8 c.loadFromString(toLoad); BEAST_EXPECT(c.legacy("validators_file").empty()); BEAST_EXPECT(c.section(SECTION_VALIDATORS).values().size() == 5); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == std::nullopt); + BEAST_EXPECT(c.validatorListThreshold == std::nullopt); } { // load validator list sites and keys from config @@ -686,7 +685,7 @@ trust-these-validators.gov "E566"); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values()[0] == "1"); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == std::size_t(1)); + BEAST_EXPECT(c.validatorListThreshold == std::size_t(1)); } { // load validator list sites and keys from config @@ -716,7 +715,7 @@ trust-these-validators.gov "E566"); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values()[0] == "0"); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == std::nullopt); + BEAST_EXPECT(c.validatorListThreshold == std::nullopt); } { // load should throw if [validator_list_threshold] is greater than @@ -837,7 +836,7 @@ trust-these-validators.gov BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_SITES).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_KEYS).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == 2); + BEAST_EXPECT(c.validatorListThreshold == 2); } { // load from specified [validators_file] file name @@ -845,7 +844,7 @@ trust-these-validators.gov std::string const valFileName = "validators.txt"; detail::ValidatorsTxtGuard const vtg(*this, "test_cfg", valFileName); detail::FileCfgGuard const rcg( - *this, vtg.subdir(), "", Config::kCONFIG_FILE_NAME, valFileName, false); + *this, vtg.subdir(), "", Config::kConfigFileName, valFileName, false); BEAST_EXPECT(vtg.validatorsFileExists()); BEAST_EXPECT(rcg.configFileExists()); auto const& c(rcg.config()); @@ -854,7 +853,7 @@ trust-these-validators.gov BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_SITES).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_KEYS).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == 2); + BEAST_EXPECT(c.validatorListThreshold == 2); } { // load from specified [validators_file] relative path @@ -862,7 +861,7 @@ trust-these-validators.gov detail::ValidatorsTxtGuard const vtg(*this, "test_cfg", "validators.txt"); auto const valFilePath = ".." / vtg.subdir() / "validators.txt"; detail::FileCfgGuard const rcg( - *this, vtg.subdir(), "", Config::kCONFIG_FILE_NAME, valFilePath, false); + *this, vtg.subdir(), "", Config::kConfigFileName, valFilePath, false); BEAST_EXPECT(vtg.validatorsFileExists()); BEAST_EXPECT(rcg.configFileExists()); auto const& c(rcg.config()); @@ -871,13 +870,13 @@ trust-these-validators.gov BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_SITES).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_KEYS).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == 2); + BEAST_EXPECT(c.validatorListThreshold == 2); } { // load from validators file in default location detail::ValidatorsTxtGuard const vtg(*this, "test_cfg", "validators.txt"); detail::FileCfgGuard const rcg( - *this, vtg.subdir(), "", Config::kCONFIG_FILE_NAME, "", false); + *this, vtg.subdir(), "", Config::kConfigFileName, "", false); BEAST_EXPECT(vtg.validatorsFileExists()); BEAST_EXPECT(rcg.configFileExists()); auto const& c(rcg.config()); @@ -886,7 +885,7 @@ trust-these-validators.gov BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_SITES).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_KEYS).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == 2); + BEAST_EXPECT(c.validatorListThreshold == 2); } { // load from specified [validators_file] instead @@ -897,7 +896,7 @@ trust-these-validators.gov *this, vtg.subdir(), "validators.txt", false); BEAST_EXPECT(vtgDefault.validatorsFileExists()); detail::FileCfgGuard const rcg( - *this, vtg.subdir(), "", Config::kCONFIG_FILE_NAME, vtg.validatorsFile(), false); + *this, vtg.subdir(), "", Config::kConfigFileName, vtg.validatorsFile(), false); BEAST_EXPECT(rcg.configFileExists()); auto const& c(rcg.config()); BEAST_EXPECT(c.legacy("validators_file") == vtg.validatorsFile()); @@ -905,7 +904,7 @@ trust-these-validators.gov BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_SITES).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_KEYS).values().size() == 2); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == 2); + BEAST_EXPECT(c.validatorListThreshold == 2); } { @@ -941,7 +940,7 @@ trust-these-validators.gov BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_SITES).values().size() == 4); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_KEYS).values().size() == 3); BEAST_EXPECT(c.section(SECTION_VALIDATOR_LIST_THRESHOLD).values().size() == 1); - BEAST_EXPECT(c.VALIDATOR_LIST_THRESHOLD == 2); + BEAST_EXPECT(c.validatorListThreshold == 2); } { // load should throw if [validator_list_threshold] is present both @@ -1003,7 +1002,7 @@ trust-these-validators.gov testSetup(bool explicitPath) { detail::FileCfgGuard const cfg( - *this, "testSetup", explicitPath ? "test_db" : "", Config::kCONFIG_FILE_NAME, ""); + *this, "testSetup", explicitPath ? "test_db" : "", Config::kConfigFileName, ""); /* FileCfgGuard has a Config object that gets loaded on construction, but Config::setup is not reentrant, so we need a fresh config for every test case, so ignore it. @@ -1018,7 +1017,7 @@ trust-these-validators.gov BEAST_EXPECT(!config.quiet()); BEAST_EXPECT(!config.silent()); BEAST_EXPECT(!config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 256); + BEAST_EXPECT(config.ledgerHistory == 256); BEAST_EXPECT(!config.legacy("database_path").empty()); } { @@ -1031,7 +1030,7 @@ trust-these-validators.gov BEAST_EXPECT(config.quiet()); BEAST_EXPECT(!config.silent()); BEAST_EXPECT(!config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 256); + BEAST_EXPECT(config.ledgerHistory == 256); BEAST_EXPECT(!config.legacy("database_path").empty()); } { @@ -1044,7 +1043,7 @@ trust-these-validators.gov BEAST_EXPECT(config.quiet()); BEAST_EXPECT(config.silent()); BEAST_EXPECT(!config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 256); + BEAST_EXPECT(config.ledgerHistory == 256); BEAST_EXPECT(!config.legacy("database_path").empty()); } { @@ -1057,7 +1056,7 @@ trust-these-validators.gov BEAST_EXPECT(config.quiet()); BEAST_EXPECT(config.silent()); BEAST_EXPECT(!config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 256); + BEAST_EXPECT(config.ledgerHistory == 256); BEAST_EXPECT(!config.legacy("database_path").empty()); } { @@ -1070,7 +1069,7 @@ trust-these-validators.gov BEAST_EXPECT(!config.quiet()); BEAST_EXPECT(!config.silent()); BEAST_EXPECT(config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 0); + BEAST_EXPECT(config.ledgerHistory == 0); BEAST_EXPECT(config.legacy("database_path").empty() == !explicitPath); } { @@ -1083,7 +1082,7 @@ trust-these-validators.gov BEAST_EXPECT(config.quiet()); BEAST_EXPECT(!config.silent()); BEAST_EXPECT(config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 0); + BEAST_EXPECT(config.ledgerHistory == 0); BEAST_EXPECT(config.legacy("database_path").empty() == !explicitPath); } { @@ -1096,7 +1095,7 @@ trust-these-validators.gov BEAST_EXPECT(config.quiet()); BEAST_EXPECT(config.silent()); BEAST_EXPECT(config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 0); + BEAST_EXPECT(config.ledgerHistory == 0); BEAST_EXPECT(config.legacy("database_path").empty() == !explicitPath); } { @@ -1109,7 +1108,7 @@ trust-these-validators.gov BEAST_EXPECT(config.quiet()); BEAST_EXPECT(config.silent()); BEAST_EXPECT(config.standalone()); - BEAST_EXPECT(config.LEDGER_HISTORY == 0); + BEAST_EXPECT(config.ledgerHistory == 0); BEAST_EXPECT(config.legacy("database_path").empty() == !explicitPath); } } @@ -1117,7 +1116,7 @@ trust-these-validators.gov void testPort() { - detail::FileCfgGuard const cfg(*this, "testPort", "", Config::kCONFIG_FILE_NAME, ""); + detail::FileCfgGuard const cfg(*this, "testPort", "", Config::kConfigFileName, ""); auto const& conf = cfg.config(); if (!BEAST_EXPECT(conf.exists("port_rpc"))) return; @@ -1126,11 +1125,11 @@ trust-these-validators.gov ParsedPort rpc; if (!unexcept([&]() { parsePort(rpc, conf["port_rpc"], log); })) return; - BEAST_EXPECT(rpc.admin_nets_v4.size() + rpc.admin_nets_v6.size() == 2); + BEAST_EXPECT(rpc.adminNetsV4.size() + rpc.adminNetsV6.size() == 2); ParsedPort wss; if (!unexcept([&]() { parsePort(wss, conf["port_wss_admin"], log); })) return; - BEAST_EXPECT(wss.admin_nets_v4.size() + wss.admin_nets_v6.size() == 1); + BEAST_EXPECT(wss.adminNetsV4.size() + wss.adminNetsV6.size() == 1); } void @@ -1142,7 +1141,7 @@ trust-these-validators.gov try { detail::FileCfgGuard const cfg( - *this, "testPort", "", Config::kCONFIG_FILE_NAME, "", true, contents); + *this, "testPort", "", Config::kConfigFileName, "", true, contents); BEAST_EXPECT(false); } catch (std::exception const& ex) @@ -1246,25 +1245,25 @@ r.ripple.com:51235 BEAST_EXPECT( cfg.exists(SECTION_IPS_FIXED) && cfg.section(SECTION_IPS_FIXED).lines().size() == 15 && cfg.section(SECTION_IPS_FIXED).values().size() == 15); - BEAST_EXPECT(cfg.IPS[0] == "r.ripple.com 51235"); + BEAST_EXPECT(cfg.ips[0] == "r.ripple.com 51235"); - BEAST_EXPECT(cfg.IPS_FIXED[0] == "s1.ripple.com 51235"); - BEAST_EXPECT(cfg.IPS_FIXED[1] == "s2.ripple.com 51235"); - BEAST_EXPECT(cfg.IPS_FIXED[2] == "anotherserversansport"); - BEAST_EXPECT(cfg.IPS_FIXED[3] == "anotherserverwithport 12"); - BEAST_EXPECT(cfg.IPS_FIXED[4] == "1.1.1.1 1"); - BEAST_EXPECT(cfg.IPS_FIXED[5] == "1.1.1.1 1"); - BEAST_EXPECT(cfg.IPS_FIXED[6] == "12.34.12.123 12345"); - BEAST_EXPECT(cfg.IPS_FIXED[7] == "12.34.12.123 12345"); + BEAST_EXPECT(cfg.ipsFixed[0] == "s1.ripple.com 51235"); + BEAST_EXPECT(cfg.ipsFixed[1] == "s2.ripple.com 51235"); + BEAST_EXPECT(cfg.ipsFixed[2] == "anotherserversansport"); + BEAST_EXPECT(cfg.ipsFixed[3] == "anotherserverwithport 12"); + BEAST_EXPECT(cfg.ipsFixed[4] == "1.1.1.1 1"); + BEAST_EXPECT(cfg.ipsFixed[5] == "1.1.1.1 1"); + BEAST_EXPECT(cfg.ipsFixed[6] == "12.34.12.123 12345"); + BEAST_EXPECT(cfg.ipsFixed[7] == "12.34.12.123 12345"); // all ipv6 should be ignored by colon replacer, howsoever formatted - BEAST_EXPECT(cfg.IPS_FIXED[8] == "::"); - BEAST_EXPECT(cfg.IPS_FIXED[9] == "2001:db8::"); - BEAST_EXPECT(cfg.IPS_FIXED[10] == "::1"); - BEAST_EXPECT(cfg.IPS_FIXED[11] == "::1:12345"); - BEAST_EXPECT(cfg.IPS_FIXED[12] == "[::1]:12345"); - BEAST_EXPECT(cfg.IPS_FIXED[13] == "2001:db8:3333:4444:5555:6666:7777:8888:12345"); - BEAST_EXPECT(cfg.IPS_FIXED[14] == "[2001:db8:3333:4444:5555:6666:7777:8888]:1"); + BEAST_EXPECT(cfg.ipsFixed[8] == "::"); + BEAST_EXPECT(cfg.ipsFixed[9] == "2001:db8::"); + BEAST_EXPECT(cfg.ipsFixed[10] == "::1"); + BEAST_EXPECT(cfg.ipsFixed[11] == "::1:12345"); + BEAST_EXPECT(cfg.ipsFixed[12] == "[::1]:12345"); + BEAST_EXPECT(cfg.ipsFixed[13] == "2001:db8:3333:4444:5555:6666:7777:8888:12345"); + BEAST_EXPECT(cfg.ipsFixed[14] == "[2001:db8:3333:4444:5555:6666:7777:8888]:1"); } void @@ -1275,51 +1274,51 @@ r.ripple.com:51235 std::string_view line; std::string_view field; std::string_view expect; - bool had_comment; + bool hadComment; }; std::array const tests = { {{.line = "password = aaaa\\#bbbb", .field = "password", .expect = "aaaa#bbbb", - .had_comment = false}, + .hadComment = false}, {.line = "password = aaaa#bbbb", .field = "password", .expect = "aaaa", - .had_comment = true}, + .hadComment = true}, {.line = "password = aaaa #bbbb", .field = "password", .expect = "aaaa", - .had_comment = true}, + .hadComment = true}, // since the value is all comment, this doesn't parse as k=v : {.line = "password = #aaaa #bbbb", .field = "", .expect = "password =", - .had_comment = true}, + .hadComment = true}, {.line = "password = aaaa\\# #bbbb", .field = "password", .expect = "aaaa#", - .had_comment = true}, + .hadComment = true}, {.line = "password = aaaa\\##bbbb", .field = "password", .expect = "aaaa#", - .had_comment = true}, - {.line = "aaaa#bbbb", .field = "", .expect = "aaaa", .had_comment = true}, - {.line = "aaaa\\#bbbb", .field = "", .expect = "aaaa#bbbb", .had_comment = false}, - {.line = "aaaa\\##bbbb", .field = "", .expect = "aaaa#", .had_comment = true}, - {.line = "aaaa #bbbb", .field = "", .expect = "aaaa", .had_comment = true}, - {.line = "1 #comment", .field = "", .expect = "1", .had_comment = true}, - {.line = "#whole thing is comment", .field = "", .expect = "", .had_comment = false}, + .hadComment = true}, + {.line = "aaaa#bbbb", .field = "", .expect = "aaaa", .hadComment = true}, + {.line = "aaaa\\#bbbb", .field = "", .expect = "aaaa#bbbb", .hadComment = false}, + {.line = "aaaa\\##bbbb", .field = "", .expect = "aaaa#", .hadComment = true}, + {.line = "aaaa #bbbb", .field = "", .expect = "aaaa", .hadComment = true}, + {.line = "1 #comment", .field = "", .expect = "1", .hadComment = true}, + {.line = "#whole thing is comment", .field = "", .expect = "", .hadComment = false}, {.line = " #whole comment with space", .field = "", .expect = "", - .had_comment = false}}}; + .hadComment = false}}}; for (auto const& t : tests) { Section s; s.append(std::string(t.line)); - BEAST_EXPECT(s.hadTrailingComments() == t.had_comment); + BEAST_EXPECT(s.hadTrailingComments() == t.hadComment); if (t.field.empty()) { BEAST_EXPECTS(s.legacy() == t.expect, s.legacy()); @@ -1482,7 +1481,7 @@ r.ripple.com:51235 c.loadFromString(toLoad); if (shouldPass) { - BEAST_EXPECT(c.AMENDMENT_MAJORITY_TIME.count() == val * sec); + BEAST_EXPECT(c.amendmentMajorityTime.count() == val * sec); } else { @@ -1513,7 +1512,7 @@ r.ripple.com:51235 { Config c; c.loadFromString("[overlay]\nmax_unknown_time=" + value); - return c.MAX_UNKNOWN_TIME; + return c.maxUnknownTime; } catch (std::runtime_error const&) { @@ -1547,7 +1546,7 @@ r.ripple.com:51235 { Config c; c.loadFromString("[overlay]\nmax_diverged_time=" + value); - return c.MAX_DIVERGED_TIME; + return c.maxDivergedTime; } catch (std::runtime_error const&) { diff --git a/src/test/core/Coroutine_test.cpp b/src/test/core/Coroutine_test.cpp index 103191ec59..bf1d98c779 100644 --- a/src/test/core/Coroutine_test.cpp +++ b/src/test/core/Coroutine_test.cpp @@ -58,7 +58,7 @@ public: testcase("correct order"); Env env(*this, envconfig([](std::unique_ptr cfg) { - cfg->FORCE_MULTI_THREAD = true; + cfg->forceMultiThread = true; return cfg; })); @@ -85,7 +85,7 @@ public: testcase("incorrect order"); Env env(*this, envconfig([](std::unique_ptr cfg) { - cfg->FORCE_MULTI_THREAD = true; + cfg->forceMultiThread = true; return cfg; })); 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/Peer.h b/src/test/csf/Peer.h index d3b35c19a1..3e9eed1c52 100644 --- a/src/test/csf/Peer.h +++ b/src/test/csf/Peer.h @@ -496,12 +496,7 @@ struct Peer return Result( TxSet{openTxs}, Proposal( - prevLedger.id(), - Proposal::kSEQ_JOIN, - TxSet::calcID(openTxs), - closeTime, - now(), - id)); + prevLedger.id(), Proposal::kSeqJoin, TxSet::calcID(openTxs), closeTime, now(), id)); } void diff --git a/src/test/csf/Scheduler.h b/src/test/csf/Scheduler.h index c70b7d4854..ede43be854 100644 --- a/src/test/csf/Scheduler.h +++ b/src/test/csf/Scheduler.h @@ -91,7 +91,7 @@ private: make_multiset>::type; // alloc_ is owned by the scheduler boost::container::pmr::monotonic_buffer_resource* alloc_; - by_when_set by_when_; + by_when_set byWhen_; public: using iterator = typename by_when_set::iterator; @@ -258,7 +258,7 @@ inline Scheduler::QueueType::QueueType(boost::container::pmr::monotonic_buffer_r inline Scheduler::QueueType::~QueueType() { - for (auto iter = by_when_.begin(); iter != by_when_.end();) + for (auto iter = byWhen_.begin(); iter != byWhen_.end();) { auto e = &*iter; ++iter; @@ -270,19 +270,19 @@ inline Scheduler::QueueType::~QueueType() inline bool Scheduler::QueueType::empty() const { - return by_when_.empty(); + return byWhen_.empty(); } inline auto Scheduler::QueueType::begin() -> iterator { - return by_when_.begin(); + return byWhen_.begin(); } inline auto Scheduler::QueueType::end() -> iterator { - return by_when_.end(); + return byWhen_.end(); } template @@ -292,14 +292,14 @@ Scheduler::QueueType::emplace(time_point when, Handler&& h) -> typename by_when_ using event_type = EventImpl>; auto const p = alloc_->allocate(sizeof(event_type)); auto& e = *new (p) event_type(when, std::forward(h)); - return by_when_.insert(e); + return byWhen_.insert(e); } inline auto Scheduler::QueueType::erase(iterator iter) -> typename by_when_set::iterator { auto& e = *iter; - auto next = by_when_.erase(iter); + auto next = byWhen_.erase(iter); e.~Event(); alloc_->deallocate(&e, sizeof(e)); return next; 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..46a3600307 100644 --- a/src/test/csf/impl/ledgers.cpp +++ b/src/test/csf/impl/ledgers.cpp @@ -15,12 +15,12 @@ namespace xrpl::test::csf { -Ledger::Instance const Ledger::kGENESIS; +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; @@ -76,7 +76,7 @@ mismatch(Ledger const& a, Ledger const& b) LedgerOracle::LedgerOracle() { - instances_.insert(InstanceEntry{Ledger::kGENESIS, nextID()}); + instances_.insert(InstanceEntry{Ledger::kGenesis, nextID()}); } Ledger::ID diff --git a/src/test/csf/ledgers.h b/src/test/csf/ledgers.h index 96082bc987..25672de133 100644 --- a/src/test/csf/ledgers.h +++ b/src/test/csf/ledgers.h @@ -66,7 +66,7 @@ private: TxSetType txs; // Resolution used to determine close time - NetClock::duration closeTimeResolution = kLEDGER_DEFAULT_TIME_RESOLUTION; + NetClock::duration closeTimeResolution = kLedgerDefaultTimeResolution; //! When the ledger closed (up to closeTimeResolution) NetClock::time_point closeTime; @@ -128,14 +128,14 @@ private: }; // Single common genesis instance - static Instance const kGENESIS; + static Instance const kGenesis; Ledger(ID id, Instance const* i) : id_{id}, instance_{i} { } public: - Ledger(MakeGenesis) : instance_(&kGENESIS) + Ledger(MakeGenesis) : instance_(&kGenesis) { } diff --git a/src/test/jtx/AMM.h b/src/test/jtx/AMM.h index 2876522218..deadd80290 100644 --- a/src/test/jtx/AMM.h +++ b/src/test/jtx/AMM.h @@ -178,7 +178,7 @@ public: std::optional asset2 = std::nullopt, std::optional const& ammAccount = std::nullopt, bool ignoreParams = false, - unsigned apiVersion = RPC::kAPI_INVALID_VERSION) const; + unsigned apiVersion = RPC::kApiInvalidVersion) const; /** Verify the AMM balances. */ diff --git a/src/test/jtx/Account.h b/src/test/jtx/Account.h index 2a11c5540e..b20b4a359a 100644 --- a/src/test/jtx/Account.h +++ b/src/test/jtx/Account.h @@ -23,7 +23,7 @@ private: public: /** The master account. */ - static Account const kMASTER; + static Account const kMaster; Account() = delete; Account(Account&&) = default; 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..4618b36fde 100644 --- a/src/test/jtx/Env.h +++ b/src/test/jtx/Env.h @@ -75,7 +75,7 @@ noripple(Account const& account, Args const&... args) inline FeatureBitset testableAmendments() { - static FeatureBitset const kIDS = [] { + static FeatureBitset const kIds = [] { auto const& sa = allAmendments(); std::vector feats; feats.reserve(sa.size()); @@ -93,7 +93,7 @@ testableAmendments() } return FeatureBitset(feats); }(); - return kIDS; + return kIds; } //------------------------------------------------------------------------------ @@ -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_); } @@ -125,7 +124,7 @@ class Env public: beast::unit_test::Suite& test; - Account const& master = Account::kMASTER; + Account const& master = Account::kMaster; /// Used by parseResult() and postConditions() struct ParsedResult @@ -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,12 +187,12 @@ 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")} { - memoize(Account::kMASTER); + memoize(Account::kMaster); Pathfinder::initPathTable(); foreachFeature(features, [&appFeats = app().config().features](uint256 const& f) { appFeats.insert(f); @@ -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 @@ -871,7 +869,7 @@ Env::rpc( Args&&... args) { return doRpc( - RPC::kAPI_COMMAND_LINE_VERSION, + RPC::kApiCommandLineVersion, std::vector{cmd, std::forward(args)...}, headers); } 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..0c9e5ffe24 100644 --- a/src/test/jtx/Env_test.cpp +++ b/src/test/jtx/Env_test.cpp @@ -163,7 +163,7 @@ public: auto const get = [](AnyAmount a) { return a; }; BEAST_EXPECT(!get(usd(10)).isAny); - BEAST_EXPECT(get(kANY(usd(10))).isAny); + BEAST_EXPECT(get(kAny(usd(10))).isAny); } // Test Env @@ -240,13 +240,13 @@ public: env.fund(n, "alice"); env.require(Balance("alice", n)); env(noop("alice"), Fee(1), Ter(telINSUF_FEE_P)); - env(noop("alice"), Seq(kNONE), Ter(temMALFORMED)); - env(noop("alice"), Seq(kNONE), Fee(10), Ter(temMALFORMED)); - env(noop("alice"), Fee(kNONE), Ter(temMALFORMED)); - env(noop("alice"), Sig(kNONE), Ter(temMALFORMED)); - env(noop("alice"), Fee(kAUTOFILL)); - env(noop("alice"), Fee(kAUTOFILL), Seq(kAUTOFILL)); - env(noop("alice"), Fee(kAUTOFILL), Seq(kAUTOFILL), Sig(kAUTOFILL)); + env(noop("alice"), Seq(kNone), Ter(temMALFORMED)); + env(noop("alice"), Seq(kNone), Fee(10), Ter(temMALFORMED)); + env(noop("alice"), Fee(kNone), Ter(temMALFORMED)); + env(noop("alice"), Sig(kNone), Ter(temMALFORMED)); + env(noop("alice"), Fee(kAutofill)); + env(noop("alice"), Fee(kAutofill), Seq(kAutofill)); + env(noop("alice"), Fee(kAutofill), Seq(kAutofill), Sig(kAutofill)); } } @@ -258,11 +258,11 @@ public: Env env(*this); auto const gw = Account("gw"); auto const usd = gw["USD"]; - env.require(Balance("alice", kNONE)); - env.require(Balance("alice", XRP(kNONE))); + env.require(Balance("alice", kNone)); + env.require(Balance("alice", XRP(kNone))); env.fund(XRP(10000), "alice", gw); env.close(); - env.require(Balance("alice", usd(kNONE))); + env.require(Balance("alice", usd(kNone))); env.trust(usd(100), "alice"); env.require(Balance("alice", XRP(10000))); // fee refunded env.require(Balance("alice", usd(0))); @@ -324,11 +324,11 @@ public: env.require(Balance("carol", XRP(10000))); env.require(Balance(gw, XRP(10000))); - env(pay(env.master, "alice", XRP(1000)), Fee(kNONE), Ter(temMALFORMED)); + env(pay(env.master, "alice", XRP(1000)), Fee(kNone), Ter(temMALFORMED)); env(pay(env.master, "alice", XRP(1000)), Fee(1), Ter(telINSUF_FEE_P)); - env(pay(env.master, "alice", XRP(1000)), Seq(kNONE), Ter(temMALFORMED)); + env(pay(env.master, "alice", XRP(1000)), Seq(kNone), Ter(temMALFORMED)); env(pay(env.master, "alice", XRP(1000)), Seq(20), Ter(terPRE_SEQ)); - env(pay(env.master, "alice", XRP(1000)), Sig(kNONE), Ter(temMALFORMED)); + env(pay(env.master, "alice", XRP(1000)), Sig(kNone), Ter(temMALFORMED)); env(pay(env.master, "alice", XRP(1000)), Sig("bob"), Ter(tefBAD_AUTH)); env(pay(env.master, "dilbert", XRP(1000)), Sig(env.master)); @@ -342,9 +342,9 @@ public: env.require(Balance(gw, Account("carol")["USD"](-50))); env(offer("carol", XRP(50), usd(50)), Require(Owners("carol", 2))); - env(pay("alice", "bob", kANY(usd(10))), Ter(tecPATH_DRY)); - env(pay("alice", "bob", kANY(usd(10))), Paths(XRP), Sendmax(XRP(10)), Ter(tecPATH_PARTIAL)); - env(pay("alice", "bob", kANY(usd(10))), Paths(XRP), Sendmax(XRP(20))); + env(pay("alice", "bob", kAny(usd(10))), Ter(tecPATH_DRY)); + env(pay("alice", "bob", kAny(usd(10))), Paths(XRP), Sendmax(XRP(10)), Ter(tecPATH_PARTIAL)); + env(pay("alice", "bob", kAny(usd(10))), Paths(XRP), Sendmax(XRP(20))); env.require(Balance("bob", usd(10))); env.require(Balance("carol", usd(39.5))); @@ -359,7 +359,7 @@ public: env.require(Nflags("alice", asfDisableMaster)); env(fset("alice", asfDisableMaster), Sig("alice")); env.require(Flags("alice", asfDisableMaster)); - env(regkey("alice", kDISABLED), Ter(tecNO_ALTERNATIVE_KEY)); + env(regkey("alice", kDisabled), Ter(tecNO_ALTERNATIVE_KEY)); env(noop("alice")); env(noop("alice"), Sig("alice"), Ter(tefMASTER_DISABLED)); env(noop("alice"), Sig("eric")); @@ -368,7 +368,7 @@ public: env(fclear("alice", asfDisableMaster), Sig("alice"), Ter(tefMASTER_DISABLED)); env(fclear("alice", asfDisableMaster)); env.require(Nflags("alice", asfDisableMaster)); - env(regkey("alice", kDISABLED)); + env(regkey("alice", kDisabled)); env(noop("alice"), Sig("eric"), Ter(tefBAD_AUTH)); env(noop("alice")); } @@ -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; @@ -468,7 +468,7 @@ public: Fee(4 * baseFee), Ter(tefBAD_SIGNATURE)); - env(signers("alice", kNONE)); + env(signers("alice", kNone)); } void @@ -703,7 +703,7 @@ public: env.fund(XRP(10000), alice); { - envs(noop(alice), Fee(kNONE), Seq(kNONE))(); + envs(noop(alice), Fee(kNone), Seq(kNone))(); // Make sure we get the right account back. auto tx = env.tx(); @@ -715,8 +715,8 @@ public: } { - auto params = json::Value(json::NullValue); - envs(noop(alice), Fee(kNONE), Seq(kNONE))(params); + auto params = json::Value(json::ValueType::Null); + envs(noop(alice), Fee(kNone), Seq(kNone))(params); // Make sure we get the right account back. auto tx = env.tx(); @@ -728,14 +728,14 @@ 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; auto const expectedErrorString = "Fee of " + std::to_string(baseFee.drops()) + " exceeds the requested tx limit of " + std::to_string(baseFee.drops() / 2); - envs(noop(alice), Fee(kNONE), Seq(kNONE), Rpc(RpcHighFee, expectedErrorString))(params); + envs(noop(alice), Fee(kNone), Seq(kNone), Rpc(RpcHighFee, expectedErrorString))(params); auto tx = env.tx(); BEAST_EXPECT(!tx); @@ -867,7 +867,7 @@ public: return cfg; }), nullptr, - beast::severities::KDisabled}; + beast::Severity::Disabled}; }); pass(); } diff --git a/src/test/jtx/Oracle.h b/src/test/jtx/Oracle.h index becc572e4a..cf091c6d13 100644 --- a/src/test/jtx/Oracle.h +++ b/src/test/jtx/Oracle.h @@ -11,9 +11,9 @@ using OraclesData = std::vector, std::optional< // Special string value, which is converted to unquoted string in the string // passed to rpc. -constexpr char const* kNONE_TAG = "%None%"; -constexpr char const* kUNQUOTED_NONE = "None"; -constexpr char const* kNONE_PATTERN = "\"%None%\""; +constexpr char const* kNoneTag = "%None%"; +constexpr char const* kUnquotedNone = "None"; +constexpr char const* kNonePattern = "\"%None%\""; std::uint32_t asUInt(AnyValue const& v); @@ -83,8 +83,7 @@ struct RemoveArg // The value doesn't matter much, it has to be greater // than maxLastUpdateTimeDelta in order to pass LastUpdateTime // validation {close-maxLastUpdateTimeDelta,close+maxLastUpdateTimeDelta}. -constexpr static std::chrono::seconds kTEST_START_TIME = - kEPOCH_OFFSET + std::chrono::seconds(10'000); +static constexpr std::chrono::seconds kTestStartTime = kEpochOffset + std::chrono::seconds(10'000); /** Oracle class facilitates unit-testing of the Price Oracle feature. * It defines functions to create, update, and delete the Oracle object, diff --git a/src/test/jtx/PathSet.h b/src/test/jtx/PathSet.h index 9b5f893d5a..cab31ea540 100644 --- a/src/test/jtx/PathSet.h +++ b/src/test/jtx/PathSet.h @@ -109,7 +109,7 @@ TestPath::pushBack(Issue const& iss) { path.emplaceBack( STPathElement::TypeCurrency | STPathElement::TypeIssuer, - beast::kZERO, + beast::kZero, iss.currency, iss.account); return *this; @@ -120,7 +120,7 @@ TestPath::pushBack(MPTIssue const& iss) { path.emplaceBack( STPathElement::TypeMpt | STPathElement::TypeIssuer, - beast::kZERO, + beast::kZero, iss.getMptID(), iss.getIssuer()); return *this; @@ -129,7 +129,7 @@ TestPath::pushBack(MPTIssue const& iss) inline TestPath& TestPath::pushBack(jtx::Account const& account) { - path.emplaceBack(account.id(), Currency{beast::kZERO}, beast::kZERO); + path.emplaceBack(account.id(), Currency{beast::kZero}, beast::kZero); return *this; } @@ -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..011ac2e58d 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); } }; @@ -274,9 +274,9 @@ using simpleField = JTxFieldWrapper>; /** General field definitions, or fields used in multiple transaction namespaces */ -auto const kDATA = JTxFieldWrapper(sfData); +auto const kData = JTxFieldWrapper(sfData); -auto const kAMOUNT = JTxFieldWrapper(sfAmount); +auto const kAmount = JTxFieldWrapper(sfAmount); // TODO We only need this long "requires" clause as polyfill, for C++20 // implementations which are missing header. Replace with @@ -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; @@ -728,8 +728,8 @@ create(jtx::Account const& account, jtx::Account const& dest, STAmount const& se } // namespace check -static constexpr FeeLevel64 kBASE_FEE_LEVEL{TxQ::kBASE_LEVEL}; -static constexpr FeeLevel64 kMIN_ESCALATION_FEE_LEVEL = kBASE_FEE_LEVEL * 500; +static constexpr FeeLevel64 kBaseFeeLevel{TxQ::kBaseLevel}; +static constexpr FeeLevel64 kMinEscalationFeeLevel = kBaseFeeLevel * 500; inline uint256 getCheckIndex(AccountID const& account, std::uint32_t uSequence) @@ -746,8 +746,8 @@ checkMetrics( std::optional expectedMaxCount, std::size_t expectedInLedger, std::size_t expectedPerLedger, - std::uint64_t expectedMinFeeLevel = kBASE_FEE_LEVEL.fee(), - std::uint64_t expectedMedFeeLevel = kMIN_ESCALATION_FEE_LEVEL.fee(), + std::uint64_t expectedMinFeeLevel = kBaseFeeLevel.fee(), + std::uint64_t expectedMedFeeLevel = kMinEscalationFeeLevel.fee(), std::source_location const location = std::source_location::current()) { int const line = location.line(); @@ -757,11 +757,11 @@ checkMetrics( auto const metrics = env.app().getTxQ().getMetrics(*env.current()); using namespace std::string_literals; - metrics.referenceFeeLevel == kBASE_FEE_LEVEL + metrics.referenceFeeLevel == kBaseFeeLevel ? test.pass() : test.fail( "reference: "s + std::to_string(metrics.referenceFeeLevel.value()) + "/" + - std::to_string(kBASE_FEE_LEVEL.value()), + std::to_string(kBaseFeeLevel.value()), file, line); @@ -856,20 +856,19 @@ coverWithdraw( json::Value coverClawback(AccountID const& account, std::uint32_t flags = 0); -auto const kLOAN_BROKER_ID = JTxFieldWrapper(sfLoanBrokerID); +auto const kLoanBrokerId = JTxFieldWrapper(sfLoanBrokerID); -auto const kMANAGEMENT_FEE_RATE = +auto const kManagementFeeRate = valueUnitWrapper(sfManagementFeeRate); -auto const kDEBT_MAXIMUM = simpleField(sfDebtMaximum); +auto const kDebtMaximum = simpleField(sfDebtMaximum); -auto const kCOVER_RATE_MINIMUM = - valueUnitWrapper(sfCoverRateMinimum); +auto const kCoverRateMinimum = valueUnitWrapper(sfCoverRateMinimum); -auto const kCOVER_RATE_LIQUIDATION = +auto const kCoverRateLiquidation = valueUnitWrapper(sfCoverRateLiquidation); -auto const kDESTINATION = JTxFieldWrapper(sfDestination); +auto const kDestination = JTxFieldWrapper(sfDestination); } // namespace loanBroker @@ -883,36 +882,35 @@ set(AccountID const& account, Number principalRequested, std::uint32_t flags = 0); -auto const kCOUNTERPARTY = JTxFieldWrapper(sfCounterparty); +auto const kCounterparty = JTxFieldWrapper(sfCounterparty); // For `CounterPartySignature`, use `Sig(sfCounterpartySignature, ...)` -auto const kLOAN_ORIGINATION_FEE = simpleField(sfLoanOriginationFee); +auto const kLoanOriginationFee = simpleField(sfLoanOriginationFee); -auto const kLOAN_SERVICE_FEE = simpleField(sfLoanServiceFee); +auto const kLoanServiceFee = simpleField(sfLoanServiceFee); -auto const kLATE_PAYMENT_FEE = simpleField(sfLatePaymentFee); +auto const kLatePaymentFee = simpleField(sfLatePaymentFee); -auto const kCLOSE_PAYMENT_FEE = simpleField(sfClosePaymentFee); +auto const kClosePaymentFee = simpleField(sfClosePaymentFee); -auto const kOVERPAYMENT_FEE = valueUnitWrapper(sfOverpaymentFee); +auto const kOverpaymentFee = valueUnitWrapper(sfOverpaymentFee); -auto const kINTEREST_RATE = valueUnitWrapper(sfInterestRate); +auto const kInterestRate = valueUnitWrapper(sfInterestRate); -auto const kLATE_INTEREST_RATE = - valueUnitWrapper(sfLateInterestRate); +auto const kLateInterestRate = valueUnitWrapper(sfLateInterestRate); -auto const kCLOSE_INTEREST_RATE = +auto const kCloseInterestRate = valueUnitWrapper(sfCloseInterestRate); -auto const kOVERPAYMENT_INTEREST_RATE = +auto const kOverpaymentInterestRate = valueUnitWrapper(sfOverpaymentInterestRate); -auto const kPAYMENT_TOTAL = simpleField(sfPaymentTotal); +auto const kPaymentTotal = simpleField(sfPaymentTotal); -auto const kPAYMENT_INTERVAL = simpleField(sfPaymentInterval); +auto const kPaymentInterval = simpleField(sfPaymentInterval); -auto const kGRACE_PERIOD = simpleField(sfGracePeriod); +auto const kGracePeriod = simpleField(sfGracePeriod); json::Value manage(AccountID const& account, uint256 const& loanID, std::uint32_t flags); diff --git a/src/test/jtx/TrustedPublisherServer.h b/src/test/jtx/TrustedPublisherServer.h index 05efc9eea2..9a53a32481 100644 --- a/src/test/jtx/TrustedPublisherServer.h +++ b/src/test/jtx/TrustedPublisherServer.h @@ -101,7 +101,7 @@ public: SecretKey const& ssk, int seq) { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = seq; st[sfPublicKey] = pk; st[sfSigningPubKey] = spk; @@ -339,7 +339,7 @@ public: static std::string const& cert() { - static std::string const kCERT{R"cert( + static std::string const kCert{R"cert( -----BEGIN CERTIFICATE----- MIIDczCCAlugAwIBAgIBATANBgkqhkiG9w0BAQsFADBjMQswCQYDVQQGEwJVUzEL MAkGA1UECAwCQ0ExFDASBgNVBAcMC0xvcyBBbmdlbGVzMRswGQYDVQQKDBJyaXBw @@ -362,13 +362,13 @@ GSGO8NEEq8BTVmp69zD1JyfvQcXzsi7WtkAX+/EOFZ7LesnZ6VsyjZ74wECCaQuD X1yu/XxHqchM+DOzzVw6wRKaM7Zsk80= -----END CERTIFICATE----- )cert"}; - return kCERT; + return kCert; } static std::string const& key() { - static std::string const kEY{R"pkey( + static std::string const kKey{R"pkey( -----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEAueZ1hgRxwPgfeVx2AdngUYx7zYcaxcGYXyqi7izJqTuBUcVc TRC/9Ip67RAEhfcgGudRS/a4Sv1ljwiRknSCcD/ZjzOFDLgbqYGSZNEs+T/qkwmc @@ -397,13 +397,13 @@ cK55dMILcbHqeIBq/wR6sIhw6IJcaDBfFfrJiKKDilfij2lHxR2FQrEngtTCCRV+ ZzARzaWhQPvbDqEtLJDWuXZNXfL8/PTIs5NmuKuQ8F4+gQJpkQgwaw== -----END RSA PRIVATE KEY----- )pkey"}; - return kEY; + return kKey; } static std::string const& caCert() { - static std::string const kCERT{R"cert( + static std::string const kCert{R"cert( -----BEGIN CERTIFICATE----- MIIDpzCCAo+gAwIBAgIUWc45WqaaNuaSLoFYTMC/Mjfqw/gwDQYJKoZIhvcNAQEL BQAwYzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRQwEgYDVQQHDAtMb3MgQW5n @@ -427,7 +427,7 @@ mRMyNekaRw+Npy4Hjou5sx272cXHHmPCSF5TjwdaibSaGjx1k0Q50mOf7S9KG5b5 7X1e3FekJlaD02EBEhtkXURIxogOQALdFncj -----END CERTIFICATE----- )cert"}; - return kCERT; + return kCert; } static std::string const& @@ -545,11 +545,11 @@ private: else { int refresh = 5; - constexpr char const* kREFRESH_PREFIX = "/validators2/refresh/"; - if (boost::starts_with(path, kREFRESH_PREFIX)) + static constexpr char const* kRefreshPrefix = "/validators2/refresh/"; + if (boost::starts_with(path, kRefreshPrefix)) { refresh = boost::lexical_cast( - path.substr(strlen(kREFRESH_PREFIX))); + path.substr(strlen(kRefreshPrefix))); } res.body() = getList2_(refresh); } @@ -569,11 +569,11 @@ private: else { int refresh = 5; - constexpr char const* kREFRESH_PREFIX = "/validators/refresh/"; - if (boost::starts_with(path, kREFRESH_PREFIX)) + static constexpr char const* kRefreshPrefix = "/validators/refresh/"; + if (boost::starts_with(path, kRefreshPrefix)) { refresh = boost::lexical_cast( - path.substr(strlen(kREFRESH_PREFIX))); + path.substr(strlen(kRefreshPrefix))); } res.body() = getList_(refresh); } 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/amount.h b/src/test/jtx/amount.h index 4bf5bffd6b..db281419ef 100644 --- a/src/test/jtx/amount.h +++ b/src/test/jtx/amount.h @@ -55,8 +55,7 @@ struct None // This value is also defined in SystemParameters.h. It's // duplicated here to catch any possible future errors that // could change that value (however unlikely). -// TODO: rename — clashes with xrpl::kDROPS_PER_XRP -constexpr XRPAmount kJTX_DROPS_PER_XRP{1'000'000}; +constexpr XRPAmount kJtxDropsPerXrp{1'000'000}; /** Represents an XRP, IOU, or MPT quantity This customizes the string conversion and supports @@ -276,7 +275,7 @@ struct XrpT operator()(T v) const { using TOut = std::conditional_t, std::int64_t, std::uint64_t>; - return {TOut{v} * kJTX_DROPS_PER_XRP}; + return {TOut{v} * kJtxDropsPerXrp}; } /** Returns an amount of XRP as PrettyAmount, @@ -287,7 +286,7 @@ struct XrpT PrettyAmount operator()(Number v) const { - auto const c = kJTX_DROPS_PER_XRP.drops(); + auto const c = kJtxDropsPerXrp.drops(); auto const d = std::int64_t(v * c); if (Number(d) / c != v) Throw("unrepresentable"); @@ -297,7 +296,7 @@ struct XrpT PrettyAmount operator()(double v) const { - auto const c = kJTX_DROPS_PER_XRP.drops(); + auto const c = kJtxDropsPerXrp.drops(); if (v >= 0) { auto const d = std::uint64_t(std::round(v * c)); @@ -371,7 +370,7 @@ struct EpsilonT } }; -static EpsilonT const kEPSILON; +static EpsilonT const kEpsilon; /** Converts to IOU Issue or STAmount. @@ -612,7 +611,7 @@ AnyT::operator()(STAmount const& sta) const /** Returns an amount representing "any issuer" @note With respect to what the recipient will accept */ -extern AnyT const kANY; +extern AnyT const kAny; } // namespace test::jtx 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/directory.h b/src/test/jtx/directory.h index 5f277d6c91..9a87266802 100644 --- a/src/test/jtx/directory.h +++ b/src/test/jtx/directory.h @@ -48,7 +48,7 @@ maximumPageIndex(Env const& env) -> std::uint64_t { if (env.enabled(fixDirectoryLimit)) return std::numeric_limits::max(); - return kDIR_NODE_MAX_PAGES - 1; + return kDirNodeMaxPages - 1; } } // namespace xrpl::test::jtx::directory diff --git a/src/test/jtx/escrow.h b/src/test/jtx/escrow.h index 5cb6f65395..58be9b701a 100644 --- a/src/test/jtx/escrow.h +++ b/src/test/jtx/escrow.h @@ -41,38 +41,38 @@ cancel(Account const& account, Account const& from, std::uint32_t seq) Rate rate(Env& env, Account const& account, std::uint32_t const& seq); -// A PreimageSha256 fulfillments and its associated kCONDITION. -std::array const kFB1 = {{0xA0, 0x02, 0x80, 0x00}}; +// A PreimageSha256 fulfillments and its associated kCondition. +std::array const kFb1 = {{0xA0, 0x02, 0x80, 0x00}}; -std::array const kCB1 = { +std::array const kCb1 = { {0xA0, 0x25, 0x80, 0x20, 0xE3, 0xB0, 0xC4, 0x42, 0x98, 0xFC, 0x1C, 0x14, 0x9A, 0xFB, 0xF4, 0xC8, 0x99, 0x6F, 0xB9, 0x24, 0x27, 0xAE, 0x41, 0xE4, 0x64, 0x9B, 0x93, 0x4C, 0xA4, 0x95, 0x99, 0x1B, 0x78, 0x52, 0xB8, 0x55, 0x81, 0x01, 0x00}}; -// Another PreimageSha256 fulfillments and its associated kCONDITION. -std::array const kFB2 = {{0xA0, 0x05, 0x80, 0x03, 0x61, 0x61, 0x61}}; +// Another PreimageSha256 fulfillments and its associated kCondition. +std::array const kFb2 = {{0xA0, 0x05, 0x80, 0x03, 0x61, 0x61, 0x61}}; -std::array const kCB2 = { +std::array const kCb2 = { {0xA0, 0x25, 0x80, 0x20, 0x98, 0x34, 0x87, 0x6D, 0xCF, 0xB0, 0x5C, 0xB1, 0x67, 0xA5, 0xC2, 0x49, 0x53, 0xEB, 0xA5, 0x8C, 0x4A, 0xC8, 0x9B, 0x1A, 0xDF, 0x57, 0xF2, 0x8F, 0x2F, 0x9D, 0x09, 0xAF, 0x10, 0x7E, 0xE8, 0xF0, 0x81, 0x01, 0x03}}; -// Another PreimageSha256 kFULFILLMENT and its associated kCONDITION. -std::array const kFB3 = {{0xA0, 0x06, 0x80, 0x04, 0x6E, 0x69, 0x6B, 0x62}}; +// Another PreimageSha256 kFulfillment and its associated kCondition. +std::array const kFb3 = {{0xA0, 0x06, 0x80, 0x04, 0x6E, 0x69, 0x6B, 0x62}}; -std::array const kCB3 = { +std::array const kCb3 = { {0xA0, 0x25, 0x80, 0x20, 0x6E, 0x4C, 0x71, 0x45, 0x30, 0xC0, 0xA4, 0x26, 0x8B, 0x3F, 0xA6, 0x3B, 0x1B, 0x60, 0x6F, 0x2D, 0x26, 0x4A, 0x2D, 0x85, 0x7B, 0xE8, 0xA0, 0x9C, 0x1D, 0xFD, 0x57, 0x0D, 0x15, 0x85, 0x8B, 0xD4, 0x81, 0x01, 0x04}}; /** Set the "FinishAfter" time tag on a JTx */ -auto const kFINISH_TIME = JTxFieldWrapper(sfFinishAfter); +auto const kFinishTime = JTxFieldWrapper(sfFinishAfter); /** Set the "CancelAfter" time tag on a JTx */ -auto const kCANCEL_TIME = JTxFieldWrapper(sfCancelAfter); +auto const kCancelTime = JTxFieldWrapper(sfCancelAfter); -auto const kCONDITION = JTxFieldWrapper(sfCondition); +auto const kCondition = JTxFieldWrapper(sfCondition); -auto const kFULFILLMENT = JTxFieldWrapper(sfFulfillment); +auto const kFulfillment = JTxFieldWrapper(sfFulfillment); } // namespace xrpl::test::jtx::escrow diff --git a/src/test/jtx/impl/AMM.cpp b/src/test/jtx/impl/AMM.cpp index 5193034826..c6dc14081a 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,25 +199,25 @@ 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); } auto jr = - (apiVersion == RPC::kAPI_INVALID_VERSION + (apiVersion == RPC::kApiInvalidVersion ? env_.rpc("json", "amm_info", to_string(jv)) : 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/AMMTest.cpp b/src/test/jtx/impl/AMMTest.cpp index 5801e8fb44..46c5e44bd3 100644 --- a/src/test/jtx/impl/AMMTest.cpp +++ b/src/test/jtx/impl/AMMTest.cpp @@ -213,9 +213,9 @@ AMMTest::pathTestEnv() // different from the current defaults. This function creates an env // with the search parameters that the tests were written for. return Env(*this, envconfig([](std::unique_ptr cfg) { - cfg->PATH_SEARCH_OLD = 7; - cfg->PATH_SEARCH = 7; - cfg->PATH_SEARCH_MAX = 10; + cfg->pathSearchOld = 7; + cfg->pathSearch = 7; + cfg->pathSearchMax = 10; return cfg; })); } diff --git a/src/test/jtx/impl/Account.cpp b/src/test/jtx/impl/Account.cpp index 50e6c701f1..f82b997c3d 100644 --- a/src/test/jtx/impl/Account.cpp +++ b/src/test/jtx/impl/Account.cpp @@ -23,7 +23,7 @@ namespace xrpl::test::jtx { std::unordered_map, Account, beast::Uhash<>> Account::cache; -Account const Account::kMASTER( +Account const Account::kMaster( "master", generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase")), Account::PrivateCtorTag{}); diff --git a/src/test/jtx/impl/Env.cpp b/src/test/jtx/impl/Env.cpp index cc3db4f1e1..4b6955bafb 100644 --- a/src/test/jtx/impl/Env.cpp +++ b/src/test/jtx/impl/Env.cpp @@ -73,25 +73,25 @@ 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(); // Hack so we don't have to call Config::setup HTTPClient::initializeSSLContext( - config->SSL_VERIFY_DIR, config->SSL_VERIFY_FILE, config->SSL_VERIFY, debugLog()); + config->sslVerifyDir, config->sslVerifyFile, config->sslVerify, debugLog()); owned = makeApplication(std::move(config), std::move(logs), std::move(tk)); app = owned.get(); app->getLogs().threshold(thresh); @@ -301,23 +301,23 @@ Env::fund(bool setDefaultRipple, STAmount const& amount, Account const& account) // VFALCO NOTE Is the fee formula correct? apply( pay(master, account, amount + drops(current()->fees().base)), - jtx::Seq(jtx::kAUTOFILL), - Fee(jtx::kAUTOFILL), - Sig(jtx::kAUTOFILL)); + jtx::Seq(jtx::kAutofill), + Fee(jtx::kAutofill), + Sig(jtx::kAutofill)); apply( fset(account, asfDefaultRipple), - jtx::Seq(jtx::kAUTOFILL), - Fee(jtx::kAUTOFILL), - Sig(jtx::kAUTOFILL)); + jtx::Seq(jtx::kAutofill), + Fee(jtx::kAutofill), + Sig(jtx::kAutofill)); require(Flags(account, asfDefaultRipple)); } else { apply( pay(master, account, amount), - jtx::Seq(jtx::kAUTOFILL), - Fee(jtx::kAUTOFILL), - Sig(jtx::kAUTOFILL)); + jtx::Seq(jtx::kAutofill), + Fee(jtx::kAutofill), + Sig(jtx::kAutofill)); require(Nflags(account, asfDefaultRipple)); } require(jtx::Balance(account, amount)); @@ -331,14 +331,14 @@ Env::trust(STAmount const& amount, Account const& account) auto const start = balance(account); apply( jtx::trust(account, amount), - jtx::Seq(jtx::kAUTOFILL), - Fee(jtx::kAUTOFILL), - Sig(jtx::kAUTOFILL)); + jtx::Seq(jtx::kAutofill), + Fee(jtx::kAutofill), + Sig(jtx::kAutofill)); apply( pay(master, account, drops(current()->fees().base)), - jtx::Seq(jtx::kAUTOFILL), - Fee(jtx::kAUTOFILL), - Sig(jtx::kAUTOFILL)); + jtx::Seq(jtx::kAutofill), + Fee(jtx::kAutofill), + Sig(jtx::kAutofill)); test.expect(balance(account) == start); } diff --git a/src/test/jtx/impl/JSONRPCClient.cpp b/src/test/jtx/impl/JSONRPCClient.cpp index 01b8b5863a..cf81bfab0c 100644 --- a/src/test/jtx/impl/JSONRPCClient.cpp +++ b/src/test/jtx/impl/JSONRPCClient.cpp @@ -81,11 +81,11 @@ class JSONRPCClient : public AbstractClient boost::asio::ip::tcp::socket stream_; boost::beast::multi_buffer bin_; boost::beast::multi_buffer bout_; - unsigned rpc_version_; + unsigned rpcVersion_; public: explicit JSONRPCClient(Config const& cfg, unsigned rpcVersion) - : ep_(getEndpoint(cfg)), stream_(ios_), rpc_version_(rpcVersion) + : ep_(getEndpoint(cfg)), stream_(ios_), rpcVersion_(rpcVersion) { stream_.connect(ep_); } @@ -116,7 +116,7 @@ public: { json::Value jr; jr[jss::method] = cmd; - if (rpc_version_ == 2) + if (rpcVersion_ == 2) { jr[jss::jsonrpc] = "2.0"; jr[jss::ripplerpc] = "2.0"; @@ -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); @@ -148,7 +148,7 @@ public: [[nodiscard]] unsigned version() const override { - return rpc_version_; + return rpcVersion_; } }; diff --git a/src/test/jtx/impl/Oracle.cpp b/src/test/jtx/impl/Oracle.cpp index 051e1f4470..991c84fc18 100644 --- a/src/test/jtx/impl/Oracle.cpp +++ b/src/test/jtx/impl/Oracle.cpp @@ -39,7 +39,7 @@ Oracle::Oracle(Env& env, CreateArg const& arg, bool submit) : env_(env) // on testStartTime since XRPL epoch. auto const now = env_.timeKeeper().now(); if (now.time_since_epoch().count() == 0 || arg.close) - env_.close(now + kTEST_START_TIME - kEPOCH_OFFSET); + env_.close(now + kTestStartTime - kEpochOffset); if (arg.owner) owner_ = *arg.owner; if (arg.documentID && validDocumentID(*arg.documentID)) @@ -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) @@ -191,7 +191,7 @@ Oracle::aggregatePrice( toJson(jv[jss::time_threshold], *timeThreshold); // Convert "%None%" to None auto str = to_string(jv); - str = boost::regex_replace(str, boost::regex(kNONE_PATTERN), kUNQUOTED_NONE); + str = boost::regex_replace(str, boost::regex(kNonePattern), kUnquotedNone); auto jr = env.rpc("json", "get_aggregate_price", str); if (jr.isObject()) @@ -205,7 +205,7 @@ Oracle::aggregatePrice( return jr; } } - return json::NullValue; + return json::ValueType::Null; } void @@ -256,7 +256,7 @@ Oracle::set(UpdateArg const& arg) if (std::holds_alternative(*arg.lastUpdateTime)) { jv[jss::LastUpdateTime] = - to_string(kTEST_START_TIME.count() + std::get(*arg.lastUpdateTime)); + to_string(kTestStartTime.count() + std::get(*arg.lastUpdateTime)); } else { @@ -267,9 +267,9 @@ Oracle::set(UpdateArg const& arg) { jv[jss::LastUpdateTime] = to_string( duration_cast(env_.current()->header().closeTime.time_since_epoch()).count() + - kEPOCH_OFFSET.count()); + kEpochOffset.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) @@ -351,7 +351,7 @@ Oracle::ledgerEntry( } // Convert "%None%" to None auto str = to_string(jvParams); - str = boost::regex_replace(str, boost::regex(kNONE_PATTERN), kUNQUOTED_NONE); + str = boost::regex_replace(str, boost::regex(kNonePattern), kUnquotedNone); auto jr = env.rpc("json", "ledger_entry", str); if (jr.isObject()) @@ -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..c784c074de 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); } @@ -172,9 +172,9 @@ pathTestEnv(beast::unit_test::Suite& suite) // with the search parameters that the tests were written for. using namespace jtx; return Env(suite, envconfig([](std::unique_ptr cfg) { - cfg->PATH_SEARCH_OLD = 7; - cfg->PATH_SEARCH = 7; - cfg->PATH_SEARCH_MAX = 10; + cfg->pathSearchOld = 7; + cfg->pathSearch = 7; + cfg->pathSearchMax = 10; return cfg; })); } @@ -193,7 +193,7 @@ findPathsRequest( using namespace jtx; auto& app = env.app(); - Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; + Resource::Charge loadType = Resource::kFeeReferenceRpc; Resource::Consumer c; RPC::JsonContext context{ @@ -206,22 +206,22 @@ findPathsRequest( .role = Role::USER, .coro = {}, .infoSub = {}, - .apiVersion = RPC::kAPI_VERSION_IF_UNSPECIFIED}, + .apiVersion = RPC::kApiVersionIfUnspecified}, {}, {}}; - 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); } @@ -262,7 +262,7 @@ findPaths( STAmount da; if (result.isMember(jss::destination_amount)) - da = amountFromJson(kSF_GENERIC, result[jss::destination_amount]); + da = amountFromJson(sfGeneric, result[jss::destination_amount]); STAmount sa; STPathSet paths; @@ -274,10 +274,10 @@ findPaths( auto const& path = alts[0u]; if (path.isMember(jss::source_amount)) - sa = amountFromJson(kSF_GENERIC, path[jss::source_amount]); + sa = amountFromJson(sfGeneric, path[jss::source_amount]); if (path.isMember(jss::destination_amount)) - da = amountFromJson(kSF_GENERIC, path[jss::destination_amount]); + da = amountFromJson(sfGeneric, path[jss::destination_amount]); if (path.isMember(jss::paths_computed)) { @@ -332,7 +332,7 @@ PrettyAmount xrpMinusFee(Env const& env, std::int64_t xrpAmount) { auto feeDrops = env.current()->fees().base; - return drops(kJTX_DROPS_PER_XRP * xrpAmount - feeDrops); + return drops(kJtxDropsPerXrp * xrpAmount - feeDrops); }; [[nodiscard]] bool @@ -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/WSClient.cpp b/src/test/jtx/impl/WSClient.cpp index ba09647ce7..551fd1404b 100644 --- a/src/test/jtx/impl/WSClient.cpp +++ b/src/test/jtx/impl/WSClient.cpp @@ -120,7 +120,7 @@ class WSClientImpl : public WSClient std::condition_variable cv_; std::list> msgs_; - unsigned rpc_version_; + unsigned rpcVersion_; void cleanup() @@ -157,7 +157,7 @@ public: , thread_([&] { ios_.run(); }) , stream_(ios_) , ws_(stream_) - , rpc_version_(rpcVersion) + , rpcVersion_(rpcVersion) { try { @@ -197,7 +197,7 @@ public: json::Value jp; if (params) jp = params; - if (rpc_version_ == 2) + if (rpcVersion_ == 2) { jp[jss::method] = cmd; jp[jss::jsonrpc] = "2.0"; @@ -284,7 +284,7 @@ public: [[nodiscard]] unsigned version() const override { - return rpc_version_; + return rpcVersion_; } private: diff --git a/src/test/jtx/impl/amount.cpp b/src/test/jtx/impl/amount.cpp index 873eab1a6a..b07703dace 100644 --- a/src/test/jtx/impl/amount.cpp +++ b/src/test/jtx/impl/amount.cpp @@ -50,7 +50,7 @@ operator<<(std::ostream& os, PrettyAmount const& amount) if (issue.native()) { // measure in hundredths - auto const c = kJTX_DROPS_PER_XRP.drops() / 100; + auto const c = kJtxDropsPerXrp.drops() / 100; auto const n = amount.value().mantissa(); if (n < c) { @@ -65,7 +65,7 @@ operator<<(std::ostream& os, PrettyAmount const& amount) } else { - auto const d = double(n) / kJTX_DROPS_PER_XRP.drops(); + auto const d = double(n) / kJtxDropsPerXrp.drops(); if (amount.value().negative()) { os << "-"; @@ -117,6 +117,6 @@ operator<<(std::ostream& os, MPT const& mpt) return os; } -AnyT const kANY{}; +AnyT const kAny{}; } // namespace xrpl::test::jtx diff --git a/src/test/jtx/impl/balance.cpp b/src/test/jtx/impl/balance.cpp index 1290888ab6..ddb45a8a97 100644 --- a/src/test/jtx/impl/balance.cpp +++ b/src/test/jtx/impl/balance.cpp @@ -18,12 +18,12 @@ namespace xrpl::test::jtx { ((cond) ? (env.test.pass(), true) : (env.test.fail((reason), __FILE__, __LINE__), false)) void -doBalance(Env& env, AccountID const& account, bool kNONE, STAmount const& value, Issue const& issue) +doBalance(Env& env, AccountID const& account, bool kNone, STAmount const& value, Issue const& issue) { if (isXRP(issue)) { auto const sle = env.le(keylet::account(account)); - if (kNONE) + if (kNone) { TEST_EXPECT(!sle); } @@ -37,7 +37,7 @@ doBalance(Env& env, AccountID const& account, bool kNONE, STAmount const& value, else { auto const sle = env.le(keylet::line(account, issue)); - if (kNONE) + if (kNone) { TEST_EXPECT(!sle); } @@ -56,12 +56,12 @@ void doBalance( Env& env, AccountID const& account, - bool kNONE, + bool kNone, STAmount const& value, MPTIssue const& mptIssue) { auto const sle = env.le(keylet::mptoken(mptIssue.getMptID(), account)); - if (kNONE) + if (kNone) { TEST_EXPECT(!sle); } 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..56197e1078 100644 --- a/src/test/jtx/impl/envconfig.cpp +++ b/src/test/jtx/impl/envconfig.cpp @@ -20,12 +20,12 @@ setupConfigForUnitTests(Config& cfg) using namespace jtx; // Default fees to old values, so tests don't have to worry about changes in // Config.h - cfg.FEES.reference_fee = UNIT_TEST_REFERENCE_FEE; - cfg.FEES.account_reserve = XRP(200).value().xrp().drops(); - cfg.FEES.owner_reserve = XRP(50).value().xrp().drops(); + cfg.fees.referenceFee = UNIT_TEST_REFERENCE_FEE; + cfg.fees.accountReserve = XRP(200).value().xrp().drops(); + cfg.fees.ownerReserve = XRP(50).value().xrp().drops(); // The Beta API (currently v2) is always available to tests - cfg.BETA_RPC_API = true; + cfg.betaRpcApi = true; cfg.overwrite(ConfigSection::nodeDatabase(), "type", "memory"); cfg.overwrite(ConfigSection::nodeDatabase(), "path", "main"); @@ -54,7 +54,7 @@ setupConfigForUnitTests(Config& cfg) cfg[PORT_WS].set("admin", getEnvLocalhostAddr()); cfg[PORT_WS].set("port", "0"); cfg[PORT_WS].set("protocol", "ws"); - cfg.SSL_VERIFY = false; + cfg.sslVerify = false; } namespace jtx { @@ -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,25 +89,25 @@ 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 singleThreadIo(std::unique_ptr cfg) { - cfg->IO_WORKERS = 1; + cfg->ioWorkers = 1; return cfg; } -auto constexpr kDEFAULTSEED = "shUwVw52ofnCUX5m7kPTKzJdr4HEH"; +constexpr auto kDefaultSeed = "shUwVw52ofnCUX5m7kPTKzJdr4HEH"; std::unique_ptr validator(std::unique_ptr cfg, std::string const& seed) { // If the config has valid validation keys then we run as a validator. cfg->section(SECTION_VALIDATION_SEED) - .append(std::vector{seed.empty() ? kDEFAULTSEED : seed}); + .append(std::vector{seed.empty() ? kDefaultSeed : seed}); return cfg; } @@ -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/ledgerStateFixes.cpp b/src/test/jtx/impl/ledgerStateFixes.cpp index a4b6d9b986..30c6659124 100644 --- a/src/test/jtx/impl/ledgerStateFixes.cpp +++ b/src/test/jtx/impl/ledgerStateFixes.cpp @@ -1,6 +1,7 @@ #include #include +#include #include #include #include @@ -22,4 +23,16 @@ nftPageLinks(jtx::Account const& acct, jtx::Account const& owner) return jv; } +// Fix sfExchangeRate on a book directory. acct pays fee. +json::Value +bookExchangeRate(jtx::Account const& acct, uint256 const& bookDir) +{ + json::Value jv; + jv[sfAccount.jsonName] = acct.human(); + jv[sfLedgerFixType.jsonName] = static_cast(LedgerStateFix::FixType::BookExchangeRate); + jv[sfBookDirectory.jsonName] = to_string(bookDir); + jv[sfTransactionType.jsonName] = jss::LedgerStateFix; + return jv; +} + } // namespace xrpl::test::jtx::ledgerStateFix 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_dex.cpp b/src/test/jtx/impl/permissioned_dex.cpp index 012932fed5..5c059e9e80 100644 --- a/src/test/jtx/impl/permissioned_dex.cpp +++ b/src/test/jtx/impl/permissioned_dex.cpp @@ -48,7 +48,7 @@ PermissionedDEX::PermissionedDEX(Env& env) , alice("permdex-alice") , bob("permdex-bob") , carol("permdex-carol") - , USD(gw["USD"]) + , usd(gw["USD"]) , credType("permdex-abcde") { // Fund accounts @@ -59,10 +59,10 @@ PermissionedDEX::PermissionedDEX(Env& env) for (auto const& account : {alice, bob, carol, domainOwner}) { - env.trust(USD(1000), account); + env.trust(usd(1000), account); env.close(); - env(pay(gw, account, USD(100))); + env(pay(gw, account, usd(100))); env.close(); } } 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..24669e6d4f 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; @@ -373,15 +379,15 @@ XChainBridgeObjects::XChainBridgeObjects() , scuGw("scuGw") , mcUSD(mcGw["USD"]) , scUSD(scGw["USD"]) - , jvXRPBridgeRPC(bridgeRpc(mcDoor, xrpIssue(), Account::kMASTER, xrpIssue())) - , jvb(bridge(mcDoor, xrpIssue(), Account::kMASTER, xrpIssue())) - , jvub(bridge(mcuDoor, xrpIssue(), Account::kMASTER, xrpIssue())) + , jvXRPBridgeRPC(bridgeRpc(mcDoor, xrpIssue(), Account::kMaster, xrpIssue())) + , jvb(bridge(mcDoor, xrpIssue(), Account::kMaster, xrpIssue())) + , jvub(bridge(mcuDoor, xrpIssue(), Account::kMaster, xrpIssue())) , features(testableAmendments() | FeatureBitset{featureXChainBridge}) , signers([] { - constexpr int kNUM_SIGNERS = kUT_XCHAIN_DEFAULT_NUM_SIGNERS; + static constexpr int kNumSigners = kUtXchainDefaultNumSigners; std::vector result; - result.reserve(kNUM_SIGNERS); - for (int i = 0; i < kNUM_SIGNERS; ++i) + result.reserve(kNumSigners); + for (int i = 0; i < kNumSigners; ++i) { using namespace std::literals; auto const a = Account( @@ -390,11 +396,11 @@ XChainBridgeObjects::XChainBridgeObjects() } return result; }()) - , alt_signers([] { - constexpr int kNUM_SIGNERS = kUT_XCHAIN_DEFAULT_NUM_SIGNERS; + , altSigners([] { + static constexpr int kNumSigners = kUtXchainDefaultNumSigners; std::vector result; - result.reserve(kNUM_SIGNERS); - for (int i = 0; i < kNUM_SIGNERS; ++i) + result.reserve(kNumSigners); + for (int i = 0; i < kNumSigners; ++i) { using namespace std::literals; auto const a = Account( @@ -425,20 +431,16 @@ XChainBridgeObjects::XChainBridgeObjects() return r; }()) , reward(XRP(1)) - , split_reward_quorum(divide(reward, STAmount(kUT_XCHAIN_DEFAULT_QUORUM), reward.get())) - , split_reward_everyone( - divide(reward, STAmount(kUT_XCHAIN_DEFAULT_NUM_SIGNERS), reward.get())) - , tiny_reward(drops(37)) - , tiny_reward_split( - (divide(tiny_reward, STAmount(kUT_XCHAIN_DEFAULT_QUORUM), tiny_reward.get()))) - , tiny_reward_remainder( - tiny_reward - - multiply( - tiny_reward_split, - STAmount(kUT_XCHAIN_DEFAULT_QUORUM), - tiny_reward.get())) - , one_xrp(XRP(1)) - , xrp_dust(divide(one_xrp, STAmount(10000), one_xrp.get())) + , splitRewardQuorum(divide(reward, STAmount(kUtXchainDefaultQuorum), reward.get())) + , splitRewardEveryone(divide(reward, STAmount(kUtXchainDefaultNumSigners), reward.get())) + , tinyReward(drops(37)) + , tinyRewardSplit( + (divide(tinyReward, STAmount(kUtXchainDefaultQuorum), tinyReward.get()))) + , tinyRewardRemainder( + tinyReward - + multiply(tinyRewardSplit, STAmount(kUtXchainDefaultQuorum), tinyReward.get())) + , oneXrp(XRP(1)) + , xrpDust(divide(oneXrp, STAmount(10000), oneXrp.get())) { } @@ -466,13 +468,13 @@ XChainBridgeObjects::createScBridgeObjects(Env& scEnv) scEnv.fund(xrpFunds, scDoor, scAlice, scBob, scCarol, scGw, scAttester, scReward); // Signer's list must match the attestation signers - scEnv(jtx::signers(Account::kMASTER, signers.size(), signers)); + scEnv(jtx::signers(Account::kMaster, signers.size(), signers)); // create XRP bridges in both direction auto const reward = XRP(1); STAmount const minCreate = XRP(20); - scEnv(bridgeCreate(Account::kMASTER, jvb, reward, minCreate)); + scEnv(bridgeCreate(Account::kMaster, jvb, reward, minCreate)); scEnv.close(); } diff --git a/src/test/jtx/ledgerStateFix.h b/src/test/jtx/ledgerStateFix.h index 769a28fb08..71f3f76101 100644 --- a/src/test/jtx/ledgerStateFix.h +++ b/src/test/jtx/ledgerStateFix.h @@ -10,4 +10,8 @@ namespace xrpl::test::jtx::ledgerStateFix { json::Value nftPageLinks(jtx::Account const& acct, jtx::Account const& owner); +/** Repair sfExchangeRate on a book directory's first page. */ +json::Value +bookExchangeRate(jtx::Account const& acct, uint256 const& bookDir); + } // namespace xrpl::test::jtx::ledgerStateFix diff --git a/src/test/jtx/mpt.h b/src/test/jtx/mpt.h index 9dec95a2a2..c8a65d7541 100644 --- a/src/test/jtx/mpt.h +++ b/src/test/jtx/mpt.h @@ -13,7 +13,7 @@ namespace xrpl::test::jtx { class MPTTester; -auto const kMPT_DEX_FLAGS = tfMPTCanTrade | tfMPTCanTransfer; +auto const kMptDexFlags = tfMPTCanTrade | tfMPTCanTransfer; // Check flags settings on MPT create class MptFlags @@ -103,7 +103,7 @@ struct MPTInit // create MPTIssuanceID if seated and follow rules for MPTCreate args std::optional create = std::nullopt; }; -static MPTInit const kMPT_INIT_NO_FUND{.fund = false}; +static MPTInit const kMptInitNoFund{.fund = false}; struct MPTInitDef { @@ -112,7 +112,7 @@ struct MPTInitDef Holders holders = {}; // NOLINT(readability-redundant-member-init) std::uint16_t transferFee = 0; std::optional pay = std::nullopt; - std::uint32_t flags = kMPT_DEX_FLAGS; + std::uint32_t flags = kMptDexFlags; std::optional mutableFlags = std::nullopt; bool authHolder = false; bool fund = false; diff --git a/src/test/jtx/multisign.h b/src/test/jtx/multisign.h index 62da7f65bc..3fef2ab446 100644 --- a/src/test/jtx/multisign.h +++ b/src/test/jtx/multisign.h @@ -46,7 +46,7 @@ public: SField const* const subField = nullptr; /// Used solely as a convenience placeholder for ctors that do _not_ specify /// a subfield. - static constexpr SField* const kTOP_LEVEL = nullptr; + static constexpr SField const* kTopLevel = nullptr; Msig(SField const* subField, std::vector signers) : signers(std::move(signers)), subField(subField) @@ -58,7 +58,7 @@ public: { } - Msig(std::vector signers) : Msig(kTOP_LEVEL, signers) + Msig(std::vector signers) : Msig(kTopLevel, signers) { } @@ -84,7 +84,7 @@ public: requires(std::convertible_to && !std::is_same_v) explicit Msig(AccountType&& a0, Accounts&&... aN) : Msig{ - kTOP_LEVEL, + kTopLevel, std::vector{std::forward(a0), std::forward(aN)...}} { } 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/permissioned_dex.h b/src/test/jtx/permissioned_dex.h index 025097116f..b0a4d4e2d5 100644 --- a/src/test/jtx/permissioned_dex.h +++ b/src/test/jtx/permissioned_dex.h @@ -20,7 +20,7 @@ public: Account alice; Account bob; Account carol; - IOU USD; + IOU usd; uint256 domainID; std::string credType; diff --git a/src/test/jtx/sig.h b/src/test/jtx/sig.h index 374f106684..e88785ef15 100644 --- a/src/test/jtx/sig.h +++ b/src/test/jtx/sig.h @@ -26,7 +26,7 @@ private: std::optional account_; /// Used solely as a convenience placeholder for ctors that do _not_ specify /// a subfield. - static constexpr SField* const kTOP_LEVEL = nullptr; + static constexpr SField const* kTopLevel = nullptr; public: explicit Sig(AutofillT) : manual_(false) @@ -46,7 +46,7 @@ public: { } - explicit Sig(Account const& account) : Sig(kTOP_LEVEL, account) + explicit Sig(Account const& account) : Sig(kTopLevel, account) { } diff --git a/src/test/jtx/tags.h b/src/test/jtx/tags.h index 66cf3b6ef7..4f4afbd1fa 100644 --- a/src/test/jtx/tags.h +++ b/src/test/jtx/tags.h @@ -6,19 +6,19 @@ struct NoneT { NoneT() = default; }; -static NoneT const kNONE; +static NoneT const kNone; struct AutofillT { AutofillT() = default; }; -static AutofillT const kAUTOFILL; +static AutofillT const kAutofill; struct DisabledT { DisabledT() = default; }; -static DisabledT const kDISABLED; +static DisabledT const kDisabled; /** Used for Fee() calls that use an owner reserve increment */ struct IncrementT @@ -26,6 +26,6 @@ struct IncrementT IncrementT() = default; }; -static IncrementT const kINCREMENT; +static IncrementT const kIncrement; } // namespace xrpl::test::jtx diff --git a/src/test/jtx/xchain_bridge.h b/src/test/jtx/xchain_bridge.h index d33b3bf4ac..e4c012510d 100644 --- a/src/test/jtx/xchain_bridge.h +++ b/src/test/jtx/xchain_bridge.h @@ -12,8 +12,8 @@ namespace xrpl::test::jtx { using JValueVec = std::vector; -constexpr std::size_t kUT_XCHAIN_DEFAULT_NUM_SIGNERS = 5; -constexpr std::size_t kUT_XCHAIN_DEFAULT_QUORUM = 4; +constexpr std::size_t kUtXchainDefaultNumSigners = 5; +constexpr std::size_t kUtXchainDefaultQuorum = 4; json::Value bridge( @@ -110,7 +110,7 @@ claimAttestations( std::uint64_t claimID, std::optional const& dst, std::vector const& signers, - std::size_t const numAtts = kUT_XCHAIN_DEFAULT_QUORUM, + std::size_t const numAtts = kUtXchainDefaultQuorum, std::size_t const fromIdx = 0); JValueVec @@ -125,7 +125,7 @@ createAccountAttestations( std::uint64_t createCount, jtx::Account const& dst, std::vector const& signers, - std::size_t const numAtts = kUT_XCHAIN_DEFAULT_QUORUM, + std::size_t const numAtts = kUtXchainDefaultQuorum, std::size_t const fromIdx = 0); struct XChainBridgeObjects @@ -165,23 +165,23 @@ struct XChainBridgeObjects FeatureBitset const features; std::vector const signers; - std::vector const alt_signers; + std::vector const altSigners; std::vector const payee; std::vector const payees; - std::uint32_t const quorum{kUT_XCHAIN_DEFAULT_QUORUM}; + std::uint32_t const quorum{kUtXchainDefaultQuorum}; - STAmount const reward; // 1 xrp - STAmount const split_reward_quorum; // 250,000 drops - STAmount const split_reward_everyone; // 200,000 drops + STAmount const reward; // 1 xrp + STAmount const splitRewardQuorum; // 250,000 drops + STAmount const splitRewardEveryone; // 200,000 drops - STAmount const tiny_reward; // 37 drops - STAmount const tiny_reward_split; // 9 drops - STAmount const tiny_reward_remainder; // 1 drops + STAmount const tinyReward; // 37 drops + STAmount const tinyRewardSplit; // 9 drops + STAmount const tinyRewardRemainder; // 1 drops - STAmount const one_xrp; - STAmount const xrp_dust; + STAmount const oneXrp; + STAmount const xrpDust; - static constexpr int kDROP_PER_XRP = 1000000; + static constexpr int kDropPerXrp = 1000000; XChainBridgeObjects(); @@ -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/Directory_test.cpp b/src/test/ledger/Directory_test.cpp index 4f3c94f695..a207b83f30 100644 --- a/src/test/ledger/Directory_test.cpp +++ b/src/test/ledger/Directory_test.cpp @@ -137,8 +137,8 @@ struct Directory_test : public beast::unit_test::Suite // Ensure that the page contains the correct orders by // calculating which sequence numbers belong here. - std::uint32_t const minSeq = firstOfferSeq + (page * kDIR_NODE_MAX_ENTRIES); - std::uint32_t const maxSeq = minSeq + kDIR_NODE_MAX_ENTRIES; + std::uint32_t const minSeq = firstOfferSeq + (page * kDirNodeMaxEntries); + std::uint32_t const maxSeq = minSeq + kDirNodeMaxEntries; for (auto const& e : v) { @@ -189,14 +189,14 @@ struct Directory_test : public beast::unit_test::Suite env.close(); BEAST_EXPECT(!dirIsEmpty(*env.closed(), keylet::ownerDir(alice))); - env(signers(alice, jtx::kNONE)); + env(signers(alice, jtx::kNone)); env.close(); BEAST_EXPECT(dirIsEmpty(*env.closed(), keylet::ownerDir(alice))); std::vector const currencies = [this, &gw]() { std::vector c; - c.reserve((2 * kDIR_NODE_MAX_ENTRIES) + 3); + c.reserve((2 * kDirNodeMaxEntries) + 3); while (c.size() != c.capacity()) c.push_back(gw[currcode(c.size())]); @@ -295,7 +295,7 @@ struct Directory_test : public beast::unit_test::Suite // Fill up three pages of offers for (int i = 0; i < 3; ++i) { - for (int j = 0; j < kDIR_NODE_MAX_ENTRIES; ++j) + for (int j = 0; j < kDirNodeMaxEntries; ++j) env(offer(alice, XRP(1), usd(1))); } env.close(); @@ -303,9 +303,9 @@ struct Directory_test : public beast::unit_test::Suite // remove all the offers. Remove the middle page last for (auto page : {0, 2, 1}) { - for (int i = 0; i < kDIR_NODE_MAX_ENTRIES; ++i) + for (int i = 0; i < kDirNodeMaxEntries; ++i) { - env(offerCancel(alice, firstOfferSeq + (page * kDIR_NODE_MAX_ENTRIES) + i)); + env(offerCancel(alice, firstOfferSeq + (page * kDirNodeMaxEntries) + i)); env.close(); } } @@ -346,54 +346,54 @@ struct Directory_test : public beast::unit_test::Suite env.fund(XRP(10000), alice); env.close(); - constexpr uint256 kBASE("fb71c9aa3310141da4b01d6c744a98286af2d72ab5448d5adc0910ca0c910880"); + constexpr uint256 kBase("fb71c9aa3310141da4b01d6c744a98286af2d72ab5448d5adc0910ca0c910880"); - constexpr uint256 kITEM("bad0f021aa3b2f6754a8fe82a5779730aa0bbbab82f17201ef24900efc2c7312"); + constexpr uint256 kItem("bad0f021aa3b2f6754a8fe82a5779730aa0bbbab82f17201ef24900efc2c7312"); { // Create a chain of three pages: Sandbox sb(env.closed().get(), TapNone); - makePages(sb, kBASE, 3); + makePages(sb, kBase, 3); // Insert an item in the middle page: { - auto p = sb.peek(keylet::page(kBASE, 1)); + auto p = sb.peek(keylet::page(kBase, 1)); BEAST_EXPECT(p); STVector256 v; - v.pushBack(kITEM); + v.pushBack(kItem); p->setFieldV256(sfIndexes, v); sb.update(p); } // Now, try to delete the item from the middle // page. This should cause all pages to be deleted: - BEAST_EXPECT(sb.dirRemove(keylet::page(kBASE, 0), 1, keylet::unchecked(kITEM), false)); - BEAST_EXPECT(!sb.peek(keylet::page(kBASE, 2))); - BEAST_EXPECT(!sb.peek(keylet::page(kBASE, 1))); - BEAST_EXPECT(!sb.peek(keylet::page(kBASE, 0))); + BEAST_EXPECT(sb.dirRemove(keylet::page(kBase, 0), 1, keylet::unchecked(kItem), false)); + BEAST_EXPECT(!sb.peek(keylet::page(kBase, 2))); + BEAST_EXPECT(!sb.peek(keylet::page(kBase, 1))); + BEAST_EXPECT(!sb.peek(keylet::page(kBase, 0))); } { // Create a chain of four pages: Sandbox sb(env.closed().get(), TapNone); - makePages(sb, kBASE, 4); + makePages(sb, kBase, 4); // Now add items on pages 1 and 2: { - auto p1 = sb.peek(keylet::page(kBASE, 1)); + auto p1 = sb.peek(keylet::page(kBase, 1)); BEAST_EXPECT(p1); STVector256 v1; - v1.pushBack(~kITEM); + v1.pushBack(~kItem); p1->setFieldV256(sfIndexes, v1); sb.update(p1); - auto p2 = sb.peek(keylet::page(kBASE, 2)); + auto p2 = sb.peek(keylet::page(kBase, 2)); BEAST_EXPECT(p2); STVector256 v2; - v2.pushBack(kITEM); + v2.pushBack(kItem); p2->setFieldV256(sfIndexes, v2); sb.update(p2); } @@ -401,16 +401,16 @@ struct Directory_test : public beast::unit_test::Suite // Now, try to delete the item from page 2. // This should cause pages 2 and 3 to be // deleted: - BEAST_EXPECT(sb.dirRemove(keylet::page(kBASE, 0), 2, keylet::unchecked(kITEM), false)); - BEAST_EXPECT(!sb.peek(keylet::page(kBASE, 3))); - BEAST_EXPECT(!sb.peek(keylet::page(kBASE, 2))); + BEAST_EXPECT(sb.dirRemove(keylet::page(kBase, 0), 2, keylet::unchecked(kItem), false)); + BEAST_EXPECT(!sb.peek(keylet::page(kBase, 3))); + BEAST_EXPECT(!sb.peek(keylet::page(kBase, 2))); - auto p1 = sb.peek(keylet::page(kBASE, 1)); + auto p1 = sb.peek(keylet::page(kBase, 1)); BEAST_EXPECT(p1); BEAST_EXPECT(p1->getFieldU64(sfIndexNext) == 0); BEAST_EXPECT(p1->getFieldU64(sfIndexPrevious) == 0); - auto p0 = sb.peek(keylet::page(kBASE, 0)); + auto p0 = sb.peek(keylet::page(kBase, 0)); BEAST_EXPECT(p0); BEAST_EXPECT(p0->getFieldU64(sfIndexNext) == 1); BEAST_EXPECT(p0->getFieldU64(sfIndexPrevious) == 1); @@ -569,13 +569,13 @@ struct Directory_test : public beast::unit_test::Suite testableAmendments() - fixDirectoryLimit, [this](Env&) -> std::tuple { testcase("directory full without fixDirectoryLimit"); - return {kDIR_NODE_MAX_PAGES - 1, true}; + return {kDirNodeMaxPages - 1, true}; }); testCase( testableAmendments(), // [this](Env&) -> std::tuple { testcase("directory not full with fixDirectoryLimit"); - return {kDIR_NODE_MAX_PAGES - 1, false}; + return {kDirNodeMaxPages - 1, false}; }); testCase( testableAmendments(), // diff --git a/src/test/ledger/PaymentSandbox_test.cpp b/src/test/ledger/PaymentSandbox_test.cpp index a100b4a51d..f59b75091a 100644 --- a/src/test/ledger/PaymentSandbox_test.cpp +++ b/src/test/ledger/PaymentSandbox_test.cpp @@ -87,7 +87,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite PathSet const paths(TestPath(gw1, usdGw2, gw2), TestPath(gw2, usdGw1, gw1)); - env(pay(snd, rcv, kANY(usdGw1(4))), + env(pay(snd, rcv, kAny(usdGw1(4))), Json(paths.json()), Txflags(tfNoRippleDirect | tfPartialPayment)); @@ -307,9 +307,9 @@ class PaymentSandbox_test : public beast::unit_test::Suite auto const issue = usd; STAmount const tinyAmt( - issue, STAmount::kMIN_VALUE, STAmount::kMIN_OFFSET + 1, false, STAmount::Unchecked{}); + issue, STAmount::kMinValue, STAmount::kMinOffset + 1, false, STAmount::Unchecked{}); STAmount const hugeAmt( - issue, STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET - 1, false, STAmount::Unchecked{}); + issue, STAmount::kMaxValue, STAmount::kMaxOffset - 1, false, STAmount::Unchecked{}); ApplyViewImpl av(&*env.current(), TapNone); PaymentSandbox pv(&av); @@ -354,7 +354,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite auto r = accountSend(sb, alice, xrpAccount(), XRP(100), env.journal); BEAST_EXPECT(isTesSuccess(r)); } - BEAST_EXPECT(accountFundsXRP(sb, alice, env.journal) == beast::kZERO); + BEAST_EXPECT(accountFundsXRP(sb, alice, env.journal) == beast::kZero); } } diff --git a/src/test/ledger/SkipList_test.cpp b/src/test/ledger/SkipList_test.cpp index dd4ebd27fd..fd3cc2f214 100644 --- a/src/test/ledger/SkipList_test.cpp +++ b/src/test/ledger/SkipList_test.cpp @@ -23,9 +23,9 @@ class SkipList_test : public beast::unit_test::Suite { Config const config; auto prev = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config.features}, - config.FEES.toFees(), + config.fees.toFees(), std::vector{}, env.app().getNodeFamily()); history.push_back(prev); diff --git a/src/test/ledger/View_test.cpp b/src/test/ledger/View_test.cpp index 2cf6517c8a..d1c7316588 100644 --- a/src/test/ledger/View_test.cpp +++ b/src/test/ledger/View_test.cpp @@ -151,9 +151,9 @@ class View_test : public beast::unit_test::Suite Env env(*this); Config const config; std::shared_ptr const genesis = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config.features}, - config.FEES.toFees(), + config.fees.toFees(), std::vector{}, env.app().getNodeFamily()); auto const ledger = @@ -419,9 +419,9 @@ class View_test : public beast::unit_test::Suite Env env(*this); Config const config; std::shared_ptr const genesis = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config.features}, - config.FEES.toFees(), + config.fees.toFees(), std::vector{}, env.app().getNodeFamily()); auto const ledger = @@ -628,9 +628,9 @@ class View_test : public beast::unit_test::Suite Env env(*this); Config const config; std::shared_ptr const genesis = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config.features}, - config.FEES.toFees(), + config.fees.toFees(), std::vector{}, env.app().getNodeFamily()); auto const ledger = @@ -935,7 +935,7 @@ class View_test : public beast::unit_test::Suite auto rdView = env.closed(); // Test with no rate set on gw1. - BEAST_EXPECT(transferRate(*rdView, gw1) == kPARITY_RATE); + BEAST_EXPECT(transferRate(*rdView, gw1) == kParityRate); env(rate(gw1, 1.02)); env.close(); @@ -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. @@ -1018,9 +1018,9 @@ class View_test : public beast::unit_test::Suite Env env(*this); Config const config; std::shared_ptr const genesis = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config.features}, - config.FEES.toFees(), + config.fees.toFees(), std::vector{}, env.app().getNodeFamily()); auto const ledger = 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/Basics_test.cpp b/src/test/nodestore/Basics_test.cpp index d0445cc1ab..5565399cc2 100644 --- a/src/test/nodestore/Basics_test.cpp +++ b/src/test/nodestore/Basics_test.cpp @@ -21,13 +21,13 @@ public: { testcase("batch"); - auto batch1 = createPredictableBatch(kNUM_OBJECTS_TO_TEST, seedValue); + auto batch1 = createPredictableBatch(kNumObjectsToTest, seedValue); - auto batch2 = createPredictableBatch(kNUM_OBJECTS_TO_TEST, seedValue); + auto batch2 = createPredictableBatch(kNumObjectsToTest, seedValue); BEAST_EXPECT(areBatchesEqual(batch1, batch2)); - auto batch3 = createPredictableBatch(kNUM_OBJECTS_TO_TEST, seedValue + 1); + auto batch3 = createPredictableBatch(kNumObjectsToTest, seedValue + 1); BEAST_EXPECT(!areBatchesEqual(batch1, batch3)); } @@ -38,7 +38,7 @@ public: { testcase("encoding"); - auto batch = createPredictableBatch(kNUM_OBJECTS_TO_TEST, seedValue); + auto batch = createPredictableBatch(kNumObjectsToTest, seedValue); for (int i = 0; i < batch.size(); ++i) { diff --git a/src/test/nodestore/Database_test.cpp b/src/test/nodestore/Database_test.cpp index a152bb3a2d..50bdfefd4c 100644 --- a/src/test/nodestore/Database_test.cpp +++ b/src/test/nodestore/Database_test.cpp @@ -74,13 +74,13 @@ public: auto& section = p->section("sqlite"); section.set("safety_level", "high"); } - p->LEDGER_HISTORY = 100'000'000; + p->ledgerHistory = 100'000'000; return Env( *this, std::move(p), std::make_unique(integrityWarning, &found), - beast::severities::KWarning); + beast::Severity::Warning); }(); BEAST_EXPECT(!found); @@ -103,13 +103,13 @@ public: auto& section = p->section("sqlite"); section.set("safety_level", "low"); } - p->LEDGER_HISTORY = 100'000'000; + p->ledgerHistory = 100'000'000; return Env( *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 @@ -166,13 +166,13 @@ public: section.set("synchronous", "extra"); section.set("temp_store", "default"); } - p->LEDGER_HISTORY = 50'000'000; + p->ledgerHistory = 50'000'000; return Env( *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 (...) @@ -536,7 +536,7 @@ public: srcParams.set("path", nodeDb.path()); // Create a batch - auto batch = createPredictableBatch(kNUM_OBJECTS_TO_TEST, seedValue); + auto batch = createPredictableBatch(kNumObjectsToTest, seedValue); // Write to source db { @@ -647,7 +647,7 @@ public: { std::unique_ptr db = Manager::instance().makeDatabase( megabytes(4), scheduler, 2, nodeParams, journal_); - BEAST_EXPECT(db->earliestLedgerSeq() == kXRP_LEDGER_EARLIEST_SEQ); + BEAST_EXPECT(db->earliestLedgerSeq() == kXrpLedgerEarliestSeq); } // Set an invalid earliest ledger sequence @@ -676,7 +676,7 @@ public: try { // Set to default earliest ledger sequence - nodeParams.set("earliest_seq", std::to_string(kXRP_LEDGER_EARLIEST_SEQ)); + nodeParams.set("earliest_seq", std::to_string(kXrpLedgerEarliestSeq)); std::unique_ptr const db2 = Manager::instance().makeDatabase( megabytes(4), scheduler, 2, nodeParams, journal_); } 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/TestBase.h b/src/test/nodestore/TestBase.h index 7cde0266ab..c35042bd4f 100644 --- a/src/test/nodestore/TestBase.h +++ b/src/test/nodestore/TestBase.h @@ -47,9 +47,9 @@ class TestBase : public beast::unit_test::Suite public: // Tunable parameters // - static std::size_t const kMIN_PAYLOAD_BYTES = 1; - static std::size_t const kMAX_PAYLOAD_BYTES = 2000; - static int const kNUM_OBJECTS_TO_TEST = 2000; + static std::size_t const kMinPayloadBytes = 1; + static std::size_t const kMaxPayloadBytes = 2000; + static int const kNumObjectsToTest = 2000; public: // Create a predictable batch of objects @@ -83,7 +83,7 @@ public: uint256 hash; beast::rngfill(hash.begin(), hash.size(), rng); - Blob blob(randInt(rng, kMIN_PAYLOAD_BYTES, kMAX_PAYLOAD_BYTES)); + Blob blob(randInt(rng, kMinPayloadBytes, kMaxPayloadBytes)); beast::rngfill(blob.data(), blob.size(), rng); batch.push_back(NodeObject::createObject(type, std::move(blob), hash)); diff --git a/src/test/nodestore/Timing_test.cpp b/src/test/nodestore/Timing_test.cpp index dfc1a0235d..67feace198 100644 --- a/src/test/nodestore/Timing_test.cpp +++ b/src/test/nodestore/Timing_test.cpp @@ -77,22 +77,23 @@ 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 kMinLedger = 1; + static constexpr auto kMaxLedger = 1000000; + static constexpr auto kMinSize = 250; + static constexpr auto kMaxSize = 1250; beast::xor_shift_engine gen_; std::uint8_t prefix_; - std::discrete_distribution d_type_; - std::uniform_int_distribution d_size_; + std::discrete_distribution dType_; + std::uniform_int_distribution dSize_; public: explicit Sequence(std::uint8_t prefix) : prefix_(prefix) // uniform distribution over hotLEDGER - hotTRANSACTION_NODE // but exclude hotTRANSACTION = 2 (removed) - , d_type_({1, 1, 0, 1, 1}) - , d_size_(MinSize, MaxSize) + , dType_({1, 1, 0, 1, 1}) + , dSize_(kMinSize, kMaxSize) { } @@ -115,10 +116,10 @@ public: auto const data = static_cast(&*key.begin()); *data = prefix_; rngcpy(data + 1, key.size() - 1, gen_); - Blob value(d_size_(gen_)); + Blob value(dSize_(gen_)); rngcpy(&value[0], value.size(), gen_); return NodeObject::createObject( - safeCast(d_type_(gen_)), std::move(value), key); + safeCast(dType_(gen_)), std::move(value), key); } // returns a batch of NodeObjects starting at n @@ -137,18 +138,13 @@ 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 kMissingNodePercent = 20; // percent of fetches for missing nodes - std::size_t const default_repeat = 3; + std::size_t const defaultRepeat = 3; #ifndef NDEBUG - std::size_t const default_items = 10000; + std::size_t const defaultItems = 10000; #else - std::size_t const default_items = 100000; // release + std::size_t const defaultItems = 100000; // release #endif using clock_type = std::chrono::steady_clock; @@ -466,7 +462,7 @@ public: { try { - if (rand_(gen_) < MissingNodePercent) + if (rand_(gen_) < kMissingNodePercent) { auto const hash = seq2_.key(dist_(gen_)); std::shared_ptr result; @@ -643,7 +639,7 @@ public: { w = std::max::size_type>(w, test.first.size()); } - log << threads << " Thread" << (threads > 1 ? "s" : "") << ", " << default_items + log << threads << " Thread" << (threads > 1 ? "s" : "") << ", " << defaultItems << " Objects" << std::endl; { std::stringstream ss; @@ -653,15 +649,15 @@ public: log << ss.str() << std::endl; } - using namespace beast::severities; + using beast::Severity; test::SuiteJournal journal("Timing_test", *this); for (auto const& configString : configStrings) { Params params{}; - params.items = default_items; + params.items = defaultItems; params.threads = threads; - for (auto i = default_repeat; (i--) != 0u;) + for (auto i = defaultRepeat; (i--) != 0u;) { beast::TempDir const tempDir; Section config = parse(configString); diff --git a/src/test/nodestore/import_test.cpp b/src/test/nodestore/import_test.cpp index 0ef7b2314f..a80b5ccc93 100644 --- a/src/test/nodestore/import_test.cpp +++ b/src/test/nodestore/import_test.cpp @@ -253,7 +253,7 @@ std::map parseArgs(std::string const& s) { // '=' - static boost::regex const kRE1( + static boost::regex const kRe1( "^" // start of line "(?:\\s*)" // whitespace (optional) "([a-zA-Z][_a-zA-Z0-9]*)" // @@ -269,7 +269,7 @@ parseArgs(std::string const& s) for (auto const& kv : v) { boost::smatch m; - if (!boost::regex_match(kv, m, kRE1)) + if (!boost::regex_match(kv, m, kRe1)) Throw("invalid parameter " + kv); auto const result = map.emplace(m[1], m[2]); if (!result.second) diff --git a/src/test/nodestore/varint_test.cpp b/src/test/nodestore/varint_test.cpp index f45de568f3..68e88d831a 100644 --- a/src/test/nodestore/varint_test.cpp +++ b/src/test/nodestore/varint_test.cpp @@ -17,7 +17,7 @@ public: testcase("encode, decode"); for (auto const v : vv) { - std::array::kMAX> vi{}; + std::array::kMax> vi{}; auto const n0 = writeVarint(vi.data(), v); expect(n0 > 0, "write error"); expect(n0 == sizeVarint(v), "size error"); diff --git a/src/test/overlay/TMGetObjectByHash_test.cpp b/src/test/overlay/TMGetObjectByHash_test.cpp index fa47f42740..961e1b7eb4 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::kHardMaxReplyNodes); 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..60cc69a14f 100644 --- a/src/test/overlay/compression_test.cpp +++ b/src/test/overlay/compression_test.cpp @@ -112,23 +112,23 @@ public: return; std::vector decompressed; - decompressed.resize(header->uncompressed_size); + decompressed.resize(header->uncompressedSize); - BEAST_EXPECT(header->payload_wire_size == buffer.size() - header->header_size); + BEAST_EXPECT(header->payloadWireSize == buffer.size() - header->headerSize); ZeroCopyInputStream stream(buffers.data()); - stream.Skip(header->header_size); + stream.Skip(header->headerSize); auto decompressedSize = xrpl::compression::decompress( - stream, header->payload_wire_size, decompressed.data(), header->uncompressed_size); - BEAST_EXPECT(decompressedSize == header->uncompressed_size); + stream, header->payloadWireSize, decompressed.data(), header->uncompressedSize); + BEAST_EXPECT(decompressedSize == header->uncompressedSize); auto const proto1 = std::make_shared(); BEAST_EXPECT(proto1->ParseFromArray(decompressed.data(), decompressedSize)); auto uncompressed = m.getBuffer(Compressed::Off); BEAST_EXPECT( std::equal( - uncompressed.begin() + xrpl::compression::kHEADER_BYTES, + uncompressed.begin() + xrpl::compression::kHeaderBytes, uncompressed.end(), decompressed.begin())); } @@ -142,7 +142,7 @@ public: { auto master = randomKeyPair(KeyType::Ed25519); auto signing = randomKeyPair(KeyType::Ed25519); - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = i; st[sfPublicKey] = std::get<0>(master); st[sfSigningPubKey] = std::get<0>(signing); @@ -299,7 +299,7 @@ public: auto master = randomKeyPair(KeyType::Ed25519); auto signing = randomKeyPair(KeyType::Ed25519); - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = 0; st[sfPublicKey] = std::get<0>(master); st[sfSigningPubKey] = std::get<0>(signing); @@ -326,7 +326,7 @@ public: auto master = randomKeyPair(KeyType::Ed25519); auto signing = randomKeyPair(KeyType::Ed25519); - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfSequence] = 0; st[sfPublicKey] = std::get<0>(master); st[sfSigningPubKey] = std::get<0>(signing); @@ -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; @@ -408,9 +408,8 @@ public: << enable << "\n"; c.loadFromString(str.str()); auto env = std::make_shared(*this); - env->app().config().COMPRESSION = c.COMPRESSION; - env->app().config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = - c.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE; + env->app().config().compression = c.compression; + env->app().config().vpReduceRelayBaseSquelchEnable = c.vpReduceRelayBaseSquelchEnable; return env; }; auto handshake = [&](int outboundEnable, int inboundEnable) { @@ -419,10 +418,10 @@ public: auto env = getEnv(outboundEnable); auto request = xrpl::makeRequest( true, - env->app().config().COMPRESSION, + env->app().config().compression, false, - env->app().config().TX_REDUCE_RELAY_ENABLE, - env->app().config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE); + env->app().config().txReduceRelayEnable, + env->app().config().vpReduceRelayBaseSquelchEnable); http_request_type httpRequest; httpRequest.version(request.version()); httpRequest.base() = request.base(); @@ -432,7 +431,7 @@ public: // inbound is enabled if the request's header has the feature // enabled and the peer's configuration is enabled auto const inboundEnabled = - peerFeatureEnabled(httpRequest, kFEATURE_COMPR, "lz4", inboundEnable); + peerFeatureEnabled(httpRequest, kFeatureCompr, "lz4", inboundEnable); BEAST_EXPECT(!(peerEnabled ^ inboundEnabled)); env.reset(); @@ -442,7 +441,7 @@ public: // outbound is enabled if the response's header has the feature // enabled and the peer's configuration is enabled auto const outboundEnabled = - peerFeatureEnabled(httpResp, kFEATURE_COMPR, "lz4", outboundEnable); + peerFeatureEnabled(httpResp, kFeatureCompr, "lz4", outboundEnable); BEAST_EXPECT(!(peerEnabled ^ outboundEnabled)); }; handshake(1, 1); diff --git a/src/test/overlay/reduce_relay_test.cpp b/src/test/overlay/reduce_relay_test.cpp index 842e739fa6..54d8f555a2 100644 --- a/src/test/overlay/reduce_relay_test.cpp +++ b/src/test/overlay/reduce_relay_test.cpp @@ -60,9 +60,9 @@ using SquelchCB = std::function; using LinkIterCB = std::function; -static constexpr std::uint32_t kMAX_PEERS = 10; -static constexpr std::uint32_t kMAX_VALIDATORS = 10; -static constexpr std::uint32_t kMAX_MESSAGES = 200000; +static constexpr std::uint32_t kMaxPeers = 10; +static constexpr std::uint32_t kMaxValidators = 10; +static constexpr std::uint32_t kMaxMessages = 200000; /** Simulate two entities - peer directly connected to the server * (via squelch in PeerSim) and PeerImp (via Overlay) @@ -142,8 +142,8 @@ public: [[nodiscard]] uint256 const& getClosedLedgerHash() const override { - static uint256 const kHASH{}; - return kHASH; + static uint256 const kHash{}; + return kHash; } [[nodiscard]] bool hasLedger(uint256 const& hash, std::uint32_t seq) const override @@ -205,25 +205,25 @@ public: static void advance(duration d) noexcept { - kNOW += d; + kNow += d; } static void randAdvance(milliseconds min, milliseconds max) { - kNOW += randDuration(min, max); + kNow += randDuration(min, max); } static void reset() noexcept { - kNOW = time_point(seconds(0)); + kNow = time_point(seconds(0)); } static time_point now() noexcept { - return kNOW; + return kNow; } static duration @@ -235,7 +235,7 @@ public: explicit ManualClock() = default; private: - inline static time_point kNOW = time_point(seconds(0)); + inline static time_point kNow = time_point(seconds(0)); }; /** Simulate server's OverlayImpl */ @@ -704,8 +704,8 @@ public: void init() { - validators_.resize(kMAX_VALIDATORS); - for (int p = 0; p < kMAX_PEERS; p++) + validators_.resize(kMaxValidators); + for (int p = 0; p < kMaxPeers; p++) { auto peer = overlay_.addPeer(); for (auto& v : validators_) @@ -749,7 +749,7 @@ public: void purgePeers() { - while (overlay_.getNumPeers() > kMAX_PEERS) + while (overlay_.getNumPeers() > kMaxPeers) deleteLastPeer(); } @@ -817,8 +817,8 @@ public: void propagate( LinkIterCB link, - std::uint16_t nValidators = kMAX_VALIDATORS, - std::uint32_t nMessages = kMAX_MESSAGES, + std::uint16_t nValidators = kMaxValidators, + std::uint32_t nMessages = kMaxMessages, bool purge = true, bool resetClock = true) { @@ -973,8 +973,7 @@ protected: auto countingState = network_.overlay().isCountingState(validator); BEAST_EXPECT( countingState == false && - selected.size() == - env_.app().config().VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS); + selected.size() == env_.app().config().vpReduceRelaySquelchMaxSelectedPeers); } // Trigger Link Down or Peer Disconnect event @@ -1051,7 +1050,7 @@ protected: auto d = reduce_relay::epoch(now).count() - std::get<3>(peers[event.peer]); mustHandle = event.isSelected && - d > milliseconds(reduce_relay::kIDLED).count() && + d > milliseconds(reduce_relay::kIdled).count() && network_.overlay().inState(*event.key, reduce_relay::PeerState::Squelched) > 0 && peers.contains(event.peer); @@ -1070,7 +1069,7 @@ protected: } if (event.state == State::WaitReset || (event.state == State::On && - (now - event.time > (reduce_relay::kIDLED + seconds(2))))) + (now - event.time > (reduce_relay::kIdled + seconds(2))))) { bool const handled = event.state == State::WaitReset || !event.handled; BEAST_EXPECT(handled); @@ -1163,18 +1162,16 @@ protected: { BEAST_EXPECT( squelched == - kMAX_PEERS - - env_.app().config().VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS); + kMaxPeers - env_.app().config().vpReduceRelaySquelchMaxSelectedPeers); n++; } }, 1, - reduce_relay::kMAX_MESSAGE_THRESHOLD + 2, + reduce_relay::kMaxMessageThreshold + 2, purge, resetClock); auto selected = network_.overlay().getSelected(network_.validator(0)); - BEAST_EXPECT( - selected.size() == env_.app().config().VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS); + BEAST_EXPECT(selected.size() == env_.app().config().vpReduceRelaySquelchMaxSelectedPeers); BEAST_EXPECT(n == 1); // only one selection round auto res = checkCounting(network_.validator(0), false); BEAST_EXPECT(res); @@ -1235,7 +1232,7 @@ protected: id, [&](PublicKey const& key, PeerWPtr const& peer) { unsquelched++; }); BEAST_EXPECT( unsquelched == - kMAX_PEERS - env_.app().config().VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS); + kMaxPeers - env_.app().config().vpReduceRelaySquelchMaxSelectedPeers); BEAST_EXPECT(checkCounting(network_.validator(0), true)); }); } @@ -1248,14 +1245,14 @@ protected: doTest("Selected Peer Stops Relaying", log, [this](bool log) { ManualClock::advance(seconds(601)); BEAST_EXPECT(propagateAndSquelch(log, true, false)); - ManualClock::advance(reduce_relay::kIDLED + seconds(1)); + ManualClock::advance(reduce_relay::kIdled + seconds(1)); std::uint16_t unsquelched = 0; network_.overlay().deleteIdlePeers( [&](PublicKey const& key, PeerWPtr const& peer) { unsquelched++; }); auto peers = network_.overlay().getPeers(network_.validator(0)); BEAST_EXPECT( unsquelched == - kMAX_PEERS - env_.app().config().VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS); + kMaxPeers - env_.app().config().vpReduceRelaySquelchMaxSelectedPeers); BEAST_EXPECT(checkCounting(network_.validator(0), true)); }); } @@ -1294,7 +1291,7 @@ vp_enable=1 )xrpldConfig"); c.loadFromString(toLoad); - BEAST_EXPECT(c.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE == true); + BEAST_EXPECT(c.vpReduceRelayBaseSquelchEnable == true); }); doTest("Test Config - squelch disabled (legacy)", log, [&](bool log) { @@ -1306,7 +1303,7 @@ vp_enable=0 )xrpldConfig"); c.loadFromString(toLoad); - BEAST_EXPECT(c.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE == false); + BEAST_EXPECT(c.vpReduceRelayBaseSquelchEnable == false); Config c1; @@ -1315,7 +1312,7 @@ vp_enable=0 )xrpldConfig"; c1.loadFromString(toLoad); - BEAST_EXPECT(c1.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE == false); + BEAST_EXPECT(c1.vpReduceRelayBaseSquelchEnable == false); }); doTest("Test Config - squelch enabled", log, [&](bool log) { @@ -1327,7 +1324,7 @@ vp_base_squelch_enable=1 )xrpldConfig"); c.loadFromString(toLoad); - BEAST_EXPECT(c.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE == true); + BEAST_EXPECT(c.vpReduceRelayBaseSquelchEnable == true); }); doTest("Test Config - squelch disabled", log, [&](bool log) { @@ -1339,7 +1336,7 @@ vp_base_squelch_enable=0 )xrpldConfig"); c.loadFromString(toLoad); - BEAST_EXPECT(c.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE == false); + BEAST_EXPECT(c.vpReduceRelayBaseSquelchEnable == false); }); doTest("Test Config - legacy and new", log, [&](bool log) { @@ -1379,7 +1376,7 @@ vp_enable=0 )xrpldConfig"); c.loadFromString(toLoad); - BEAST_EXPECT(c.VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS == 5); + BEAST_EXPECT(c.vpReduceRelaySquelchMaxSelectedPeers == 5); Config c1; @@ -1389,7 +1386,7 @@ vp_base_squelch_max_selected_peers=6 )xrpldConfig"; c1.loadFromString(toLoad); - BEAST_EXPECT(c1.VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS == 6); + BEAST_EXPECT(c1.vpReduceRelaySquelchMaxSelectedPeers == 6); Config c2; @@ -1422,7 +1419,7 @@ vp_base_squelch_max_selected_peers=2 doTest("BaseSquelchReady", log, [&](bool log) { ManualClock::reset(); auto createSlots = [&](bool baseSquelchEnabled) -> reduce_relay::Slots { - env_.app().config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = baseSquelchEnabled; + env_.app().config().vpReduceRelayBaseSquelchEnable = baseSquelchEnabled; return reduce_relay::Slots( env_.app(), network_.overlay(), env_.app().config()); }; @@ -1433,7 +1430,7 @@ vp_base_squelch_max_selected_peers=2 // bootup BEAST_EXPECT(!createSlots(true).baseSquelchReady()); - ManualClock::advance(reduce_relay::kWAIT_ON_BOOTUP + minutes{1}); + ManualClock::advance(reduce_relay::kWaitOnBootup + minutes{1}); // base squelch enabled and bootup time passed BEAST_EXPECT(createSlots(true).baseSquelchReady()); @@ -1470,7 +1467,7 @@ vp_base_squelch_max_selected_peers=2 peers = network_.overlay().getPeers(network_.validator(0)); BEAST_EXPECT(std::get<1>(peers[0]) == (nMessages - 1)); // advance the clock - ManualClock::advance(reduce_relay::kIDLED + seconds(1)); + ManualClock::advance(reduce_relay::kIdled + seconds(1)); network_.overlay().updateSlotAndSquelch( key, network_.validator(0), 0, [&](PublicKey const&, PeerWPtr, std::uint32_t) {}); peers = network_.overlay().getPeers(network_.validator(0)); @@ -1508,7 +1505,7 @@ vp_base_squelch_max_selected_peers=2 // to counting state and resets the counts of all peers + // MAX_MESSAGE_THRESHOLD + 1 messages to reach the threshold // and switch the slot's state to peer selection. - for (int m = 1; m <= reduce_relay::kMAX_MESSAGE_THRESHOLD + 2; m++) + for (int m = 1; m <= reduce_relay::kMaxMessageThreshold + 2; m++) { for (int peer = 0; peer < npeers; peer++) { @@ -1525,39 +1522,39 @@ vp_base_squelch_max_selected_peers=2 }; using namespace reduce_relay; - // expect max duration less than kMAX_UNSQUELCH_EXPIRE_DEFAULT with + // expect max duration less than kMaxUnsquelchExpireDefault with // less than or equal to 60 peers run(20); BEAST_EXPECT( - handler.maxDuration >= kMIN_UNSQUELCH_EXPIRE.count() && - handler.maxDuration <= kMAX_UNSQUELCH_EXPIRE_DEFAULT.count()); + handler.maxDuration >= kMinUnsquelchExpire.count() && + handler.maxDuration <= kMaxUnsquelchExpireDefault.count()); run(60); BEAST_EXPECT( - handler.maxDuration >= kMIN_UNSQUELCH_EXPIRE.count() && - handler.maxDuration <= kMAX_UNSQUELCH_EXPIRE_DEFAULT.count()); - // expect max duration greater than kMIN_UNSQUELCH_EXPIRE and less - // than kMAX_UNSQUELCH_EXPIRE_PEERS with peers greater than 60 + handler.maxDuration >= kMinUnsquelchExpire.count() && + handler.maxDuration <= kMaxUnsquelchExpireDefault.count()); + // expect max duration greater than kMinUnsquelchExpire and less + // than kMaxUnsquelchExpirePeers with peers greater than 60 // and less than 360 run(350); // can't make this condition stronger. squelch // duration is probabilistic and max condition may still fail. // log when the value is low BEAST_EXPECT( - handler.maxDuration >= kMIN_UNSQUELCH_EXPIRE.count() && - handler.maxDuration <= kMAX_UNSQUELCH_EXPIRE_PEERS.count()); + handler.maxDuration >= kMinUnsquelchExpire.count() && + handler.maxDuration <= kMaxUnsquelchExpirePeers.count()); using namespace beast::unit_test::detail; - if (handler.maxDuration <= kMAX_UNSQUELCH_EXPIRE_DEFAULT.count()) + if (handler.maxDuration <= kMaxUnsquelchExpireDefault.count()) { log << makeReason("warning: squelch duration is low", __FILE__, __LINE__) << std::endl << std::flush; } - // more than 400 is still less than kMAX_UNSQUELCH_EXPIRE_PEERS + // more than 400 is still less than kMaxUnsquelchExpirePeers run(400); BEAST_EXPECT( - handler.maxDuration >= kMIN_UNSQUELCH_EXPIRE.count() && - handler.maxDuration <= kMAX_UNSQUELCH_EXPIRE_PEERS.count()); - if (handler.maxDuration <= kMAX_UNSQUELCH_EXPIRE_DEFAULT.count()) + handler.maxDuration >= kMinUnsquelchExpire.count() && + handler.maxDuration <= kMaxUnsquelchExpirePeers.count()); + if (handler.maxDuration <= kMaxUnsquelchExpireDefault.count()) { log << makeReason("warning: squelch duration is low", __FILE__, __LINE__) << std::endl @@ -1578,10 +1575,10 @@ vp_base_squelch_max_selected_peers=2 << "[compression]\n" << "1\n"; c.loadFromString(str.str()); - env_.app().config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = - c.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE; + env_.app().config().vpReduceRelayBaseSquelchEnable = + c.vpReduceRelayBaseSquelchEnable; - env_.app().config().COMPRESSION = c.COMPRESSION; + env_.app().config().compression = c.compression; }; auto handshake = [&](int outboundEnable, int inboundEnable) { beast::IP::Address const addr = boost::asio::ip::make_address("172.1.1.100"); @@ -1589,10 +1586,10 @@ vp_base_squelch_max_selected_peers=2 setEnv(outboundEnable); auto request = xrpl::makeRequest( true, - env_.app().config().COMPRESSION, + env_.app().config().compression, false, - env_.app().config().TX_REDUCE_RELAY_ENABLE, - env_.app().config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE); + env_.app().config().txReduceRelayEnable, + env_.app().config().vpReduceRelayBaseSquelchEnable); http_request_type httpRequest; httpRequest.version(request.version()); httpRequest.base() = request.base(); @@ -1602,7 +1599,7 @@ vp_base_squelch_max_selected_peers=2 // inbound is enabled if the request's header has the feature // enabled and the peer's configuration is enabled auto const inboundEnabled = - peerFeatureEnabled(httpRequest, kFEATURE_VPRR, inboundEnable); + peerFeatureEnabled(httpRequest, kFeatureVprr, inboundEnable); BEAST_EXPECT(!(peerEnabled ^ inboundEnabled)); setEnv(inboundEnable); @@ -1611,7 +1608,7 @@ vp_base_squelch_max_selected_peers=2 // outbound is enabled if the response's header has the feature // enabled and the peer's configuration is enabled auto const outboundEnabled = - peerFeatureEnabled(httpResp, kFEATURE_VPRR, outboundEnable); + peerFeatureEnabled(httpResp, kFeatureVprr, outboundEnable); BEAST_EXPECT(!(peerEnabled ^ outboundEnabled)); }; handshake(1, 1); @@ -1627,8 +1624,8 @@ vp_base_squelch_max_selected_peers=2 public: reduce_relay_test() : env_(*this, jtx::envconfig([](std::unique_ptr cfg) { - cfg->VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = true; - cfg->VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS = 6; + cfg->vpReduceRelayBaseSquelchEnable = true; + cfg->vpReduceRelaySquelchMaxSelectedPeers = 6; return cfg; })) , network_(env_.app()) diff --git a/src/test/overlay/short_read_test.cpp b/src/test/overlay/short_read_test.cpp index 1b608edee7..9af632d65c 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 @@ -62,7 +62,7 @@ private: using endpoint_type = boost::asio::ip::tcp::endpoint; using address_type = boost::asio::ip::address; - io_context_type io_context_; + io_context_type ioContext_; boost::optional> work_; std::thread thread_; std::shared_ptr context_; @@ -185,10 +185,10 @@ private: , server(server) , test(server.test_) , acceptor( - test.io_context_, + test.ioContext_, endpoint_type(boost::asio::ip::make_address(test::getEnvLocalhostAddr()), 0)) - , socket(test.io_context_) - , strand(boost::asio::make_strand(test.io_context_)) + , socket(test.ioContext_) + , strand(boost::asio::make_strand(test.ioContext_)) { acceptor.listen(); server.endpoint_ = acceptor.local_endpoint(); @@ -261,8 +261,8 @@ private: , test(server.test_) , socket(std::move(inSocket)) , stream(socket, *test.context_) - , strand(boost::asio::make_strand(test.io_context_)) - , timer(test.io_context_) + , strand(boost::asio::make_strand(test.ioContext_)) + , timer(test.ioContext_) { } @@ -450,10 +450,10 @@ private: : Child(client) , client(client) , test(client.test_) - , socket(test.io_context_) + , socket(test.ioContext_) , stream(socket, *test.context_) - , strand(boost::asio::make_strand(test.io_context_)) - , timer(test.io_context_) + , strand(boost::asio::make_strand(test.ioContext_)) + , timer(test.ioContext_) , ep(ep) { } @@ -632,10 +632,10 @@ private: public: short_read_test() - : work_(io_context_.get_executor()) + : work_(ioContext_.get_executor()) , thread_(std::thread([this]() { beast::setCurrentThreadName("io_context"); - this->io_context_.run(); + this->ioContext_.run(); })) , context_(makeSslContext("")) { diff --git a/src/test/overlay/tx_reduce_relay_test.cpp b/src/test/overlay/tx_reduce_relay_test.cpp index e053774108..a0d91d3aed 100644 --- a/src/test/overlay/tx_reduce_relay_test.cpp +++ b/src/test/overlay/tx_reduce_relay_test.cpp @@ -81,10 +81,10 @@ private: { c.loadFromString(str.str()); - BEAST_EXPECT(c.TX_REDUCE_RELAY_ENABLE == enable); - BEAST_EXPECT(c.TX_REDUCE_RELAY_METRICS == metrics); - BEAST_EXPECT(c.TX_REDUCE_RELAY_MIN_PEERS == min); - BEAST_EXPECT(c.TX_RELAY_PERCENTAGE == pct); + BEAST_EXPECT(c.txReduceRelayEnable == enable); + BEAST_EXPECT(c.txReduceRelayMetrics == metrics); + BEAST_EXPECT(c.txReduceRelayMinPeers == min); + BEAST_EXPECT(c.txRelayPercentage == pct); if (success) { pass(); @@ -173,7 +173,7 @@ private: std::uint16_t rid_{1}; shared_context context_; ProtocolVersion protocolVersion_; - boost::beast::multi_buffer read_buf_; + boost::beast::multi_buffer readBuf_; public: tx_reduce_relay_test() : context_(makeSslContext("")), protocolVersion_{1, 7} @@ -232,9 +232,9 @@ private: testcase(test); jtx::Env env(*this); std::vector> peers; - env.app().config().TX_REDUCE_RELAY_ENABLE = txRREnabled; - env.app().config().TX_REDUCE_RELAY_MIN_PEERS = minPeers; - env.app().config().TX_RELAY_PERCENTAGE = relayPercentage; + env.app().config().txReduceRelayEnable = txRREnabled; + env.app().config().txReduceRelayMinPeers = minPeers; + env.app().config().txRelayPercentage = relayPercentage; PeerTest::init(); lid_ = 0; rid_ = 0; diff --git a/src/test/peerfinder/Livecache_test.cpp b/src/test/peerfinder/Livecache_test.cpp index 28d5beef88..9dae410b5b 100644 --- a/src/test/peerfinder/Livecache_test.cpp +++ b/src/test/peerfinder/Livecache_test.cpp @@ -116,7 +116,7 @@ public: BEAST_EXPECT(c.size() == 1); // verify that advancing to 1 sec before expiration // leaves our entry intact - clock_.advance(Tuning::kLIVE_CACHE_SECONDS_TO_LIVE - 1s); + clock_.advance(Tuning::kLiveCacheSecondsToLive - 1s); c.expire(); BEAST_EXPECT(c.size() == 1); // now advance to the point of expiration @@ -129,9 +129,9 @@ public: testHistogram() { testcase("Histogram"); - constexpr auto kNUM_EPS = 40; + static constexpr auto kNumEps = 40; Livecache<> c(clock_, journal_); - for (auto i = 0; i < kNUM_EPS; ++i) + for (auto i = 0; i < kNumEps; ++i) add(beast::IP::randomEP(true), c, xrpl::randInt()); auto h = c.hops.histogram(); if (!BEAST_EXPECT(!h.empty())) @@ -145,7 +145,7 @@ public: sum += val; BEAST_EXPECT(val >= 0); } - BEAST_EXPECT(sum == kNUM_EPS); + BEAST_EXPECT(sum == kNumEps); } void @@ -154,10 +154,10 @@ public: testcase("Shuffle"); Livecache<> c(clock_, journal_); for (auto i = 0; i < 100; ++i) - add(beast::IP::randomEP(true), c, xrpl::randInt(Tuning::kMAX_HOPS + 1)); + add(beast::IP::randomEP(true), c, xrpl::randInt(Tuning::kMaxHops + 1)); using at_hop = std::vector; - using all_hops = std::array; + using all_hops = std::array; auto cmpEp = [](Endpoint const& a, Endpoint const& b) { return (b.hops < a.hops || (b.hops == a.hops && b.address < a.address)); diff --git a/src/test/peerfinder/PeerFinder_test.cpp b/src/test/peerfinder/PeerFinder_test.cpp index 17ce6835ef..c4f129c1a3 100644 --- a/src/test/peerfinder/PeerFinder_test.cpp +++ b/src/test/peerfinder/PeerFinder_test.cpp @@ -421,10 +421,10 @@ public: c.loadFromString(toLoad); BEAST_EXPECT( - (c.PEERS_MAX == max && c.PEERS_IN_MAX == 0 && c.PEERS_OUT_MAX == 0) || - (c.PEERS_IN_MAX == *maxIn && c.PEERS_OUT_MAX == *maxOut)); + (c.peersMax == max && c.peersInMax == 0 && c.peersOutMax == 0) || + (c.peersInMax == *maxIn && c.peersOutMax == *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/ApiVersion_test.cpp b/src/test/protocol/ApiVersion_test.cpp index 588de6ee80..c41fa6f6c0 100644 --- a/src/test/protocol/ApiVersion_test.cpp +++ b/src/test/protocol/ApiVersion_test.cpp @@ -10,11 +10,10 @@ struct ApiVersion_test : beast::unit_test::Suite { testcase("API versions invariants"); - static_assert( - RPC::kAPI_MINIMUM_SUPPORTED_VERSION <= RPC::kAPI_MAXIMUM_SUPPORTED_VERSION); - static_assert(RPC::kAPI_MINIMUM_SUPPORTED_VERSION <= RPC::kAPI_MAXIMUM_VALID_VERSION); - static_assert(RPC::kAPI_MAXIMUM_SUPPORTED_VERSION <= RPC::kAPI_MAXIMUM_VALID_VERSION); - static_assert(RPC::kAPI_BETA_VERSION <= RPC::kAPI_MAXIMUM_VALID_VERSION); + static_assert(RPC::kApiMinimumSupportedVersion <= RPC::kApiMaximumSupportedVersion); + static_assert(RPC::kApiMinimumSupportedVersion <= RPC::kApiMaximumValidVersion); + static_assert(RPC::kApiMaximumSupportedVersion <= RPC::kApiMaximumValidVersion); + static_assert(RPC::kApiBetaVersion <= RPC::kApiMaximumValidVersion); BEAST_EXPECT(true); } @@ -23,14 +22,14 @@ struct ApiVersion_test : beast::unit_test::Suite // Update when we change versions testcase("API versions"); - static_assert(RPC::kAPI_MINIMUM_SUPPORTED_VERSION >= 1); - static_assert(RPC::kAPI_MINIMUM_SUPPORTED_VERSION < 2); - static_assert(RPC::kAPI_MAXIMUM_SUPPORTED_VERSION >= 2); - static_assert(RPC::kAPI_MAXIMUM_SUPPORTED_VERSION < 3); - static_assert(RPC::kAPI_MAXIMUM_VALID_VERSION >= 3); - static_assert(RPC::kAPI_MAXIMUM_VALID_VERSION < 4); - static_assert(RPC::kAPI_BETA_VERSION >= 3); - static_assert(RPC::kAPI_BETA_VERSION < 4); + static_assert(RPC::kApiMinimumSupportedVersion >= 1); + static_assert(RPC::kApiMinimumSupportedVersion < 2); + static_assert(RPC::kApiMaximumSupportedVersion >= 2); + static_assert(RPC::kApiMaximumSupportedVersion < 3); + static_assert(RPC::kApiMaximumValidVersion >= 3); + static_assert(RPC::kApiMaximumValidVersion < 4); + static_assert(RPC::kApiBetaVersion >= 3); + static_assert(RPC::kApiBetaVersion < 4); BEAST_EXPECT(true); } diff --git a/src/test/protocol/Hooks_test.cpp b/src/test/protocol/Hooks_test.cpp index e948c76365..082507aca7 100644 --- a/src/test/protocol/Hooks_test.cpp +++ b/src/test/protocol/Hooks_test.cpp @@ -73,7 +73,7 @@ class Hooks_test : public beast::unit_test::Suite { SField const& f = rf.get(); - STObject dummy{kSF_GENERIC}; + STObject dummy{sfGeneric}; BEAST_EXPECT(!dummy.isFieldPresent(f)); @@ -161,8 +161,8 @@ class Hooks_test : public beast::unit_test::Suite case STI_ARRAY: { STArray dummy2{f, 2}; - dummy2.pushBack(STObject{kSF_GENERIC}); - dummy2.pushBack(STObject{kSF_GENERIC}); + dummy2.pushBack(STObject{sfGeneric}); + dummy2.pushBack(STObject{sfGeneric}); dummy.setFieldArray(f, dummy2); BEAST_EXPECT(dummy.getFieldArray(f) == dummy2); BEAST_EXPECT(dummy.isFieldPresent(f)); diff --git a/src/test/protocol/InnerObjectFormats_test.cpp b/src/test/protocol/InnerObjectFormats_test.cpp index efef209c6b..5154153ecf 100644 --- a/src/test/protocol/InnerObjectFormats_test.cpp +++ b/src/test/protocol/InnerObjectFormats_test.cpp @@ -21,7 +21,7 @@ struct TestJSONTxt bool const expectFail; }; -static TestJSONTxt const kTEST_ARRAY[] = { +static TestJSONTxt const kTestArray[] = { // Valid SignerEntry {.txt = R"({ @@ -162,7 +162,7 @@ public: // Instantiate a jtx::Env so debugLog writes are exercised. test::jtx::Env const env(*this); - for (auto const& test : kTEST_ARRAY) + for (auto const& test : kTestArray) { json::Value req; json::Reader().parse(test.txt, req); diff --git a/src/test/protocol/MultiApiJson_test.cpp b/src/test/protocol/MultiApiJson_test.cpp index e66403e0ae..c6f844a206 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; } @@ -47,7 +47,7 @@ struct MultiApiJson_test : beast::unit_test::Suite MultiApiJson<1, 3> subject{}; static_assert(sizeof(subject) == sizeof(subject.val)); - static_assert(subject.kSIZE == subject.val.size()); + static_assert(subject.kSize == subject.val.size()); static_assert(std::is_same_v>); BEAST_EXPECT(subject.val.size() == 3); @@ -60,42 +60,37 @@ struct MultiApiJson_test : beast::unit_test::Suite testcase("forApiVersions, forAllApiVersions"); // Some static data for test inputs - static int const kPRIMES[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, + static int const kPrimes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97}; - static_assert(std::size(kPRIMES) > RPC::kAPI_MAXIMUM_VALID_VERSION); + static_assert(std::size(kPrimes) > RPC::kApiMaximumValidVersion); MultiApiJson<1, 3> s1{}; static_assert( - s1.kSIZE == - RPC::kAPI_MAXIMUM_VALID_VERSION + 1 - RPC::kAPI_MINIMUM_SUPPORTED_VERSION); + s1.kSize == RPC::kApiMaximumValidVersion + 1 - RPC::kApiMinimumSupportedVersion); int productAllVersions = 1; - for (unsigned i = RPC::kAPI_MINIMUM_SUPPORTED_VERSION; - i <= RPC::kAPI_MAXIMUM_VALID_VERSION; + for (unsigned i = RPC::kApiMinimumSupportedVersion; i <= RPC::kApiMaximumValidVersion; ++i) { - auto const index = i - RPC::kAPI_MINIMUM_SUPPORTED_VERSION; + auto const index = i - RPC::kApiMinimumSupportedVersion; BEAST_EXPECT(index == s1.index(i)); BEAST_EXPECT(s1.valid(i)); - s1.val[index] = makeJson("value", kPRIMES[i]); - productAllVersions *= kPRIMES[i]; + s1.val[index] = makeJson("value", kPrimes[i]); + productAllVersions *= kPrimes[i]; } BEAST_EXPECT(!s1.valid(0)); - BEAST_EXPECT(!s1.valid(RPC::kAPI_MAXIMUM_VALID_VERSION + 1)); + BEAST_EXPECT(!s1.valid(RPC::kApiMaximumValidVersion + 1)); BEAST_EXPECT(!s1.valid( - std::numeric_limits::max())); + std::numeric_limits::max())); int result = 1; - static_assert( - RPC::kAPI_MINIMUM_SUPPORTED_VERSION + 1 <= RPC::kAPI_MAXIMUM_VALID_VERSION); - forApiVersions< - RPC::kAPI_MINIMUM_SUPPORTED_VERSION, - RPC::kAPI_MINIMUM_SUPPORTED_VERSION + 1>( + static_assert(RPC::kApiMinimumSupportedVersion + 1 <= RPC::kApiMaximumValidVersion); + forApiVersions( std::as_const(s1).visit(), [this](json::Value const& json, unsigned int version, int* result) { BEAST_EXPECT( - version >= RPC::kAPI_MINIMUM_SUPPORTED_VERSION && - version <= RPC::kAPI_MINIMUM_SUPPORTED_VERSION + 1); + version >= RPC::kApiMinimumSupportedVersion && + version <= RPC::kApiMinimumSupportedVersion + 1); if (BEAST_EXPECT(json.isMember("value"))) { *result *= json["value"].asInt(); @@ -104,15 +99,15 @@ struct MultiApiJson_test : beast::unit_test::Suite &result); BEAST_EXPECT( result == - kPRIMES[RPC::kAPI_MINIMUM_SUPPORTED_VERSION] * - kPRIMES[RPC::kAPI_MINIMUM_SUPPORTED_VERSION + 1]); + kPrimes[RPC::kApiMinimumSupportedVersion] * + kPrimes[RPC::kApiMinimumSupportedVersion + 1]); // Check all the values with mutable data forAllApiVersions(s1.visit(), [&s1, this](json::Value& json, auto version) { BEAST_EXPECT(s1.val[s1.index(version)] == json); if (BEAST_EXPECT(json.isMember("value"))) { - BEAST_EXPECT(json["value"].asInt() == kPRIMES[version]); + BEAST_EXPECT(json["value"].asInt() == kPrimes[version]); } }); @@ -121,8 +116,8 @@ struct MultiApiJson_test : beast::unit_test::Suite std::as_const(s1).visit(), [this](json::Value const& json, unsigned int version, int* result) { BEAST_EXPECT( - version >= RPC::kAPI_MINIMUM_SUPPORTED_VERSION && - version <= RPC::kAPI_MAXIMUM_VALID_VERSION); + version >= RPC::kApiMinimumSupportedVersion && + version <= RPC::kApiMaximumValidVersion); if (BEAST_EXPECT(json.isMember("value"))) { *result *= json["value"].asInt(); @@ -278,7 +273,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 +291,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)); @@ -362,14 +358,14 @@ struct MultiApiJson_test : beast::unit_test::Suite // Test different overloads static_assert([](auto&& v) { return requires { - v.kVISITOR( + v.kVisitor( v, std::integral_constant{}, [](json::Value&, std::integral_constant) {}); }; }(s1)); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, std::integral_constant{}, Overload{ @@ -381,11 +377,11 @@ struct MultiApiJson_test : beast::unit_test::Suite static_assert([](auto&& v) { return requires { - v.kVISITOR(v, std::integral_constant{}, [](json::Value&) {}); + v.kVisitor(v, std::integral_constant{}, [](json::Value&) {}); }; }(s1)); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, std::integral_constant{}, Overload{ @@ -395,14 +391,14 @@ struct MultiApiJson_test : beast::unit_test::Suite static_assert([](auto&& v) { return requires { - v.kVISITOR( + v.kVisitor( v, std::integral_constant{}, [](json::Value const&, std::integral_constant) {}); }; }(std::as_const(s1))); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( std::as_const(s1), std::integral_constant{}, Overload{ @@ -414,11 +410,11 @@ struct MultiApiJson_test : beast::unit_test::Suite static_assert([](auto&& v) { return requires { - v.kVISITOR(v, std::integral_constant{}, [](json::Value const&) {}); + v.kVisitor(v, std::integral_constant{}, [](json::Value const&) {}); }; }(std::as_const(s1))); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( std::as_const(s1), std::integral_constant{}, Overload{ @@ -427,10 +423,10 @@ struct MultiApiJson_test : beast::unit_test::Suite [](auto...) { return 0; }}) == 3); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](json::Value&, unsigned) {}); }; + return requires { v.kVisitor(v, 1, [](json::Value&, unsigned) {}); }; }(s1)); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // 3u, Overload{ @@ -439,9 +435,9 @@ struct MultiApiJson_test : beast::unit_test::Suite [](auto, auto) { return 0; }}) == 5); static_assert( - [](auto&& v) { return requires { v.kVISITOR(v, 1, [](json::Value&) {}); }; }(s1)); + [](auto&& v) { return requires { v.kVisitor(v, 1, [](json::Value&) {}); }; }(s1)); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // 3, Overload{ @@ -450,10 +446,10 @@ struct MultiApiJson_test : beast::unit_test::Suite [](auto...) { return 0; }}) == 5); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](json::Value const&, unsigned) {}); }; + return requires { v.kVisitor(v, 1, [](json::Value const&, unsigned) {}); }; }(std::as_const(s1))); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( std::as_const(s1), // 2u, Overload{ @@ -462,10 +458,10 @@ struct MultiApiJson_test : beast::unit_test::Suite [](auto, auto) { return 0; }}) == 3); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](json::Value const&) {}); }; + return requires { v.kVisitor(v, 1, [](json::Value const&) {}); }; }(std::as_const(s1))); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( std::as_const(s1), // 2, Overload{ @@ -475,64 +471,64 @@ struct MultiApiJson_test : beast::unit_test::Suite // Test type conversions BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, std::integral_constant{}, // to unsigned [](json::Value& v, unsigned) { return v["value"].asInt(); }) == 2); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( std::as_const(s1), std::integral_constant{}, // to unsigned [](json::Value const& v, unsigned) { return v["value"].asInt(); }) == 3); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // to const std::integral_constant{}, [](json::Value const& v, auto) { return v["value"].asInt(); }) == 5); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // to const std::integral_constant{}, [](json::Value const& v) { return v["value"].asInt(); }) == 5); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, 3, // to long [](json::Value& v, long) { return v["value"].asInt(); }) == 5); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( std::as_const(s1), 1, // to long [](json::Value const& v, long) { return v["value"].asInt(); }) == 2); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // to const 2, [](json::Value const& v, auto) { return v["value"].asInt(); }) == 3); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // type deduction 2, [](auto& v, auto) { return v["value"].asInt(); }) == 3); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // to const, type deduction 2, [](auto const& v, auto) { return v["value"].asInt(); }) == 3); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // type deduction 2, [](auto& v) { return v["value"].asInt(); }) == 3); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, // to const, type deduction 2, [](auto const& v) { return v["value"].asInt(); }) == 3); // Test passing of additional arguments BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, std::integral_constant{}, [](json::Value& v, auto ver, auto a1, auto a2) { @@ -541,7 +537,7 @@ struct MultiApiJson_test : beast::unit_test::Suite 5, 7) == 2 * 5 * 7 * 3); BEAST_EXPECT( - s1.kVISITOR( + s1.kVisitor( s1, std::integral_constant{}, [](json::Value& v, auto ver, auto... args) { @@ -553,7 +549,7 @@ struct MultiApiJson_test : beast::unit_test::Suite // Several overloads we want to fail static_assert([](auto&& v) { return !requires { - v.kVISITOR( + v.kVisitor( v, 1, // [](json::Value&, auto) {}); // missing const @@ -562,7 +558,7 @@ struct MultiApiJson_test : beast::unit_test::Suite static_assert([](auto&& v) { return !requires { - v.kVISITOR( + v.kVisitor( decltype(v){}, // cannot bind rvalue 1, [](json::Value&, auto) {}); @@ -571,7 +567,7 @@ struct MultiApiJson_test : beast::unit_test::Suite static_assert([](auto&& v) { return !requires { - v.kVISITOR( + v.kVisitor( v, 1, // []() {}); // missing parameter @@ -580,7 +576,7 @@ struct MultiApiJson_test : beast::unit_test::Suite static_assert([](auto&& v) { return !requires { - v.kVISITOR( + v.kVisitor( v, 1, // [](json::Value&, int, int) {}); // too many parameters @@ -588,39 +584,39 @@ struct MultiApiJson_test : beast::unit_test::Suite }(s1)); // Want these to be unambiguous - static_assert([](auto&& v) { return requires { v.kVISITOR(v, 1, [](auto) {}); }; }(s1)); + static_assert([](auto&& v) { return requires { v.kVisitor(v, 1, [](auto) {}); }; }(s1)); static_assert( - [](auto&& v) { return requires { v.kVISITOR(v, 1, [](json::Value&) {}); }; }(s1)); + [](auto&& v) { return requires { v.kVisitor(v, 1, [](json::Value&) {}); }; }(s1)); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](json::Value&, auto...) {}); }; + return requires { v.kVisitor(v, 1, [](json::Value&, auto...) {}); }; }(s1)); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](json::Value const&) {}); }; + return requires { v.kVisitor(v, 1, [](json::Value const&) {}); }; }(s1)); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](json::Value const&, auto...) {}); }; + return requires { v.kVisitor(v, 1, [](json::Value const&, auto...) {}); }; }(s1)); static_assert( - [](auto&& v) { return requires { v.kVISITOR(v, 1, [](auto...) {}); }; }(s1)); + [](auto&& v) { return requires { v.kVisitor(v, 1, [](auto...) {}); }; }(s1)); static_assert( - [](auto&& v) { return requires { v.kVISITOR(v, 1, [](auto, auto...) {}); }; }(s1)); + [](auto&& v) { return requires { v.kVisitor(v, 1, [](auto, auto...) {}); }; }(s1)); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](auto, auto, auto...) {}); }; + return requires { v.kVisitor(v, 1, [](auto, auto, auto...) {}); }; }(s1)); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](auto, auto, auto...) {}, ""); }; + return requires { v.kVisitor(v, 1, [](auto, auto, auto...) {}, ""); }; }(s1)); static_assert([](auto&& v) { - return requires { v.kVISITOR(v, 1, [](auto, auto, auto, auto...) {}, ""); }; + return requires { v.kVisitor(v, 1, [](auto, auto, auto, auto...) {}, ""); }; }(s1)); } diff --git a/src/test/protocol/PublicKey_test.cpp b/src/test/protocol/PublicKey_test.cpp index 874eda8c65..1494e57a5e 100644 --- a/src/test/protocol/PublicKey_test.cpp +++ b/src/test/protocol/PublicKey_test.cpp @@ -46,12 +46,12 @@ public: } }; - static Table kLUT; + static Table kLut; out.reserve(std::distance(first, last) / 2); while (first != last) { - auto const hi(kLUT[(*first++)]); - auto const lo(kLUT[(*first++)]); + auto const hi(kLut[(*first++)]); + auto const lo(kLut[(*first++)]); out.push_back((hi * 16) + lo); } } diff --git a/src/test/protocol/Quality_test.cpp b/src/test/protocol/Quality_test.cpp index fe049f11f2..df95cea8ef 100644 --- a/src/test/protocol/Quality_test.cpp +++ b/src/test/protocol/Quality_test.cpp @@ -263,7 +263,7 @@ public: raw(2755280000000000ull, -15)); // 2.75528 STAmount const limit(raw(4131113916555555, -16)); // .4131113916555555 Amounts const result(q.ceilOut(value, limit)); - BEAST_EXPECT(result.in != beast::kZERO); + BEAST_EXPECT(result.in != beast::kZero); } } diff --git a/src/test/protocol/STAmount_test.cpp b/src/test/protocol/STAmount_test.cpp index 7c37d3e9bc..c7207589ff 100644 --- a/src/test/protocol/STAmount_test.cpp +++ b/src/test/protocol/STAmount_test.cpp @@ -37,7 +37,7 @@ public: s.add(ser); SerialIter sit(ser.slice()); - return STAmount(sit, kSF_GENERIC); + return STAmount(sit, sfGeneric); } //-------------------------------------------------------------------------- @@ -54,7 +54,7 @@ public: { mantissa--; - if (mantissa < STAmount::kMIN_VALUE) + if (mantissa < STAmount::kMinValue) return {amount.asset(), mantissa, amount.exponent(), amount.negative()}; return { @@ -69,7 +69,7 @@ public: { mantissa++; - if (mantissa > STAmount::kMAX_VALUE) + if (mantissa > STAmount::kMaxValue) return {amount.asset(), mantissa, amount.exponent(), amount.negative()}; return { @@ -228,9 +228,9 @@ public: unexpected(serializeAndDeserialize(hundred) != hundred, "STAmount fail"); unexpected(!zeroSt.native(), "STAmount fail"); unexpected(!hundred.native(), "STAmount fail"); - unexpected(zeroSt != beast::kZERO, "STAmount fail"); - unexpected(one == beast::kZERO, "STAmount fail"); - unexpected(hundred == beast::kZERO, "STAmount fail"); + unexpected(zeroSt != beast::kZero, "STAmount fail"); + unexpected(one == beast::kZero, "STAmount fail"); + unexpected(hundred == beast::kZero, "STAmount fail"); unexpected((zeroSt < zeroSt), "STAmount fail"); // NOLINT(misc-redundant-expression) unexpected(!(zeroSt < one), "STAmount fail"); unexpected(!(zeroSt < hundred), "STAmount fail"); @@ -314,9 +314,9 @@ public: unexpected(serializeAndDeserialize(hundred) != hundred, "STAmount fail"); unexpected(zeroSt.native(), "STAmount fail"); unexpected(hundred.native(), "STAmount fail"); - unexpected(zeroSt != beast::kZERO, "STAmount fail"); - unexpected(one == beast::kZERO, "STAmount fail"); - unexpected(hundred == beast::kZERO, "STAmount fail"); + unexpected(zeroSt != beast::kZero, "STAmount fail"); + unexpected(one == beast::kZero, "STAmount fail"); + unexpected(hundred == beast::kZero, "STAmount fail"); unexpected((zeroSt < zeroSt), "STAmount fail"); // NOLINT(misc-redundant-expression) unexpected(!(zeroSt < one), "STAmount fail"); unexpected(!(zeroSt < hundred), "STAmount fail"); @@ -494,34 +494,30 @@ public: { testcase("underflow"); - STAmount const bigNative(STAmount::kMAX_NATIVE / 2); + STAmount const bigNative(STAmount::kMaxNative / 2); STAmount const bigValue( - noIssue(), - (STAmount::kMIN_VALUE + STAmount::kMAX_VALUE) / 2, - STAmount::kMAX_OFFSET - 1); + noIssue(), (STAmount::kMinValue + STAmount::kMaxValue) / 2, STAmount::kMaxOffset - 1); STAmount const smallValue( - noIssue(), - (STAmount::kMIN_VALUE + STAmount::kMAX_VALUE) / 2, - STAmount::kMIN_OFFSET + 1); + noIssue(), (STAmount::kMinValue + STAmount::kMaxValue) / 2, STAmount::kMinOffset + 1); STAmount const zeroSt(noIssue(), 0); STAmount const smallXSmall = multiply(smallValue, smallValue, noIssue()); - BEAST_EXPECT(smallXSmall == beast::kZERO); + BEAST_EXPECT(smallXSmall == beast::kZero); STAmount bigDsmall = divide(smallValue, bigValue, noIssue()); - BEAST_EXPECT(bigDsmall == beast::kZERO); + BEAST_EXPECT(bigDsmall == beast::kZero); - BEAST_EXPECT(bigDsmall == beast::kZERO); + BEAST_EXPECT(bigDsmall == beast::kZero); bigDsmall = divide(smallValue, bigValue, xrpIssue()); - BEAST_EXPECT(bigDsmall == beast::kZERO); + BEAST_EXPECT(bigDsmall == beast::kZero); bigDsmall = divide(smallValue, bigNative, xrpIssue()); - BEAST_EXPECT(bigDsmall == beast::kZERO); + BEAST_EXPECT(bigDsmall == beast::kZero); // very bad offer std::uint64_t r = getRate(smallValue, bigValue); @@ -618,17 +614,17 @@ public: BEAST_EXPECT(amountFromJson(sfNumber, "0") == XRPAmount(0)); BEAST_EXPECT(amountFromJson(sfNumber, "-0") == XRPAmount(0)); - constexpr auto kIMIN = std::numeric_limits::min(); - BEAST_EXPECT(amountFromJson(sfNumber, kIMIN) == XRPAmount(kIMIN)); - BEAST_EXPECT(amountFromJson(sfNumber, std::to_string(kIMIN)) == XRPAmount(kIMIN)); + constexpr auto kIMin = std::numeric_limits::min(); + BEAST_EXPECT(amountFromJson(sfNumber, kIMin) == XRPAmount(kIMin)); + BEAST_EXPECT(amountFromJson(sfNumber, std::to_string(kIMin)) == XRPAmount(kIMin)); - constexpr auto kIMAX = std::numeric_limits::max(); - BEAST_EXPECT(amountFromJson(sfNumber, kIMAX) == XRPAmount(kIMAX)); - BEAST_EXPECT(amountFromJson(sfNumber, std::to_string(kIMAX)) == XRPAmount(kIMAX)); + constexpr auto kIMax = std::numeric_limits::max(); + BEAST_EXPECT(amountFromJson(sfNumber, kIMax) == XRPAmount(kIMax)); + BEAST_EXPECT(amountFromJson(sfNumber, std::to_string(kIMax)) == XRPAmount(kIMax)); - constexpr auto kUMAX = std::numeric_limits::max(); - BEAST_EXPECT(amountFromJson(sfNumber, kUMAX) == XRPAmount(kUMAX)); - BEAST_EXPECT(amountFromJson(sfNumber, std::to_string(kUMAX)) == XRPAmount(kUMAX)); + constexpr auto kUMax = std::numeric_limits::max(); + BEAST_EXPECT(amountFromJson(sfNumber, kUMax) == XRPAmount(kUMax)); + BEAST_EXPECT(amountFromJson(sfNumber, std::to_string(kUMax)) == XRPAmount(kUMax)); // XRP does not handle fractional part try @@ -1209,6 +1205,100 @@ public: //-------------------------------------------------------------------------- + void + testIsZeroAtScale() + { + testcase("isZeroAtScale"); + + Issue const usd{Currency(0x5553440000000000), AccountID(0x4985601)}; + + // IOU: 10 IOU — mantissa = kMinValue (10^15), exponent = -14. + // One ULP at this scale is 10^-14; half-ULP is 5*10^-15. + { + STAmount const ref{usd, STAmount::kMinValue, -14}; + int const refScale = ref.exponent(); // -14 + BEAST_EXPECT(refScale == -14); + + // Zero rounds to zero at any scale. + STAmount const iouZero{usd, 0}; + BEAST_EXPECT(iouZero.isZeroAtScale(refScale)); + + // Sub-ULP: 1e-16 IOU (mantissa = kMinValue, exponent = -31). + // Far below half-ULP → rounds to zero. + STAmount const subUlp{usd, STAmount::kMinValue, -31}; + BEAST_EXPECT(subUlp.isZeroAtScale(refScale)); + + // One ULP: 1e-14 IOU (mantissa = kMinValue, exponent = -29). + // Exactly the smallest representable unit at refScale → not zero. + STAmount const oneUlp{usd, STAmount::kMinValue, -29}; + BEAST_EXPECT(!oneUlp.isZeroAtScale(refScale)); + + // The reference value itself: exponent == scale → returned + // unchanged → not zero. + BEAST_EXPECT(!ref.isZeroAtScale(refScale)); + + // A much larger value: certainly not zero at this scale. + STAmount const large{usd, STAmount::kMinValue, 0}; // 1e15 IOU + BEAST_EXPECT(!large.isZeroAtScale(refScale)); + + // When scale equals the value's own exponent, roundToScale + // short-circuits and returns the value unchanged. + BEAST_EXPECT(!subUlp.isZeroAtScale(subUlp.exponent())); + BEAST_EXPECT(!oneUlp.isZeroAtScale(oneUlp.exponent())); + + // Half-ULP boundary. roundToScale forms (value + ref) - ref + // where ref = 10 IOU has mantissa 1e15 (LSB 0, even). + // Number's default rounding is to-nearest-even, so an exact + // half-ULP tie rounds toward the even-LSB neighbour — the + // reference itself — and the round-trip result is zero. + // Just below half-ULP rounds the same way; just above + // clears half-ULP and bumps the mantissa to 1e15 + 1. + STAmount const justBelowHalf{usd, STAmount::kMinValue * 4, -30}; + BEAST_EXPECT(justBelowHalf.isZeroAtScale(refScale)); + + STAmount const halfUlp{usd, STAmount::kMinValue * 5, -30}; + BEAST_EXPECT(halfUlp.isZeroAtScale(refScale)); + + STAmount const justAboveHalf{usd, STAmount::kMinValue * 6, -30}; + BEAST_EXPECT(!justAboveHalf.isZeroAtScale(refScale)); + + // Large magnitude gap: dust value far below an enormous scale. + // 1e-80 with scale +15 — the value vanishes utterly. + STAmount const dust{usd, STAmount::kMinValue, -95}; + BEAST_EXPECT(dust.isZeroAtScale(15)); + + // Negative values mirror positive behaviour. + STAmount const negSubUlp{usd, STAmount::kMinValue, -31, true}; + BEAST_EXPECT(negSubUlp.isZeroAtScale(refScale)); + + STAmount const negOneUlp{usd, STAmount::kMinValue, -29, true}; + BEAST_EXPECT(!negOneUlp.isZeroAtScale(refScale)); + } + + // XRP is integral — roundToScale short-circuits, value is preserved. + { + STAmount const xrp{XRPAmount{1}}; + BEAST_EXPECT(!xrp.isZeroAtScale(-14)); + BEAST_EXPECT(!xrp.isZeroAtScale(0)); + + STAmount const xrpZero{XRPAmount{0}}; + BEAST_EXPECT(xrpZero.isZeroAtScale(-14)); + } + + // MPT is integral — same short-circuit behaviour as XRP. + { + MPTIssue const mpt{makeMptID(1, AccountID(0x4985601))}; + STAmount const mptAmt{mpt, 1}; + BEAST_EXPECT(!mptAmt.isZeroAtScale(0)); + BEAST_EXPECT(!mptAmt.isZeroAtScale(-14)); + + STAmount const mptZero{mpt, 0}; + BEAST_EXPECT(mptZero.isZeroAtScale(0)); + } + } + + //-------------------------------------------------------------------------- + void run() override { @@ -1227,6 +1317,7 @@ public: testCanSubtractXRP(); testCanSubtractIOU(); testCanSubtractMPT(); + testIsZeroAtScale(); } }; 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/STNumber_test.cpp b/src/test/protocol/STNumber_test.cpp index 914e2d003f..4d95bc1ef7 100644 --- a/src/test/protocol/STNumber_test.cpp +++ b/src/test/protocol/STNumber_test.cpp @@ -55,7 +55,7 @@ struct STNumber_test : public beast::unit_test::Suite testCombo(Number{mantissa}); std::initializer_list const exponents = { - Number::kMIN_EXPONENT, -1, 0, 1, Number::kMAX_EXPONENT - 1}; + Number::kMinExponent, -1, 0, 1, Number::kMaxExponent - 1}; for (std::int32_t const exponent : exponents) testCombo(Number{123, exponent}); @@ -128,23 +128,23 @@ struct STNumber_test : public beast::unit_test::Suite } } - constexpr auto kIMIN = std::numeric_limits::min(); - BEAST_EXPECT(numberFromJson(sfNumber, kIMIN) == STNumber(sfNumber, Number(kIMIN, 0))); + constexpr auto kIMin = std::numeric_limits::min(); + BEAST_EXPECT(numberFromJson(sfNumber, kIMin) == STNumber(sfNumber, Number(kIMin, 0))); BEAST_EXPECT( - numberFromJson(sfNumber, std::to_string(kIMIN)) == - STNumber(sfNumber, Number(kIMIN, 0))); + numberFromJson(sfNumber, std::to_string(kIMin)) == + STNumber(sfNumber, Number(kIMin, 0))); - constexpr auto kIMAX = std::numeric_limits::max(); - BEAST_EXPECT(numberFromJson(sfNumber, kIMAX) == STNumber(sfNumber, Number(kIMAX, 0))); + constexpr auto kIMax = std::numeric_limits::max(); + BEAST_EXPECT(numberFromJson(sfNumber, kIMax) == STNumber(sfNumber, Number(kIMax, 0))); BEAST_EXPECT( - numberFromJson(sfNumber, std::to_string(kIMAX)) == - STNumber(sfNumber, Number(kIMAX, 0))); + numberFromJson(sfNumber, std::to_string(kIMax)) == + STNumber(sfNumber, Number(kIMax, 0))); - constexpr auto kUMAX = std::numeric_limits::max(); - BEAST_EXPECT(numberFromJson(sfNumber, kUMAX) == STNumber(sfNumber, Number(kUMAX, 0))); + constexpr auto kUMax = std::numeric_limits::max(); + BEAST_EXPECT(numberFromJson(sfNumber, kUMax) == STNumber(sfNumber, Number(kUMax, 0))); BEAST_EXPECT( - numberFromJson(sfNumber, std::to_string(kUMAX)) == - STNumber(sfNumber, Number(kUMAX, 0))); + numberFromJson(sfNumber, std::to_string(kUMax)) == + STNumber(sfNumber, Number(kUMax, 0))); // Obvious non-numbers tested here try diff --git a/src/test/protocol/STObject_test.cpp b/src/test/protocol/STObject_test.cpp index a408f2503b..801eebbe63 100644 --- a/src/test/protocol/STObject_test.cpp +++ b/src/test/protocol/STObject_test.cpp @@ -36,19 +36,19 @@ public: { testcase("serialization"); - unexpected(kSF_GENERIC.isUseful(), "sfGeneric must not be useful"); + unexpected(sfGeneric.isUseful(), "sfGeneric must not be useful"); { // Try to put sfGeneric in an SOTemplate. except( - [&]() { SOTemplate const elements{{kSF_GENERIC, SoeRequired}}; }); + [&]() { SOTemplate const elements{{sfGeneric, SoeRequired}}; }); } - unexpected(kSF_INVALID.isUseful(), "sfInvalid must not be useful"); + unexpected(sfInvalid.isUseful(), "sfInvalid must not be useful"); { // Test return of sfInvalid. auto testInvalid = [this](SerializedTypeID tid, int fv) { SField const& shouldBeInvalid{SField::getField(tid, fv)}; - BEAST_EXPECT(shouldBeInvalid == kSF_INVALID); + BEAST_EXPECT(shouldBeInvalid == sfInvalid); }; testInvalid(STI_VL, 255); testInvalid(STI_UINT256, 255); @@ -59,7 +59,7 @@ public: { // Try to put sfInvalid in an SOTemplate. except( - [&]() { SOTemplate const elements{{kSF_INVALID, SoeRequired}}; }); + [&]() { SOTemplate const elements{{sfInvalid, SoeRequired}}; }); } { // Try to put the same SField into an SOTemplate twice. @@ -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 @@ -188,7 +188,7 @@ public: { auto const st = [&]() { - STObject s(kSF_GENERIC); + STObject s(sfGeneric); s.setFieldU32(sf1Outer, 1); s.setFieldU32(sf2Outer, 2); return s; @@ -219,7 +219,7 @@ public: { auto const st = [&]() { - STObject s(sotOuter, kSF_GENERIC); + STObject s(sotOuter, sfGeneric); s.setFieldU32(sf1Outer, 1); s.setFieldU32(sf2Outer, 2); return s; @@ -239,7 +239,7 @@ public: // write free object { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); unexcept([&]() { st[sf1Outer]; }); except([&]() { return st[sf1Outer] == 0; }); BEAST_EXPECT(st[~sf1Outer] == std::nullopt); @@ -295,7 +295,7 @@ public: // Write templated object { - STObject st(sotOuter, kSF_GENERIC); + STObject st(sotOuter, sfGeneric); BEAST_EXPECT(!!st[~sf1Outer]); BEAST_EXPECT(st[~sf1Outer] != std::nullopt); BEAST_EXPECT(st[sf1Outer] == 0); @@ -353,7 +353,7 @@ public: // coercion operator to std::optional { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); auto const v = ~st[~sf1Outer]; static_assert( std::is_same_v, std::optional>, ""); @@ -362,7 +362,7 @@ public: // UDT scalar fields { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); st[sfAmount] = STAmount{}; st[sfAccount] = AccountID{}; st[sfDigest] = uint256{}; @@ -375,7 +375,7 @@ public: { { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); Buffer b(1); BEAST_EXPECT(!b.empty()); st[sf4] = std::move(b); @@ -392,7 +392,7 @@ public: BEAST_EXPECT(Slice(st[sf5]).size() == 2); } { - STObject st(sotOuter, kSF_GENERIC); + STObject st(sotOuter, sfGeneric); BEAST_EXPECT(st[sf5] == Slice{}); BEAST_EXPECT(!!st[~sf5]); BEAST_EXPECT(!!~st[~sf5]); @@ -408,7 +408,7 @@ public: // UDT blobs { - STObject st(kSF_GENERIC); + STObject st(sfGeneric); BEAST_EXPECT(!st[~sf5]); auto const kp = generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase")); st[sf5] = kp.first; @@ -419,7 +419,7 @@ public: { auto const& sf = sfIndexes; - STObject st(kSF_GENERIC); + STObject st(sfGeneric); std::vector v; v.emplace_back(1); v.emplace_back(2); @@ -446,7 +446,7 @@ public: {sf3, SoeDefault}, }; - STObject st(sot, kSF_GENERIC); + STObject st(sot, sfGeneric); auto const& cst(st); BEAST_EXPECT(cst[sf1].empty()); BEAST_EXPECT(!cst[~sf2]); 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..21518d1406 100644 --- a/src/test/protocol/STTx_test.cpp +++ b/src/test/protocol/STTx_test.cpp @@ -66,12 +66,12 @@ public: { testcase("Malformed serialized form"); - constexpr unsigned char kPAYLOAD1[] = { + static constexpr unsigned char kPayload1[] = { 0x0a, 0xff, 0xff, 0xff, 0xff, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x29, 0x1b, 0x1b, 0x1b, 0x1b, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef}; - constexpr unsigned char kPAYLOAD2[] = { + static constexpr unsigned char kPayload2[] = { 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xef, 0xff, 0xef, 0xef, 0xff, 0xef, 0xff, 0xef, 0xef, 0xff, 0xef, 0xff, 0xef, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0xef, 0xff, 0xef, @@ -1063,7 +1063,7 @@ public: 0xef, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0x3b, 0x3b, 0x43, 0x3b, 0x3b, 0xff, 0x3b, 0x12, 0xf1, 0x12, 0x12, 0x12, 0xff}; - constexpr unsigned char kPAYLOAD3[] = { + static constexpr unsigned char kPayload3[] = { 0x12, 0x00, 0x65, 0x24, 0x00, 0x00, 0x00, 0x00, 0x20, 0x1e, 0x00, 0x4f, 0x00, 0x00, 0x20, 0x1f, 0x03, 0xf6, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -1083,7 +1083,7 @@ public: 0x02, 0x00, 0x73, 0x00, 0x81, 0x14, 0x00, 0x10, 0x00, 0x73, 0x00, 0x81, 0x14, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0xe5, 0xfe}; - constexpr unsigned char kPAYLOAD4[] = { + static constexpr unsigned char kPayload4[] = { 0x12, 0x00, 0x65, 0x24, 0x00, 0x00, 0x00, 0x00, 0x20, 0x1e, 0x00, 0x4f, 0x00, 0x00, 0x20, 0x1f, 0x03, 0xf6, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -1279,7 +1279,7 @@ public: // from earlier versions results in "Unknown field". Either way, // we expect an exception from STTx, but the specific message will // vary. - BEAST_EXPECT(!tx2.ParseFromArray(kPAYLOAD1, sizeof(kPAYLOAD1))); + BEAST_EXPECT(!tx2.ParseFromArray(kPayload1, sizeof(kPayload1))); xrpl::SerialIter sit(xrpl::makeSlice(tx2.rawtransaction())); @@ -1293,7 +1293,7 @@ public: try { - xrpl::SerialIter sit{kPAYLOAD2}; + xrpl::SerialIter sit{kPayload2}; auto stx = std::make_shared(sit); fail("An exception should have been thrown"); } @@ -1304,7 +1304,7 @@ public: try { - xrpl::SerialIter sit{kPAYLOAD3}; + xrpl::SerialIter sit{kPayload3}; auto stx = std::make_shared(sit); fail("An exception should have been thrown"); } @@ -1315,7 +1315,7 @@ public: try { - xrpl::SerialIter sit{kPAYLOAD4}; + xrpl::SerialIter sit{kPayload4}; auto stx = std::make_shared(sit); fail("An exception should have been thrown"); } @@ -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 @@ -1390,7 +1390,7 @@ public: // Lambda that returns a Payment STObject. auto getPayment = [kp1, id1, id2]() { // Account id1 pays account id2 10,000 XRP. - STObject payment(kSF_GENERIC); + STObject payment(sfGeneric); payment.setFieldU16(sfTransactionType, ttPAYMENT); payment.setAccountID(sfAccount, id1); payment.setAccountID(sfDestination, id2); diff --git a/src/test/protocol/STValidation_test.cpp b/src/test/protocol/STValidation_test.cpp index 6ad0f92b42..e42411bd3f 100644 --- a/src/test/protocol/STValidation_test.cpp +++ b/src/test/protocol/STValidation_test.cpp @@ -22,7 +22,7 @@ namespace xrpl { class STValidation_test : public beast::unit_test::Suite { // No public key: - static constexpr std::uint8_t kPAYLOAD1[] = { + static constexpr std::uint8_t kPayload1[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x3A, 0x4E, 0x69, 0x6B, 0x2B, 0x54, 0x69, 0x66, 0x66, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, @@ -36,7 +36,7 @@ class STValidation_test : public beast::unit_test::Suite 0x8E, 0x09, 0x11, 0x52, 0x28, 0x5A, 0x48, 0x8F, 0x98, 0x7A, 0x5A, 0x10, 0x74, 0xCC}; // Short public key: - static constexpr std::uint8_t kPAYLOAD2[] = { + static constexpr std::uint8_t kPayload2[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, @@ -52,7 +52,7 @@ class STValidation_test : public beast::unit_test::Suite 0xD7, 0xFF, 0x83, 0x9D, 0xEF, 0x7D, 0xF7, 0x6A}; // Long public key: - static constexpr std::uint8_t kPAYLOAD3[] = { + static constexpr std::uint8_t kPayload3[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, @@ -68,7 +68,7 @@ class STValidation_test : public beast::unit_test::Suite 0xEF, 0x4C, 0x73, 0xB3, 0xFF, 0xFE, 0xA9, 0x8E, 0x92, 0xE8}; // Ed25519 public key: - static constexpr std::uint8_t kPAYLOAD4[] = { + static constexpr std::uint8_t kPayload4[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, @@ -84,7 +84,7 @@ class STValidation_test : public beast::unit_test::Suite 0x7E, 0x84, 0x09}; // No ledger sequence: - static constexpr std::uint8_t kPAYLOAD5[] = { + static constexpr std::uint8_t kPayload5[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97, 0x50, 0x17, @@ -100,7 +100,7 @@ class STValidation_test : public beast::unit_test::Suite 0xEA, 0x5F, 0xD9, 0xC7, 0xAA}; // No sign time: - static constexpr std::uint8_t kPAYLOAD6[] = { + static constexpr std::uint8_t kPayload6[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97, 0x50, 0x17, @@ -116,7 +116,7 @@ class STValidation_test : public beast::unit_test::Suite 0x23, 0xE2, 0x14, 0x80, 0x54}; // No signature field: - static constexpr std::uint8_t kPAYLOAD7[] = { + static constexpr std::uint8_t kPayload7[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, @@ -127,7 +127,7 @@ class STValidation_test : public beast::unit_test::Suite 0xA5, 0xC3, 0x3E, 0x92, 0x8C, 0x27, 0x51, 0xFC, 0x1B, 0x31, 0xEB, 0x32}; // Good: - static constexpr std::uint8_t kPAYLOAD8[] = { + static constexpr std::uint8_t kPayload8[] = { 0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, @@ -150,7 +150,7 @@ public: try { - SerialIter sit{kPAYLOAD8}; + SerialIter sit{kPayload8}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, true); @@ -172,7 +172,7 @@ public: try { - SerialIter sit{kPAYLOAD1}; + SerialIter sit{kPayload1}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false); fail("An exception should have been thrown"); @@ -184,7 +184,7 @@ public: try { - SerialIter sit{kPAYLOAD2}; + SerialIter sit{kPayload2}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false); fail("An exception should have been thrown"); @@ -196,7 +196,7 @@ public: try { - SerialIter sit{kPAYLOAD3}; + SerialIter sit{kPayload3}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false); fail("An exception should have been thrown"); @@ -208,7 +208,7 @@ public: try { - SerialIter sit{kPAYLOAD4}; + SerialIter sit{kPayload4}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false); fail("An exception should have been thrown"); @@ -222,7 +222,7 @@ public: try { - SerialIter sit{kPAYLOAD5}; + SerialIter sit{kPayload5}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false); fail("Expected exception not thrown from validation"); @@ -234,7 +234,7 @@ public: try { - SerialIter sit{kPAYLOAD6}; + SerialIter sit{kPayload6}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false); fail("Expected exception not thrown from validation"); @@ -246,7 +246,7 @@ public: try { - SerialIter sit{kPAYLOAD7}; + SerialIter sit{kPayload7}; auto val = std::make_shared( sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false); @@ -262,7 +262,7 @@ public: // Mutate a known-good validation and expect it to fail: std::vector v; - for (auto c : kPAYLOAD8) + for (auto c : kPayload8) v.push_back(c); beast::xor_shift_engine g(148979842); diff --git a/src/test/protocol/SecretKey_test.cpp b/src/test/protocol/SecretKey_test.cpp index 5dbb0727e8..967c4417eb 100644 --- a/src/test/protocol/SecretKey_test.cpp +++ b/src/test/protocol/SecretKey_test.cpp @@ -301,7 +301,7 @@ public: { testcase("secp256k1: key derivation"); - for (auto const& test : kSECP256K1_TEST_VECTORS) + for (auto const& test : kSecP256K1TestVectors) { auto const id = parseBase58(test.addr); BEAST_EXPECT(id); @@ -320,7 +320,7 @@ public: { testcase("ed25519: key derivation"); - for (auto const& test : kED25519_TEST_VECTORS) + for (auto const& test : kED25519TestVectors) { auto const id = parseBase58(test.addr); BEAST_EXPECT(id); @@ -352,7 +352,7 @@ public: private: // clang-format off -inline static TestKeyData const kSECP256K1_TEST_VECTORS[] = { +inline static TestKeyData const kSecP256K1TestVectors[] = { {.seed={0xDE,0xDC,0xE9,0xCE,0x67,0xB4,0x51,0xD8,0x52,0xFD,0x4E,0x84,0x6F,0xCD,0xE3,0x1C}, .pubkey={0x03,0x30,0xE7,0xFC,0x9D,0x56,0xBB,0x25,0xD6,0x89,0x3B,0xA3,0xF3,0x17,0xAE,0x5B, 0xCF,0x33,0xB3,0x29,0x1B,0xD6,0x3D,0xB3,0x26,0x54,0xA3,0x13,0x22,0x2F,0x7F,0xD0,0x20}, @@ -925,7 +925,7 @@ inline static TestKeyData const kSECP256K1_TEST_VECTORS[] = { .addr="rsYryUWhbYRiQivh693pgjnseAwPHezNj1"} }; -inline static TestKeyData const kED25519_TEST_VECTORS[] = { +inline static TestKeyData const kED25519TestVectors[] = { {.seed={0xAF,0x41,0xFF,0x66,0xF7,0x5E,0xBD,0x3A,0x6B,0x18,0xFB,0x7A,0x1D,0xF6,0x1C,0x97}, .pubkey={0xED,0x48,0xCB,0xBB,0xE0,0xEE,0x7B,0x86,0x86,0xA7,0xDE,0x9F,0x0A,0x01,0x59,0x73, 0x4E,0x65,0xF9,0xC3,0x69,0x94,0x7F,0x2E,0x26,0x96,0x23,0x2B,0x46,0x1E,0x55,0x32,0x13}, diff --git a/src/test/protocol/SeqProxy_test.cpp b/src/test/protocol/SeqProxy_test.cpp index 7da5751506..90345ddc22 100644 --- a/src/test/protocol/SeqProxy_test.cpp +++ b/src/test/protocol/SeqProxy_test.cpp @@ -64,157 +64,157 @@ struct SeqProxy_test : public beast::unit_test::Suite // While SeqProxy supports values of zero, they are not // expected in the wild. Nevertheless they are tested here. // But so are values of 1, which are expected to occur in the wild. - static constexpr std::uint32_t kUINT_MAX{std::numeric_limits::max()}; - static constexpr SeqProxy::Type kSEQ{SeqProxy::Type::Seq}; - static constexpr SeqProxy::Type kTICKET{SeqProxy::Type::Ticket}; + static constexpr std::uint32_t kUintMax{std::numeric_limits::max()}; + static constexpr SeqProxy::Type kSeq{SeqProxy::Type::Seq}; + static constexpr SeqProxy::Type kTicket{SeqProxy::Type::Ticket}; - static constexpr SeqProxy kSEQ_ZERO{kSEQ, 0}; - static constexpr SeqProxy kSEQ_SMALL{kSEQ, 1}; - static constexpr SeqProxy kSEQ_MID0{kSEQ, 2}; - static constexpr SeqProxy kSEQ_MID1{kSEQ_MID0}; - static constexpr SeqProxy kSEQ_BIG{kSEQ, kUINT_MAX}; + static constexpr SeqProxy kSeqZero{kSeq, 0}; + static constexpr SeqProxy kSeqSmall{kSeq, 1}; + static constexpr SeqProxy kSeqMiD0{kSeq, 2}; + static constexpr SeqProxy kSeqMiD1{kSeqMiD0}; + static constexpr SeqProxy kSeqBig{kSeq, kUintMax}; - static constexpr SeqProxy kTIC_ZERO{kTICKET, 0}; - static constexpr SeqProxy kTIC_SMALL{kTICKET, 1}; - static constexpr SeqProxy kTIC_MID0{kTICKET, 2}; - static constexpr SeqProxy kTIC_MID1{kTIC_MID0}; - static constexpr SeqProxy kTIC_BIG{kTICKET, kUINT_MAX}; + static constexpr SeqProxy kTicZero{kTicket, 0}; + static constexpr SeqProxy kTicSmall{kTicket, 1}; + static constexpr SeqProxy kTicMid0{kTicket, 2}; + static constexpr SeqProxy kTicMid1{kTicMid0}; + static constexpr SeqProxy kTicBig{kTicket, kUintMax}; // Verify operation of value(), isSeq() and isTicket(). - static_assert(expectValues(kSEQ_ZERO, 0, kSEQ), ""); - static_assert(expectValues(kSEQ_SMALL, 1, kSEQ), ""); - static_assert(expectValues(kSEQ_MID0, 2, kSEQ), ""); - static_assert(expectValues(kSEQ_MID1, 2, kSEQ), ""); - static_assert(expectValues(kSEQ_BIG, kUINT_MAX, kSEQ), ""); + static_assert(expectValues(kSeqZero, 0, kSeq), ""); + static_assert(expectValues(kSeqSmall, 1, kSeq), ""); + static_assert(expectValues(kSeqMiD0, 2, kSeq), ""); + static_assert(expectValues(kSeqMiD1, 2, kSeq), ""); + static_assert(expectValues(kSeqBig, kUintMax, kSeq), ""); - static_assert(expectValues(kTIC_ZERO, 0, kTICKET), ""); - static_assert(expectValues(kTIC_SMALL, 1, kTICKET), ""); - static_assert(expectValues(kTIC_MID0, 2, kTICKET), ""); - static_assert(expectValues(kTIC_MID1, 2, kTICKET), ""); - static_assert(expectValues(kTIC_BIG, kUINT_MAX, kTICKET), ""); + static_assert(expectValues(kTicZero, 0, kTicket), ""); + static_assert(expectValues(kTicSmall, 1, kTicket), ""); + static_assert(expectValues(kTicMid0, 2, kTicket), ""); + static_assert(expectValues(kTicMid1, 2, kTicket), ""); + static_assert(expectValues(kTicBig, kUintMax, kTicket), ""); // Verify expected behavior of comparison operators. - static_assert(expectEq(kSEQ_ZERO, kSEQ_ZERO), ""); - static_assert(expectLt(kSEQ_ZERO, kSEQ_SMALL), ""); - static_assert(expectLt(kSEQ_ZERO, kSEQ_MID0), ""); - static_assert(expectLt(kSEQ_ZERO, kSEQ_MID1), ""); - static_assert(expectLt(kSEQ_ZERO, kSEQ_BIG), ""); - static_assert(expectLt(kSEQ_ZERO, kTIC_ZERO), ""); - static_assert(expectLt(kSEQ_ZERO, kTIC_SMALL), ""); - static_assert(expectLt(kSEQ_ZERO, kTIC_MID0), ""); - static_assert(expectLt(kSEQ_ZERO, kTIC_MID1), ""); - static_assert(expectLt(kSEQ_ZERO, kTIC_BIG), ""); + static_assert(expectEq(kSeqZero, kSeqZero), ""); + static_assert(expectLt(kSeqZero, kSeqSmall), ""); + static_assert(expectLt(kSeqZero, kSeqMiD0), ""); + static_assert(expectLt(kSeqZero, kSeqMiD1), ""); + static_assert(expectLt(kSeqZero, kSeqBig), ""); + static_assert(expectLt(kSeqZero, kTicZero), ""); + static_assert(expectLt(kSeqZero, kTicSmall), ""); + static_assert(expectLt(kSeqZero, kTicMid0), ""); + static_assert(expectLt(kSeqZero, kTicMid1), ""); + static_assert(expectLt(kSeqZero, kTicBig), ""); - static_assert(expectGt(kSEQ_SMALL, kSEQ_ZERO), ""); - static_assert(expectEq(kSEQ_SMALL, kSEQ_SMALL), ""); - static_assert(expectLt(kSEQ_SMALL, kSEQ_MID0), ""); - static_assert(expectLt(kSEQ_SMALL, kSEQ_MID1), ""); - static_assert(expectLt(kSEQ_SMALL, kSEQ_BIG), ""); - static_assert(expectLt(kSEQ_SMALL, kTIC_ZERO), ""); - static_assert(expectLt(kSEQ_SMALL, kTIC_SMALL), ""); - static_assert(expectLt(kSEQ_SMALL, kTIC_MID0), ""); - static_assert(expectLt(kSEQ_SMALL, kTIC_MID1), ""); - static_assert(expectLt(kSEQ_SMALL, kTIC_BIG), ""); + static_assert(expectGt(kSeqSmall, kSeqZero), ""); + static_assert(expectEq(kSeqSmall, kSeqSmall), ""); + static_assert(expectLt(kSeqSmall, kSeqMiD0), ""); + static_assert(expectLt(kSeqSmall, kSeqMiD1), ""); + static_assert(expectLt(kSeqSmall, kSeqBig), ""); + static_assert(expectLt(kSeqSmall, kTicZero), ""); + static_assert(expectLt(kSeqSmall, kTicSmall), ""); + static_assert(expectLt(kSeqSmall, kTicMid0), ""); + static_assert(expectLt(kSeqSmall, kTicMid1), ""); + static_assert(expectLt(kSeqSmall, kTicBig), ""); - static_assert(expectGt(kSEQ_MID0, kSEQ_ZERO), ""); - static_assert(expectGt(kSEQ_MID0, kSEQ_SMALL), ""); - static_assert(expectEq(kSEQ_MID0, kSEQ_MID0), ""); - static_assert(expectEq(kSEQ_MID0, kSEQ_MID1), ""); - static_assert(expectLt(kSEQ_MID0, kSEQ_BIG), ""); - static_assert(expectLt(kSEQ_MID0, kTIC_ZERO), ""); - static_assert(expectLt(kSEQ_MID0, kTIC_SMALL), ""); - static_assert(expectLt(kSEQ_MID0, kTIC_MID0), ""); - static_assert(expectLt(kSEQ_MID0, kTIC_MID1), ""); - static_assert(expectLt(kSEQ_MID0, kTIC_BIG), ""); + static_assert(expectGt(kSeqMiD0, kSeqZero), ""); + static_assert(expectGt(kSeqMiD0, kSeqSmall), ""); + static_assert(expectEq(kSeqMiD0, kSeqMiD0), ""); + static_assert(expectEq(kSeqMiD0, kSeqMiD1), ""); + static_assert(expectLt(kSeqMiD0, kSeqBig), ""); + static_assert(expectLt(kSeqMiD0, kTicZero), ""); + static_assert(expectLt(kSeqMiD0, kTicSmall), ""); + static_assert(expectLt(kSeqMiD0, kTicMid0), ""); + static_assert(expectLt(kSeqMiD0, kTicMid1), ""); + static_assert(expectLt(kSeqMiD0, kTicBig), ""); - static_assert(expectGt(kSEQ_MID1, kSEQ_ZERO), ""); - static_assert(expectGt(kSEQ_MID1, kSEQ_SMALL), ""); - static_assert(expectEq(kSEQ_MID1, kSEQ_MID0), ""); - static_assert(expectEq(kSEQ_MID1, kSEQ_MID1), ""); - static_assert(expectLt(kSEQ_MID1, kSEQ_BIG), ""); - static_assert(expectLt(kSEQ_MID1, kTIC_ZERO), ""); - static_assert(expectLt(kSEQ_MID1, kTIC_SMALL), ""); - static_assert(expectLt(kSEQ_MID1, kTIC_MID0), ""); - static_assert(expectLt(kSEQ_MID1, kTIC_MID1), ""); - static_assert(expectLt(kSEQ_MID1, kTIC_BIG), ""); + static_assert(expectGt(kSeqMiD1, kSeqZero), ""); + static_assert(expectGt(kSeqMiD1, kSeqSmall), ""); + static_assert(expectEq(kSeqMiD1, kSeqMiD0), ""); + static_assert(expectEq(kSeqMiD1, kSeqMiD1), ""); + static_assert(expectLt(kSeqMiD1, kSeqBig), ""); + static_assert(expectLt(kSeqMiD1, kTicZero), ""); + static_assert(expectLt(kSeqMiD1, kTicSmall), ""); + static_assert(expectLt(kSeqMiD1, kTicMid0), ""); + static_assert(expectLt(kSeqMiD1, kTicMid1), ""); + static_assert(expectLt(kSeqMiD1, kTicBig), ""); - static_assert(expectGt(kSEQ_BIG, kSEQ_ZERO), ""); - static_assert(expectGt(kSEQ_BIG, kSEQ_SMALL), ""); - static_assert(expectGt(kSEQ_BIG, kSEQ_MID0), ""); - static_assert(expectGt(kSEQ_BIG, kSEQ_MID1), ""); - static_assert(expectEq(kSEQ_BIG, kSEQ_BIG), ""); - static_assert(expectLt(kSEQ_BIG, kTIC_ZERO), ""); - static_assert(expectLt(kSEQ_BIG, kTIC_SMALL), ""); - static_assert(expectLt(kSEQ_BIG, kTIC_MID0), ""); - static_assert(expectLt(kSEQ_BIG, kTIC_MID1), ""); - static_assert(expectLt(kSEQ_BIG, kTIC_BIG), ""); + static_assert(expectGt(kSeqBig, kSeqZero), ""); + static_assert(expectGt(kSeqBig, kSeqSmall), ""); + static_assert(expectGt(kSeqBig, kSeqMiD0), ""); + static_assert(expectGt(kSeqBig, kSeqMiD1), ""); + static_assert(expectEq(kSeqBig, kSeqBig), ""); + static_assert(expectLt(kSeqBig, kTicZero), ""); + static_assert(expectLt(kSeqBig, kTicSmall), ""); + static_assert(expectLt(kSeqBig, kTicMid0), ""); + static_assert(expectLt(kSeqBig, kTicMid1), ""); + static_assert(expectLt(kSeqBig, kTicBig), ""); - static_assert(expectGt(kTIC_ZERO, kSEQ_ZERO), ""); - static_assert(expectGt(kTIC_ZERO, kSEQ_SMALL), ""); - static_assert(expectGt(kTIC_ZERO, kSEQ_MID0), ""); - static_assert(expectGt(kTIC_ZERO, kSEQ_MID1), ""); - static_assert(expectGt(kTIC_ZERO, kSEQ_BIG), ""); - static_assert(expectEq(kTIC_ZERO, kTIC_ZERO), ""); - static_assert(expectLt(kTIC_ZERO, kTIC_SMALL), ""); - static_assert(expectLt(kTIC_ZERO, kTIC_MID0), ""); - static_assert(expectLt(kTIC_ZERO, kTIC_MID1), ""); - static_assert(expectLt(kTIC_ZERO, kTIC_BIG), ""); + static_assert(expectGt(kTicZero, kSeqZero), ""); + static_assert(expectGt(kTicZero, kSeqSmall), ""); + static_assert(expectGt(kTicZero, kSeqMiD0), ""); + static_assert(expectGt(kTicZero, kSeqMiD1), ""); + static_assert(expectGt(kTicZero, kSeqBig), ""); + static_assert(expectEq(kTicZero, kTicZero), ""); + static_assert(expectLt(kTicZero, kTicSmall), ""); + static_assert(expectLt(kTicZero, kTicMid0), ""); + static_assert(expectLt(kTicZero, kTicMid1), ""); + static_assert(expectLt(kTicZero, kTicBig), ""); - static_assert(expectGt(kTIC_SMALL, kSEQ_ZERO), ""); - static_assert(expectGt(kTIC_SMALL, kSEQ_SMALL), ""); - static_assert(expectGt(kTIC_SMALL, kSEQ_MID0), ""); - static_assert(expectGt(kTIC_SMALL, kSEQ_MID1), ""); - static_assert(expectGt(kTIC_SMALL, kSEQ_BIG), ""); - static_assert(expectGt(kTIC_SMALL, kTIC_ZERO), ""); - static_assert(expectEq(kTIC_SMALL, kTIC_SMALL), ""); - static_assert(expectLt(kTIC_SMALL, kTIC_MID0), ""); - static_assert(expectLt(kTIC_SMALL, kTIC_MID1), ""); - static_assert(expectLt(kTIC_SMALL, kTIC_BIG), ""); + static_assert(expectGt(kTicSmall, kSeqZero), ""); + static_assert(expectGt(kTicSmall, kSeqSmall), ""); + static_assert(expectGt(kTicSmall, kSeqMiD0), ""); + static_assert(expectGt(kTicSmall, kSeqMiD1), ""); + static_assert(expectGt(kTicSmall, kSeqBig), ""); + static_assert(expectGt(kTicSmall, kTicZero), ""); + static_assert(expectEq(kTicSmall, kTicSmall), ""); + static_assert(expectLt(kTicSmall, kTicMid0), ""); + static_assert(expectLt(kTicSmall, kTicMid1), ""); + static_assert(expectLt(kTicSmall, kTicBig), ""); - static_assert(expectGt(kTIC_MID0, kSEQ_ZERO), ""); - static_assert(expectGt(kTIC_MID0, kSEQ_SMALL), ""); - static_assert(expectGt(kTIC_MID0, kSEQ_MID0), ""); - static_assert(expectGt(kTIC_MID0, kSEQ_MID1), ""); - static_assert(expectGt(kTIC_MID0, kSEQ_BIG), ""); - static_assert(expectGt(kTIC_MID0, kTIC_ZERO), ""); - static_assert(expectGt(kTIC_MID0, kTIC_SMALL), ""); - static_assert(expectEq(kTIC_MID0, kTIC_MID0), ""); - static_assert(expectEq(kTIC_MID0, kTIC_MID1), ""); - static_assert(expectLt(kTIC_MID0, kTIC_BIG), ""); + static_assert(expectGt(kTicMid0, kSeqZero), ""); + static_assert(expectGt(kTicMid0, kSeqSmall), ""); + static_assert(expectGt(kTicMid0, kSeqMiD0), ""); + static_assert(expectGt(kTicMid0, kSeqMiD1), ""); + static_assert(expectGt(kTicMid0, kSeqBig), ""); + static_assert(expectGt(kTicMid0, kTicZero), ""); + static_assert(expectGt(kTicMid0, kTicSmall), ""); + static_assert(expectEq(kTicMid0, kTicMid0), ""); + static_assert(expectEq(kTicMid0, kTicMid1), ""); + static_assert(expectLt(kTicMid0, kTicBig), ""); - static_assert(expectGt(kTIC_MID1, kSEQ_ZERO), ""); - static_assert(expectGt(kTIC_MID1, kSEQ_SMALL), ""); - static_assert(expectGt(kTIC_MID1, kSEQ_MID0), ""); - static_assert(expectGt(kTIC_MID1, kSEQ_MID1), ""); - static_assert(expectGt(kTIC_MID1, kSEQ_BIG), ""); - static_assert(expectGt(kTIC_MID1, kTIC_ZERO), ""); - static_assert(expectGt(kTIC_MID1, kTIC_SMALL), ""); - static_assert(expectEq(kTIC_MID1, kTIC_MID0), ""); - static_assert(expectEq(kTIC_MID1, kTIC_MID1), ""); - static_assert(expectLt(kTIC_MID1, kTIC_BIG), ""); + static_assert(expectGt(kTicMid1, kSeqZero), ""); + static_assert(expectGt(kTicMid1, kSeqSmall), ""); + static_assert(expectGt(kTicMid1, kSeqMiD0), ""); + static_assert(expectGt(kTicMid1, kSeqMiD1), ""); + static_assert(expectGt(kTicMid1, kSeqBig), ""); + static_assert(expectGt(kTicMid1, kTicZero), ""); + static_assert(expectGt(kTicMid1, kTicSmall), ""); + static_assert(expectEq(kTicMid1, kTicMid0), ""); + static_assert(expectEq(kTicMid1, kTicMid1), ""); + static_assert(expectLt(kTicMid1, kTicBig), ""); - static_assert(expectGt(kTIC_BIG, kSEQ_ZERO), ""); - static_assert(expectGt(kTIC_BIG, kSEQ_SMALL), ""); - static_assert(expectGt(kTIC_BIG, kSEQ_MID0), ""); - static_assert(expectGt(kTIC_BIG, kSEQ_MID1), ""); - static_assert(expectGt(kTIC_BIG, kSEQ_BIG), ""); - static_assert(expectGt(kTIC_BIG, kTIC_ZERO), ""); - static_assert(expectGt(kTIC_BIG, kTIC_SMALL), ""); - static_assert(expectGt(kTIC_BIG, kTIC_MID0), ""); - static_assert(expectGt(kTIC_BIG, kTIC_MID1), ""); - static_assert(expectEq(kTIC_BIG, kTIC_BIG), ""); + static_assert(expectGt(kTicBig, kSeqZero), ""); + static_assert(expectGt(kTicBig, kSeqSmall), ""); + static_assert(expectGt(kTicBig, kSeqMiD0), ""); + static_assert(expectGt(kTicBig, kSeqMiD1), ""); + static_assert(expectGt(kTicBig, kSeqBig), ""); + static_assert(expectGt(kTicBig, kTicZero), ""); + static_assert(expectGt(kTicBig, kTicSmall), ""); + static_assert(expectGt(kTicBig, kTicMid0), ""); + static_assert(expectGt(kTicBig, kTicMid1), ""); + static_assert(expectEq(kTicBig, kTicBig), ""); // Verify streaming. - BEAST_EXPECT(streamTest(kSEQ_ZERO)); - BEAST_EXPECT(streamTest(kSEQ_SMALL)); - BEAST_EXPECT(streamTest(kSEQ_MID0)); - BEAST_EXPECT(streamTest(kSEQ_MID1)); - BEAST_EXPECT(streamTest(kSEQ_BIG)); - BEAST_EXPECT(streamTest(kTIC_ZERO)); - BEAST_EXPECT(streamTest(kTIC_SMALL)); - BEAST_EXPECT(streamTest(kTIC_MID0)); - BEAST_EXPECT(streamTest(kTIC_MID1)); - BEAST_EXPECT(streamTest(kTIC_BIG)); + BEAST_EXPECT(streamTest(kSeqZero)); + BEAST_EXPECT(streamTest(kSeqSmall)); + BEAST_EXPECT(streamTest(kSeqMiD0)); + BEAST_EXPECT(streamTest(kSeqMiD1)); + BEAST_EXPECT(streamTest(kSeqBig)); + BEAST_EXPECT(streamTest(kTicZero)); + BEAST_EXPECT(streamTest(kTicSmall)); + BEAST_EXPECT(streamTest(kTicMid0)); + BEAST_EXPECT(streamTest(kTicMid1)); + BEAST_EXPECT(streamTest(kTicBig)); } }; diff --git a/src/test/protocol/TER_test.cpp b/src/test/protocol/TER_test.cpp index d9028fa941..af1cfced0e 100644 --- a/src/test/protocol/TER_test.cpp +++ b/src/test/protocol/TER_test.cpp @@ -114,12 +114,12 @@ struct TER_test : public beast::unit_test::Suite // are not valid. // Examples of each kind of enum. - static auto const kTER_ENUMS = std::make_tuple( + static auto const kTerEnums = std::make_tuple( telLOCAL_ERROR, temMALFORMED, tefFAILURE, terRETRY, tesSUCCESS, tecCLAIM); - static int const kHI_INDEX{std::tuple_size_v - 1}; + static int const kHiIndex{std::tuple_size_v - 1}; // Verify that enums cannot be converted to other enum types. - testIterate(kTER_ENUMS, *this); + testIterate(kTerEnums, *this); // Lambda that verifies assignability and convertibility. auto isConvertible = [](auto from, auto to) { @@ -216,7 +216,7 @@ struct TER_test : public beast::unit_test::Suite // All of the TER-related types should be comparable. // Examples of all the types we expect to successfully compare. - static auto const kTERS = std::make_tuple( + static auto const kTers = std::make_tuple( telLOCAL_ERROR, temMALFORMED, tefFAILURE, @@ -225,11 +225,11 @@ struct TER_test : public beast::unit_test::Suite tecCLAIM, NotTEC{telLOCAL_ERROR}, TER{tecCLAIM}); - static int const kHI_INDEX{std::tuple_size_v - 1}; + static int const kHiIndex{std::tuple_size_v - 1}; // Verify that all types in the ters tuple can be compared with all // the other types in ters. - testIterate(kTERS, *this); + testIterate(kTers, *this); } void diff --git a/src/test/resource/Logic_test.cpp b/src/test/resource/Logic_test.cpp index 1f2dc8f4dc..de4575cb16 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(kDropThreshold + 1); beast::IP::Endpoint const addr(beast::IP::Endpoint::fromString("192.0.2.2")); std::function const ep = limited @@ -179,7 +179,7 @@ public: using namespace std::chrono_literals; // Give Consumer time to become readmitted. Should never // exceed expiration time. - auto n = kSECONDS_UNTIL_EXPIRATION + 1s; + auto n = kSecondsUntilExpiration + 1s; while (--n > 0s) { ++logic.clock(); @@ -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..385fc2f58a 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)); } } @@ -526,7 +526,7 @@ public: return res; }; - static constexpr std::array, 7> kAS_FLAGS{ + static constexpr std::array, 7> kAsFlags{ {{"defaultRipple", asfDefaultRipple}, {"depositAuth", asfDepositAuth}, {"disallowIncomingXRP", asfDisallowXRP}, @@ -535,7 +535,7 @@ public: {"requireAuthorization", asfRequireAuth}, {"requireDestinationTag", asfRequireDest}}}; - for (auto& asf : kAS_FLAGS) + for (auto& asf : kAsFlags) { // Clear a flag and check that account_info returns results // as expected @@ -555,13 +555,13 @@ public: } static constexpr std::array, 4> - kDISALLOW_INCOMING_FLAGS{ + kDisallowIncomingFlags{ {{"disallowIncomingCheck", asfDisallowIncomingCheck}, {"disallowIncomingNFTokenOffer", asfDisallowIncomingNFTokenOffer}, {"disallowIncomingPayChan", asfDisallowIncomingPayChan}, {"disallowIncomingTrustline", asfDisallowIncomingTrustline}}}; - for (auto& asf : kDISALLOW_INCOMING_FLAGS) + for (auto& asf : kDisallowIncomingFlags) { // Clear a flag and check that account_info returns results // as expected @@ -580,47 +580,47 @@ public: BEAST_EXPECT(f2.value()); // NOLINT(bugprone-unchecked-optional-access) } - static constexpr std::pair kALLOW_TRUST_LINE_CLAWBACK_FLAG{ + static constexpr std::pair kAllowTrustLineClawbackFlag{ "allowTrustLineClawback", asfAllowTrustLineClawback}; if (features[featureClawback]) { // must use bob's account because alice has noFreeze set - auto const f1 = getAccountFlag(kALLOW_TRUST_LINE_CLAWBACK_FLAG.first, bob); + auto const f1 = getAccountFlag(kAllowTrustLineClawbackFlag.first, bob); BEAST_EXPECT(f1.has_value()); BEAST_EXPECT(!f1.value()); // NOLINT(bugprone-unchecked-optional-access) // Set allowTrustLineClawback - env(fset(bob, kALLOW_TRUST_LINE_CLAWBACK_FLAG.second)); + env(fset(bob, kAllowTrustLineClawbackFlag.second)); env.close(); - auto const f2 = getAccountFlag(kALLOW_TRUST_LINE_CLAWBACK_FLAG.first, bob); + auto const f2 = getAccountFlag(kAllowTrustLineClawbackFlag.first, bob); BEAST_EXPECT(f2.has_value()); BEAST_EXPECT(f2.value()); // NOLINT(bugprone-unchecked-optional-access) } else { - BEAST_EXPECT(!getAccountFlag(kALLOW_TRUST_LINE_CLAWBACK_FLAG.first, bob)); + BEAST_EXPECT(!getAccountFlag(kAllowTrustLineClawbackFlag.first, bob)); } - static constexpr std::pair kALLOW_TRUST_LINE_LOCKING_FLAG{ + static constexpr std::pair kAllowTrustLineLockingFlag{ "allowTrustLineLocking", asfAllowTrustLineLocking}; if (features[featureTokenEscrow]) { - auto const f1 = getAccountFlag(kALLOW_TRUST_LINE_LOCKING_FLAG.first, bob); + auto const f1 = getAccountFlag(kAllowTrustLineLockingFlag.first, bob); BEAST_EXPECT(f1.has_value()); BEAST_EXPECT(!f1.value()); // NOLINT(bugprone-unchecked-optional-access) // Set allowTrustLineLocking - env(fset(bob, kALLOW_TRUST_LINE_LOCKING_FLAG.second)); + env(fset(bob, kAllowTrustLineLockingFlag.second)); env.close(); - auto const f2 = getAccountFlag(kALLOW_TRUST_LINE_LOCKING_FLAG.first, bob); + auto const f2 = getAccountFlag(kAllowTrustLineLockingFlag.first, bob); BEAST_EXPECT(f2.has_value()); BEAST_EXPECT(f2.value()); // NOLINT(bugprone-unchecked-optional-access) } else { - BEAST_EXPECT(!getAccountFlag(kALLOW_TRUST_LINE_LOCKING_FLAG.first, bob)); + BEAST_EXPECT(!getAccountFlag(kAllowTrustLineLockingFlag.first, bob)); } } diff --git a/src/test/rpc/AccountLines_test.cpp b/src/test/rpc/AccountLines_test.cpp index 750ba9cc78..8d55c5e19d 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; @@ -554,8 +554,8 @@ public: env.close(); // Escrow, in each direction - env(escrow::create(alice, becky, XRP(1000)), escrow::kFINISH_TIME(env.now() + 1s)); - env(escrow::create(becky, alice, XRP(1000)), escrow::kFINISH_TIME(env.now() + 1s)); + env(escrow::create(alice, becky, XRP(1000)), escrow::kFinishTime(env.now() + 1s)); + env(escrow::create(becky, alice, XRP(1000)), escrow::kFinishTime(env.now() + 1s)); // Pay channels, in each direction env(payChan(alice, becky, XRP(1000), 100s, alice.pk())); @@ -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) @@ -628,9 +628,9 @@ public: }; auto aliceLines = getNextLine(env, alice, std::nullopt); - constexpr std::size_t kEXPECTED_ITERATIONS = 16; - constexpr std::size_t kEXPECTED_LINES = 2; - constexpr std::size_t kEXPECTED_NF_TS = 1; + static constexpr std::size_t kExpectedIterations = 16; + static constexpr std::size_t kExpectedLines = 2; + static constexpr std::size_t kExpectedNfTs = 1; std::size_t foundLines = 0; auto hasMarker = [](auto const& aliceLines) { @@ -661,7 +661,7 @@ public: foundLines += aliceLines[jss::result][jss::lines].size(); ++iterations; } - BEAST_EXPECT(kEXPECTED_LINES == foundLines); + BEAST_EXPECT(kExpectedLines == foundLines); json::Value aliceObjectsParams2; aliceObjectsParams2[jss::account] = alice.human(); @@ -677,10 +677,10 @@ public: // this test will need to be updated. BEAST_EXPECT( aliceObjects[jss::result][jss::account_objects].size() == - iterations + kEXPECTED_NF_TS); + iterations + kExpectedNfTs); // If ledger object association ever changes, for whatever // reason, this test will need to be updated. - BEAST_EXPECTS(iterations == kEXPECTED_ITERATIONS, std::to_string(iterations)); + BEAST_EXPECTS(iterations == kExpectedIterations, std::to_string(iterations)); // Get becky's objects just to confirm that they're symmetrical json::Value beckyObjectsParams; diff --git a/src/test/rpc/AccountObjects_test.cpp b/src/test/rpc/AccountObjects_test.cpp index 6feec6334b..4307b7ab7f 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(); @@ -740,11 +740,11 @@ public: return scEnv.rpc("json", "account_objects", to_string(params)); }; - json::Value const resp = scEnvAcctObjs(Account::kMASTER, jss::bridge); + json::Value const resp = scEnvAcctObjs(Account::kMaster, jss::bridge); BEAST_EXPECT(acctObjsIsSize(resp, 1)); auto const& acctBridge = resp[jss::result][jss::account_objects][0u]; - BEAST_EXPECT(acctBridge[sfAccount.jsonName] == Account::kMASTER.human()); + BEAST_EXPECT(acctBridge[sfAccount.jsonName] == Account::kMaster.human()); BEAST_EXPECT(acctBridge[sfLedgerEntryType.getJsonName()] == "Bridge"); BEAST_EXPECT(acctBridge[sfXChainClaimID.getJsonName()].asUInt() == 0); BEAST_EXPECT(acctBridge[sfXChainAccountClaimCount.getJsonName()].asUInt() == 0); @@ -800,7 +800,7 @@ public: // send first batch of account create attestations, so the // xchain_create_account_claim_id_ should be present on the door - // account (Account::kMASTER) to collect the signatures until a + // account (Account::kMaster) to collect the signatures until a // quorum is reached scEnv( test::jtx::createAccountAttestation( @@ -827,13 +827,13 @@ public: { // Find the xchain_create_account_claim_id_ json::Value const resp = - scEnvAcctObjs(Account::kMASTER, jss::xchain_owned_create_account_claim_id); + scEnvAcctObjs(Account::kMaster, jss::xchain_owned_create_account_claim_id); BEAST_EXPECT(acctObjsIsSize(resp, 1)); auto const& xchainCreateAccountClaimId = resp[jss::result][jss::account_objects][0u]; BEAST_EXPECT( - xchainCreateAccountClaimId[sfAccount.jsonName] == Account::kMASTER.human()); + xchainCreateAccountClaimId[sfAccount.jsonName] == Account::kMaster.human()); BEAST_EXPECT( xchainCreateAccountClaimId[sfXChainAccountCreateCount.getJsonName()].asUInt() == 1); @@ -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); @@ -1061,8 +1061,8 @@ public: Account const bob{"bob"}; env.fund(XRP(10000), bob); - static constexpr unsigned kNFTS_SIZE = 10; - for (unsigned i = 0; i < kNFTS_SIZE; i++) + static constexpr unsigned kNftsSize = 10; + for (unsigned i = 0; i < kNftsSize; i++) { env(token::mint(bob, 0)); } @@ -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..421f6bd1fa 100644 --- a/src/test/rpc/AccountTx_test.cpp +++ b/src/test/rpc/AccountTx_test.cpp @@ -131,7 +131,7 @@ class AccountTx_test : public beast::unit_test::Suite using namespace test::jtx; Env env(*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; })); Account const a1{"A1"}; @@ -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(); } @@ -651,7 +651,7 @@ class AccountTx_test : public beast::unit_test::Suite // clang-format off // Do a sanity check on each returned transaction. They should // be returned in the reverse order of application to the ledger. - static const NodeSanity kSANITY[]{ + static const NodeSanity kSanity[]{ // txType, created, deleted, modified {0, jss::DepositPreauth, {jss::DepositPreauth}, {jss::Ticket}, {jss::AccountRoot, jss::DirectoryNode}}, {1, jss::TicketCreate, {jss::Ticket}, {}, {jss::AccountRoot, jss::DirectoryNode}}, @@ -678,11 +678,11 @@ class AccountTx_test : public beast::unit_test::Suite }; // clang-format on - BEAST_EXPECT(std::size(kSANITY) == result[jss::result][jss::transactions].size()); + BEAST_EXPECT(std::size(kSanity) == result[jss::result][jss::transactions].size()); - for (unsigned int index{0}; index < std::size(kSANITY); ++index) + for (unsigned int index{0}; index < std::size(kSanity); ++index) { - checkSanity(txs[index], kSANITY[index]); + checkSanity(txs[index], kSanity[index]); } } @@ -733,7 +733,7 @@ class AccountTx_test : public beast::unit_test::Suite // // Note that the first two transactions in sanity have not occurred // yet. We'll see those after becky's account is resurrected. - static const NodeSanity kSANITY[] + static const NodeSanity kSanity[] { // txType, created, deleted, modified /* becky pays alice */ { 0, jss::Payment, {}, {}, {jss::AccountRoot, jss::AccountRoot}}, @@ -759,22 +759,22 @@ class AccountTx_test : public beast::unit_test::Suite BEAST_EXPECT(result[jss::result][jss::transactions].isArray()); // The first two transactions listed in sanity haven't happened yet. - constexpr unsigned int kBECKY_DELETED_OFFSET = 2; + static constexpr unsigned int kBeckyDeletedOffset = 2; BEAST_EXPECT( - std::size(kSANITY) == - result[jss::result][jss::transactions].size() + kBECKY_DELETED_OFFSET); + std::size(kSanity) == + result[jss::result][jss::transactions].size() + kBeckyDeletedOffset); json::Value const& txs{result[jss::result][jss::transactions]}; - for (unsigned int index = kBECKY_DELETED_OFFSET; index < std::size(kSANITY); ++index) + for (unsigned int index = kBeckyDeletedOffset; index < std::size(kSanity); ++index) { - checkSanity(txs[index - kBECKY_DELETED_OFFSET], kSANITY[index]); + checkSanity(txs[index - kBeckyDeletedOffset], kSanity[index]); } } // 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(); @@ -802,13 +802,13 @@ class AccountTx_test : public beast::unit_test::Suite BEAST_EXPECT(result[jss::result][jss::status] == "success"); BEAST_EXPECT(result[jss::result][jss::transactions].isArray()); - BEAST_EXPECT(std::size(kSANITY) == result[jss::result][jss::transactions].size()); + BEAST_EXPECT(std::size(kSanity) == result[jss::result][jss::transactions].size()); json::Value const& txs{result[jss::result][jss::transactions]}; - for (unsigned int index = 0; index < std::size(kSANITY); ++index) + for (unsigned int index = 0; index < std::size(kSanity); ++index) { - checkSanity(txs[index], kSANITY[index]); + checkSanity(txs[index], kSanity[index]); } } @@ -821,7 +821,7 @@ class AccountTx_test : public beast::unit_test::Suite using namespace std::chrono_literals; auto cfg = makeConfig(); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env(*this, std::move(cfg)); Account const alice{"alice"}; @@ -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..83f7b64b4b 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'."); @@ -1545,7 +1548,7 @@ public: auto usd = gw["USD"]; - for (auto i = 0; i <= RPC::Tuning::kBOOK_OFFERS.rmax; i++) + for (auto i = 0; i <= RPC::Tuning::kBookOffers.rmax; i++) env(offer(gw, XRP(50 + (1 * i)), usd(1.0 + (0.1 * i)))); if (asAdmin) @@ -1562,17 +1565,15 @@ public: BEAST_EXPECT(jrr[jss::offers].size() == (asAdmin ? 1u : 0u)); // NOTE - a marker field is not returned for this method - jvParams[jss::limit] = RPC::Tuning::kBOOK_OFFERS.rmax + 1; + jvParams[jss::limit] = RPC::Tuning::kBookOffers.rmax + 1; jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr[jss::offers].isArray()); - BEAST_EXPECT( - jrr[jss::offers].size() == (asAdmin ? RPC::Tuning::kBOOK_OFFERS.rmax + 1 : 0u)); + BEAST_EXPECT(jrr[jss::offers].size() == (asAdmin ? RPC::Tuning::kBookOffers.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( - jrr[jss::offers].size() == (asAdmin ? RPC::Tuning::kBOOK_OFFERS.rDefault : 0u)); + BEAST_EXPECT(jrr[jss::offers].size() == (asAdmin ? RPC::Tuning::kBookOffers.rDefault : 0u)); } void @@ -1592,7 +1593,7 @@ public: auto const carol = permDex.carol; auto const domainID = permDex.domainID; auto const gw = permDex.gw; - auto const usd = permDex.USD; + auto const usd = permDex.usd; auto wsc = makeWSClient(env.app().config()); @@ -1610,8 +1611,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 +1638,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 +1665,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 +1684,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"; @@ -1715,7 +1718,7 @@ public: auto const carol = permDex.carol; auto const domainID = permDex.domainID; auto const gw = permDex.gw; - auto const usd = permDex.USD; + auto const usd = permDex.usd; auto wsc = makeWSClient(env.app().config()); @@ -1733,8 +1736,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 +1763,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 +1790,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 +1814,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..ca5df7102e 100644 --- a/src/test/rpc/DeliveredAmount_test.cpp +++ b/src/test/rpc/DeliveredAmount_test.cpp @@ -40,7 +40,7 @@ class CheckDeliveredAmount int numExpectedNotSet_ = 0; // Increment one of the expected numExpected{Available_, Unavailable_, - // NotSet_} values. Which value to kINCREMENT depends on: 1) If the ledger is + // NotSet_} values. Which value to kIncrement depends on: 1) If the ledger is // before or after the switch time 2) If the tx is a partial payment 3) If // the payment is successful or not void @@ -206,7 +206,7 @@ class DeliveredAmount_test : public beast::unit_test::Suite for (bool const afterSwitchTime : {true, false}) { auto cfg = envconfig(); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env(*this, std::move(cfg)); env.fund(XRP(10000), alice, bob, carol, gw); env.trust(usd(1000), alice, bob, carol); @@ -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())); @@ -297,7 +297,7 @@ class DeliveredAmount_test : public beast::unit_test::Suite for (bool const afterSwitchTime : {true, false}) { auto cfg = envconfig(); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env(*this, std::move(cfg)); env.fund(XRP(10000), alice, bob, carol, gw); env.trust(usd(1000), alice, bob, carol); @@ -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..89053557a7 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()); @@ -415,7 +415,7 @@ public: } { - static std::vector const kCRED_IDS = { + static std::vector const kCredIds = { "18004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4", "28004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4", "38004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4", @@ -426,15 +426,15 @@ public: "88004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4", "98004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4", }; - assert(kCRED_IDS.size() > kMAX_CREDENTIALS_ARRAY_SIZE); + assert(kCredIds.size() > kMaxCredentialsArraySize); testcase("deposit_authorized too long credentials"); auto const jv = env.rpc( "json", "deposit_authorized", - depositAuthArgs(alice, becky, "validated", kCRED_IDS).toStyledString()); + depositAuthArgs(alice, becky, "validated", kCredIds).toStyledString()); checkCredentialsResponse( - jv[jss::result], alice, becky, false, kCRED_IDS, "invalidParams"); + jv[jss::result], alice, becky, false, kCredIds, "invalidParams"); } { diff --git a/src/test/rpc/Feature_test.cpp b/src/test/rpc/Feature_test.cpp index 3eedc5fa14..d899b6dfd9 100644 --- a/src/test/rpc/Feature_test.cpp +++ b/src/test/rpc/Feature_test.cpp @@ -208,35 +208,35 @@ class Feature_test : public beast::unit_test::Suite BEAST_EXPECT(jrr[jss::error_message] == "Feature unknown or invalid."); // Test feature name size checks - constexpr auto kOK63_NAME = [] { + static constexpr auto kOK63Name = [] { return "123456789012345678901234567890123456789012345678901234567890123"; }; - static_assert(validFeatureNameSize(kOK63_NAME)); + static_assert(validFeatureNameSize(kOK63Name)); - constexpr auto kBAD64_NAME = [] { + static constexpr auto kBaD64Name = [] { return "1234567890123456789012345678901234567890123456789012345678901234"; }; - static_assert(!validFeatureNameSize(kBAD64_NAME)); + static_assert(!validFeatureNameSize(kBaD64Name)); - constexpr auto kOK31_NAME = [] { return "1234567890123456789012345678901"; }; - static_assert(validFeatureNameSize(kOK31_NAME)); + static constexpr auto kOK31Name = [] { return "1234567890123456789012345678901"; }; + static_assert(validFeatureNameSize(kOK31Name)); - constexpr auto kBAD32_NAME = [] { return "12345678901234567890123456789012"; }; - static_assert(!validFeatureNameSize(kBAD32_NAME)); + static constexpr auto kBaD32Name = [] { return "12345678901234567890123456789012"; }; + static_assert(!validFeatureNameSize(kBaD32Name)); - constexpr auto kOK33_NAME = [] { return "123456789012345678901234567890123"; }; - static_assert(validFeatureNameSize(kOK33_NAME)); + static constexpr auto kOK33Name = [] { return "123456789012345678901234567890123"; }; + static_assert(validFeatureNameSize(kOK33Name)); // Test feature character set checks - constexpr auto kOK_NAME = [] { return "AMM_123"; }; - static_assert(validFeatureName(kOK_NAME)); + static constexpr auto kOkName = [] { return "AMM_123"; }; + static_assert(validFeatureName(kOkName)); // First character is Greek Capital Alpha, visually confusable with ASCII 'A' - constexpr auto kBAD_NAME = [] { return "ΑMM_123"; }; - static_assert(!validFeatureName(kBAD_NAME)); + static constexpr auto kBadName = [] { return "ΑMM_123"; }; + static_assert(!validFeatureName(kBadName)); - constexpr auto kBAD_EMOJI = [] { return "🔥"; }; - static_assert(!validFeatureName(kBAD_EMOJI)); + static constexpr auto kBadEmoji = [] { return "🔥"; }; + static_assert(!validFeatureName(kBadEmoji)); } void @@ -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]; @@ -474,40 +474,40 @@ class Feature_test : public beast::unit_test::Suite using namespace test::jtx; Env env{*this, FeatureBitset{featurePriceOracle}}; - constexpr char const* kFEATURE_NAME = "fixAMMOverflowOffer"; + static constexpr char const* kFeatureName = "fixAMMOverflowOffer"; - auto jrr = env.rpc("feature", kFEATURE_NAME)[jss::result]; + auto jrr = env.rpc("feature", kFeatureName)[jss::result]; if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status")) return; jrr.removeMember(jss::status); if (!BEAST_EXPECT(jrr.size() == 1)) return; auto feature = *(jrr.begin()); - BEAST_EXPECTS(feature[jss::name] == kFEATURE_NAME, "name"); + BEAST_EXPECTS(feature[jss::name] == kFeatureName, "name"); BEAST_EXPECTS(feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(), "vetoed"); - jrr = env.rpc("feature", kFEATURE_NAME, "reject")[jss::result]; + jrr = env.rpc("feature", kFeatureName, "reject")[jss::result]; if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status")) return; jrr.removeMember(jss::status); if (!BEAST_EXPECT(jrr.size() == 1)) return; feature = *(jrr.begin()); - BEAST_EXPECTS(feature[jss::name] == kFEATURE_NAME, "name"); + BEAST_EXPECTS(feature[jss::name] == kFeatureName, "name"); BEAST_EXPECTS(feature[jss::vetoed].isBool() && feature[jss::vetoed].asBool(), "vetoed"); - jrr = env.rpc("feature", kFEATURE_NAME, "accept")[jss::result]; + jrr = env.rpc("feature", kFeatureName, "accept")[jss::result]; if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status")) return; jrr.removeMember(jss::status); if (!BEAST_EXPECT(jrr.size() == 1)) return; feature = *(jrr.begin()); - BEAST_EXPECTS(feature[jss::name] == kFEATURE_NAME, "name"); + BEAST_EXPECTS(feature[jss::name] == kFeatureName, "name"); BEAST_EXPECTS(feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(), "vetoed"); // anything other than accept or reject is an error - jrr = env.rpc("feature", kFEATURE_NAME, "maybe"); + jrr = env.rpc("feature", kFeatureName, "maybe"); BEAST_EXPECT(jrr[jss::error] == "invalidParams"); BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters."); } diff --git a/src/test/rpc/GatewayBalances_test.cpp b/src/test/rpc/GatewayBalances_test.cpp index 4f23db7b66..106b9b5f1a 100644 --- a/src/test/rpc/GatewayBalances_test.cpp +++ b/src/test/rpc/GatewayBalances_test.cpp @@ -190,7 +190,7 @@ public: auto usd = alice["USD"]; // The largest valid STAmount of USD: - STAmount const maxUSD(usd, STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET); + STAmount const maxUSD(usd, STAmount::kMaxValue, STAmount::kMaxOffset); // Create a hotwallet Account const hw{"hw"}; @@ -259,7 +259,7 @@ public: // Bob creates an escrow of MPT to Alice. auto const MPT = mpt["MPT"]; // NOLINT(readability-identifier-naming) - env(escrow::create(bob, alice, MPT(100)), escrow::kFINISH_TIME(env.now() + 10s)); + env(escrow::create(bob, alice, MPT(100)), escrow::kFinishTime(env.now() + 10s)); env.close(); // Query gateway_balances for Bob. diff --git a/src/test/rpc/GetAggregatePrice_test.cpp b/src/test/rpc/GetAggregatePrice_test.cpp index 418b36d703..1de08da205 100644 --- a/src/test/rpc/GetAggregatePrice_test.cpp +++ b/src/test/rpc/GetAggregatePrice_test.cpp @@ -25,22 +25,22 @@ public: using namespace jtx; Account const owner{"owner"}; Account const some{"some"}; - static OraclesData kORACLES = {{owner, 1}}; + static OraclesData kOracles = {{owner, 1}}; { Env env(*this); auto const baseFee = env.current()->fees().base; // missing base_asset - auto ret = Oracle::aggregatePrice(env, std::nullopt, "USD", kORACLES); + auto ret = Oracle::aggregatePrice(env, std::nullopt, "USD", kOracles); BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'base_asset'."); // missing quote_asset - ret = Oracle::aggregatePrice(env, "XRP", std::nullopt, kORACLES); + ret = Oracle::aggregatePrice(env, "XRP", std::nullopt, kOracles); BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'quote_asset'."); // invalid base_asset, quote_asset std::vector const invalidAsset = { - kNONE_TAG, + kNoneTag, 1, -1, 1.2, @@ -56,11 +56,11 @@ public: "012345678901234567890123456789012345678G"}; for (auto const& v : invalidAsset) { - ret = Oracle::aggregatePrice(env, "USD", v, kORACLES); + ret = Oracle::aggregatePrice(env, "USD", v, kOracles); BEAST_EXPECT(ret[jss::error].asString() == "invalidParams"); - ret = Oracle::aggregatePrice(env, v, "USD", kORACLES); + ret = Oracle::aggregatePrice(env, v, "USD", kOracles); BEAST_EXPECT(ret[jss::error].asString() == "invalidParams"); - ret = Oracle::aggregatePrice(env, v, v, kORACLES); + ret = Oracle::aggregatePrice(env, v, v, kOracles); BEAST_EXPECT(ret[jss::error].asString() == "invalidParams"); } @@ -73,7 +73,7 @@ public: BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed"); // no token pairs found - ret = Oracle::aggregatePrice(env, "YAN", "USD", kORACLES); + ret = Oracle::aggregatePrice(env, "YAN", "USD", kOracles); BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound"); // invalid oracle document id @@ -81,7 +81,7 @@ public: ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, 2}}}); BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound"); // invalid values - std::vector const invalidDocument = {kNONE_TAG, 1.2, -1, "", "none", "1.2"}; + std::vector const invalidDocument = {kNoneTag, 1.2, -1, "", "none", "1.2"}; for (auto const& v : invalidDocument) { ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, v}}}); @@ -111,8 +111,7 @@ public: BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound"); // invalid trim value - std::vector const invalidTrim = { - kNONE_TAG, 0, 26, -1, 1.2, "", "none", "1.2"}; + std::vector const invalidTrim = {kNoneTag, 0, 26, -1, 1.2, "", "none", "1.2"}; for (auto const& v : invalidTrim) { ret = @@ -121,7 +120,7 @@ public: } // invalid time threshold value - std::vector const invalidTime = {kNONE_TAG, -1, 1.2, "", "none", "1.2"}; + std::vector const invalidTime = {kNoneTag, -1, 1.2, "", "none", "1.2"}; for (auto const& v : invalidTime) { ret = Oracle::aggregatePrice( diff --git a/src/test/rpc/JSONRPC_test.cpp b/src/test/rpc/JSONRPC_test.cpp index 6c45815555..1f24d229f2 100644 --- a/src/test/rpc/JSONRPC_test.cpp +++ b/src/test/rpc/JSONRPC_test.cpp @@ -49,7 +49,7 @@ struct TxnTestData // 3. sign_for, and // 4. submit_multisigned. // The JSON is not valid for all of these interfaces, but it should - // crash kNONE of them, and should provide reliable error messages. + // crash kNone of them, and should provide reliable error messages. // // The expMsg array contains the expected error string for the above cases. std::array const expMsg; @@ -72,7 +72,7 @@ struct TxnTestData operator=(TxnTestData&&) = delete; }; -static constexpr TxnTestData kTXN_TEST_ARRAY[] = { +static constexpr TxnTestData kTxnTestArray[] = { {"Minimal payment, no Amount only DeliverMax", __LINE__, @@ -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)); } } @@ -2697,7 +2697,7 @@ public: testcase("autofill NetworkID"); using namespace test::jtx; Env env{*this, envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = 1025; + cfg->networkId = 1025; return cfg; })}; @@ -2743,7 +2743,7 @@ public: // "c" (phantom signer) is rPcNzota6B8YBokhYtcTNqQVCngtbnWfux. Env env(*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; })); env.fund(XRP(100000), a, ed, g); @@ -2777,26 +2777,26 @@ public: using TestStuff = std::tuple; - static TestStuff const kTEST_FUNCS[] = { + static TestStuff const kTestFuncs[] = { TestStuff{transactionSign, nullptr, "sign", 0}, TestStuff{nullptr, transactionSubmit, "submit", 1}, TestStuff{transactionSignFor, nullptr, "sign_for", 2}, TestStuff{nullptr, transactionSubmitMultiSigned, "submit_multisigned", 3}}; - for (auto testFunc : kTEST_FUNCS) + for (auto testFunc : kTestFuncs) { // For each JSON test. - for (auto const& txnTest : kTXN_TEST_ARRAY) + for (auto const& txnTest : kTxnTestArray) { json::Value req; json::Reader().parse(txnTest.json, req); if (RPC::containsError(req)) Throw("Internal JSONRPC_test error. Bad test JSON."); - static Role const kTESTED_ROLES[] = { + static Role const kTestedRoles[] = { Role::GUEST, Role::USER, Role::ADMIN, Role::FORBID}; - for (Role const testRole : kTESTED_ROLES) + for (Role const testRole : kTestedRoles) { json::Value result; auto const signFn = get<0>(testFunc); diff --git a/src/test/rpc/KeyGeneration_test.cpp b/src/test/rpc/KeyGeneration_test.cpp index 0195657d7f..aafe6f75a5 100644 --- a/src/test/rpc/KeyGeneration_test.cpp +++ b/src/test/rpc/KeyGeneration_test.cpp @@ -19,15 +19,15 @@ namespace xrpl::RPC { struct KeyStrings { - char const* account_id; - char const* master_key; - char const* master_seed; - char const* master_seed_hex; - char const* public_key; - char const* public_key_hex; - char const* secret_key_hex; + char const* accountId; + char const* masterKey; + char const* masterSeed; + char const* masterSeedHex; + char const* publicKey; + char const* publicKeyHex; + char const* secretKeyHex; char const* passphrase; - char const* passphrase_warning; + char const* passphraseWarning; }; namespace common { @@ -37,46 +37,46 @@ static char const* gMasterSeed = "snMwVWs2hZzfDUF3p2tHZ3EgmyhFs"; static char const* gMasterSeedHex = "BE6A670A19B209E112146D0A7ED2AAD7"; } // namespace common -static KeyStrings const kSECP256K1_STRINGS = { - .account_id = "r4Vtj2jrfmTVZGfSP3gH9hQPMqFPQFin8f", - .master_key = common::gMasterKey, - .master_seed = common::gMasterSeed, - .master_seed_hex = common::gMasterSeedHex, - .public_key = "aBQxK2YFNqzmAaXNczYcjqDjfiKkLsJUizsr1UBf44RCF8FHdrmX", - .public_key_hex = "038AAE247B2344B1837FBED8F57389C8C11774510A3F7D784F2A09F0CB6843236C", - .secret_key_hex = "1949ECD889EA71324BC7A30C8E81F4E93CB73EE19D59E9082111E78CC3DDABC2", +static KeyStrings const kSecP256K1Strings = { + .accountId = "r4Vtj2jrfmTVZGfSP3gH9hQPMqFPQFin8f", + .masterKey = common::gMasterKey, + .masterSeed = common::gMasterSeed, + .masterSeedHex = common::gMasterSeedHex, + .publicKey = "aBQxK2YFNqzmAaXNczYcjqDjfiKkLsJUizsr1UBf44RCF8FHdrmX", + .publicKeyHex = "038AAE247B2344B1837FBED8F57389C8C11774510A3F7D784F2A09F0CB6843236C", + .secretKeyHex = "1949ECD889EA71324BC7A30C8E81F4E93CB73EE19D59E9082111E78CC3DDABC2", .passphrase = common::gPassphrase, - .passphrase_warning = + .passphraseWarning = "This wallet was generated using a user-supplied " "passphrase that has low entropy and is vulnerable " "to brute-force attacks.", }; -static KeyStrings const kED25519_STRINGS = { - .account_id = "r4qV6xTXerqaZav3MJfSY79ynmc1BSBev1", - .master_key = common::gMasterKey, - .master_seed = common::gMasterSeed, - .master_seed_hex = common::gMasterSeedHex, - .public_key = "aKEQmgLMyZPMruJFejUuedp169LgW6DbJt1rej1DJ5hWUMH4pHJ7", - .public_key_hex = "ED54C3F5BEDA8BD588B203D23A27398FAD9D20F88A974007D6994659CD7273FE1D", - .secret_key_hex = "77AAED2698D56D6676323629160F4EEF21CFD9EE3D0745CC78FA291461F98278", +static KeyStrings const kED25519Strings = { + .accountId = "r4qV6xTXerqaZav3MJfSY79ynmc1BSBev1", + .masterKey = common::gMasterKey, + .masterSeed = common::gMasterSeed, + .masterSeedHex = common::gMasterSeedHex, + .publicKey = "aKEQmgLMyZPMruJFejUuedp169LgW6DbJt1rej1DJ5hWUMH4pHJ7", + .publicKeyHex = "ED54C3F5BEDA8BD588B203D23A27398FAD9D20F88A974007D6994659CD7273FE1D", + .secretKeyHex = "77AAED2698D56D6676323629160F4EEF21CFD9EE3D0745CC78FA291461F98278", .passphrase = common::gPassphrase, - .passphrase_warning = + .passphraseWarning = "This wallet was generated using a user-supplied " "passphrase that has low entropy and is vulnerable " "to brute-force attacks.", }; -static KeyStrings const kSTRONG_BRAIN_STRINGS = { - .account_id = "rBcvXmNb7KPkNdMkpckdWPpbvkWgcV3nir", - .master_key = "TED AVON CAVE HOUR BRAG JEFF RIFT NEAL TOLD FAT SEW SAN", - .master_seed = "shKdhWka8hS7Es3bpctCZXBiAwfUN", - .master_seed_hex = "74BA8389B44F98CF41E795CD91F9C93F", - .public_key = "aBRL2sqVuzrsM6zikPB4v8UBHGn1aKkrsxhYEffhcQxB2LKyywE5", - .public_key_hex = "03BD334FB9E06C58D69603E9922686528B18A754BC2F2E1ADA095FFE67DE952C64", - .secret_key_hex = "84262FB16AA25BE407174C7EDAB531220C30FA4D8A28AA9D564673FB3D34502C", +static KeyStrings const kStrongBrainStrings = { + .accountId = "rBcvXmNb7KPkNdMkpckdWPpbvkWgcV3nir", + .masterKey = "TED AVON CAVE HOUR BRAG JEFF RIFT NEAL TOLD FAT SEW SAN", + .masterSeed = "shKdhWka8hS7Es3bpctCZXBiAwfUN", + .masterSeedHex = "74BA8389B44F98CF41E795CD91F9C93F", + .publicKey = "aBRL2sqVuzrsM6zikPB4v8UBHGn1aKkrsxhYEffhcQxB2LKyywE5", + .publicKeyHex = "03BD334FB9E06C58D69603E9922686528B18A754BC2F2E1ADA095FFE67DE952C64", + .secretKeyHex = "84262FB16AA25BE407174C7EDAB531220C30FA4D8A28AA9D564673FB3D34502C", .passphrase = "A4yKIRGdzrw0YQ$2%TFKYG9HP*&ok^!sy7E@RwICs", - .passphrase_warning = + .passphraseWarning = "This wallet was generated using a user-supplied " "passphrase. It may be vulnerable to brute-force " "attacks.", @@ -120,11 +120,11 @@ public: json::Value result = walletPropose(params); BEAST_EXPECT(!containsError(result)); - expectEquals(result[jss::account_id], s.account_id); - expectEquals(result[jss::master_seed], s.master_seed); - expectEquals(result[jss::master_seed_hex], s.master_seed_hex); - expectEquals(result[jss::public_key], s.public_key); - expectEquals(result[jss::public_key_hex], s.public_key_hex); + expectEquals(result[jss::account_id], s.accountId); + expectEquals(result[jss::master_seed], s.masterSeed); + expectEquals(result[jss::master_seed_hex], s.masterSeedHex); + expectEquals(result[jss::public_key], s.publicKey); + expectEquals(result[jss::public_key_hex], s.publicKeyHex); expectEquals( result[jss::key_type], params.isMember(jss::key_type) ? params[jss::key_type] : "secp256k1"); @@ -139,7 +139,7 @@ public: json::Value params; if (keyType) params[jss::key_type] = *keyType; - params[jss::seed] = strings.master_seed; + params[jss::seed] = strings.masterSeed; auto const wallet = testSecretWallet(params, strings); BEAST_EXPECT(!wallet.isMember(jss::warning)); @@ -153,7 +153,7 @@ public: json::Value params; if (keyType) params[jss::key_type] = *keyType; - params[jss::seed_hex] = strings.master_seed_hex; + params[jss::seed_hex] = strings.masterSeedHex; auto const wallet = testSecretWallet(params, strings); BEAST_EXPECT(!wallet.isMember(jss::warning)); @@ -173,7 +173,7 @@ public: auto const wallet = testSecretWallet(params, strings); if (value == strings.passphrase) { - BEAST_EXPECT(wallet[jss::warning] == strings.passphrase_warning); + BEAST_EXPECT(wallet[jss::warning] == strings.passphraseWarning); } else { @@ -187,9 +187,9 @@ public: testcase("passphrase"); testLegacyPassphrase(strings.passphrase, keyType, strings); - testLegacyPassphrase(strings.master_key, keyType, strings); - testLegacyPassphrase(strings.master_seed, keyType, strings); - testLegacyPassphrase(strings.master_seed_hex, keyType, strings); + testLegacyPassphrase(strings.masterKey, keyType, strings); + testLegacyPassphrase(strings.masterSeed, keyType, strings); + testLegacyPassphrase(strings.masterSeedHex, keyType, strings); } void @@ -205,8 +205,8 @@ public: json::Value params; if (keyType) params[jss::key_type] = *keyType; - params[jss::seed] = strings.master_seed; - params[jss::seed_hex] = strings.master_seed_hex; + params[jss::seed] = strings.masterSeed; + params[jss::seed_hex] = strings.masterSeedHex; // Secret fields are mutually exclusive. BEAST_EXPECT(containsError(walletPropose(params))); @@ -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)); @@ -294,7 +294,7 @@ public: { testcase("keypairForSignature - " + (keyType ? *keyType : "no key_type")); - auto const publicKey = parseBase58(TokenType::AccountPublic, strings.public_key); + auto const publicKey = parseBase58(TokenType::AccountPublic, strings.publicKey); BEAST_EXPECT(publicKey); if (!keyType) @@ -302,7 +302,7 @@ public: { json::Value params; json::Value error; - params[jss::secret] = strings.master_seed; + params[jss::secret] = strings.masterSeed; auto ret = keypairForSignature(params, error); BEAST_EXPECT(!containsError(error)); @@ -316,7 +316,7 @@ public: { json::Value params; json::Value error; - params[jss::secret] = strings.master_seed_hex; + params[jss::secret] = strings.masterSeedHex; auto ret = keypairForSignature(params, error); BEAST_EXPECT(!containsError(error)); @@ -330,7 +330,7 @@ public: { json::Value params; json::Value error; - params[jss::secret] = strings.master_key; + params[jss::secret] = strings.masterKey; auto ret = keypairForSignature(params, error); BEAST_EXPECT(!containsError(error)); @@ -349,7 +349,7 @@ public: json::Value error; params[jss::key_type] = *keyType; - params[jss::seed] = strings.master_seed; + params[jss::seed] = strings.masterSeed; auto ret = keypairForSignature(params, error); BEAST_EXPECT(!containsError(error)); @@ -365,7 +365,7 @@ public: json::Value error; params[jss::key_type] = *keyType; - params[jss::seed_hex] = strings.master_seed_hex; + params[jss::seed_hex] = strings.masterSeedHex; auto ret = keypairForSignature(params, error); BEAST_EXPECT(!containsError(error)); @@ -381,7 +381,7 @@ public: json::Value error; params[jss::key_type] = *keyType; - params[jss::passphrase] = strings.master_key; + params[jss::passphrase] = strings.masterKey; auto ret = keypairForSignature(params, error); BEAST_EXPECT(!containsError(error)); @@ -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)); @@ -781,16 +781,16 @@ public: void run() override { - testKeyType(std::nullopt, kSECP256K1_STRINGS); - testKeyType(std::string("secp256k1"), kSECP256K1_STRINGS); - testKeyType(std::string("ed25519"), kED25519_STRINGS); - testKeyType(std::string("secp256k1"), kSTRONG_BRAIN_STRINGS); + testKeyType(std::nullopt, kSecP256K1Strings); + testKeyType(std::string("secp256k1"), kSecP256K1Strings); + testKeyType(std::string("ed25519"), kED25519Strings); + testKeyType(std::string("secp256k1"), kStrongBrainStrings); testBadInput(); - testKeypairForSignature(std::nullopt, kSECP256K1_STRINGS); - testKeypairForSignature(std::string("secp256k1"), kSECP256K1_STRINGS); - testKeypairForSignature(std::string("ed25519"), kED25519_STRINGS); - testKeypairForSignature(std::string("secp256k1"), kSTRONG_BRAIN_STRINGS); + testKeypairForSignature(std::nullopt, kSecP256K1Strings); + testKeypairForSignature(std::string("secp256k1"), kSecP256K1Strings); + testKeypairForSignature(std::string("ed25519"), kED25519Strings); + testKeypairForSignature(std::string("secp256k1"), kStrongBrainStrings); testXrplLibEd25519(); diff --git a/src/test/rpc/LedgerClosed_test.cpp b/src/test/rpc/LedgerClosed_test.cpp index 81919e04d0..f02d23030d 100644 --- a/src/test/rpc/LedgerClosed_test.cpp +++ b/src/test/rpc/LedgerClosed_test.cpp @@ -23,7 +23,7 @@ public: // This test relies on ledger hash so must lock it to fee 10. auto p = envconfig(); - p->FEES.reference_fee = 10; + p->fees.referenceFee = 10; Env env{*this, std::move(p), FeatureBitset{}}; Account const alice{"alice"}; env.fund(XRP(10000), alice); 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..d231a2d4a0 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()); } @@ -180,19 +180,19 @@ class LedgerEntry_test : public beast::unit_test::Suite static std::vector getBadValues(FieldType fieldType) { - static json::Value const kINJECT_OBJECT = []() { - json::Value obj(json::ObjectValue); + static json::Value const kInjectObject = []() { + 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); + static json::Value const kInjectArray = []() { + json::Value arr(json::ValueType::Array); arr[0u] = "rhigTLJJyXXSRUyRCQtqi1NoAZZzZnS4KU"; arr[1u] = "validated"; return arr; }(); - static std::array const kALL_BAD_VALUES = { + static std::array const kAllBadValues = { "", // 0 true, // 1 1, // 2 @@ -210,61 +210,61 @@ 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 + kInjectObject, // 19 + kInjectArray // 20 }; auto remove = [&](std::vector indices) -> std::vector { std::unordered_set const indexSet(indices.begin(), indices.end()); std::vector values; - values.reserve(kALL_BAD_VALUES.size() - indexSet.size()); - for (std::size_t i = 0; i < kALL_BAD_VALUES.size(); ++i) + values.reserve(kAllBadValues.size() - indexSet.size()); + for (std::size_t i = 0; i < kAllBadValues.size(); ++i) { if (!indexSet.contains(i)) { - values.push_back(kALL_BAD_VALUES[i]); + values.push_back(kAllBadValues[i]); } } return values; }; - static auto const& kBAD_ACCOUNT_VALUES = remove({12}); - static auto const& kBAD_ARRAY_VALUES = remove({17, 20}); - static auto const& kBAD_BLOB_VALUES = remove({3, 7, 8, 16}); - static auto const& kBAD_CURRENCY_VALUES = remove({14}); - static auto const& kBAD_HASH_VALUES = remove({2, 3, 7, 8, 16}); - static auto const& kBAD_FIXED_HASH_VALUES = remove({1, 2, 3, 4, 7, 8, 16}); - static auto const& kBAD_INDEX_VALUES = remove({12, 16, 18, 19}); - static auto const& kBAD_U_INT32_VALUES = remove({2, 3}); - static auto const& kBAD_U_INT64_VALUES = remove({2, 3}); - static auto const& kBAD_ISSUE_VALUES = remove({}); + static auto const& kBadAccountValues = remove({12}); + static auto const& kBadArrayValues = remove({17, 20}); + static auto const& kBadBlobValues = remove({3, 7, 8, 16}); + static auto const& kBadCurrencyValues = remove({14}); + static auto const& kBadHashValues = remove({2, 3, 7, 8, 16}); + static auto const& kBadFixedHashValues = remove({1, 2, 3, 4, 7, 8, 16}); + static auto const& kBadIndexValues = remove({12, 16, 18, 19}); + static auto const& kBadUInt32Values = remove({2, 3}); + static auto const& kBadUInt64Values = remove({2, 3}); + static auto const& kBadIssueValues = remove({}); switch (fieldType) { case FieldType::AccountField: - return kBAD_ACCOUNT_VALUES; + return kBadAccountValues; case FieldType::ArrayField: case FieldType::TwoAccountArrayField: - return kBAD_ARRAY_VALUES; + return kBadArrayValues; case FieldType::BlobField: - return kBAD_BLOB_VALUES; + return kBadBlobValues; case FieldType::CurrencyField: - return kBAD_CURRENCY_VALUES; + return kBadCurrencyValues; case FieldType::HashField: - return kBAD_HASH_VALUES; + return kBadHashValues; case FieldType::HashOrObjectField: - return kBAD_INDEX_VALUES; + return kBadIndexValues; case FieldType::FixedHashField: - return kBAD_FIXED_HASH_VALUES; + return kBadFixedHashValues; case FieldType::AssetField: - return kBAD_ISSUE_VALUES; + return kBadIssueValues; case FieldType::UInt32Field: - return kBAD_U_INT32_VALUES; + return kBadUInt32Values; case FieldType::UInt64Field: - return kBAD_U_INT64_VALUES; + return kBadUInt64Values; default: Throw( "unknown type " + std::to_string(static_cast(fieldType))); @@ -274,14 +274,14 @@ class LedgerEntry_test : public beast::unit_test::Suite static json::Value getCorrectValue(json::StaticString fieldName) { - static json::Value const kTWO_ACCOUNT_ARRAY = []() { - json::Value arr(json::ArrayValue); + static json::Value const kTwoAccountArray = []() { + 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); + static json::Value const kIssueObject = []() { + 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: @@ -301,12 +301,12 @@ class LedgerEntry_test : public beast::unit_test::Suite return "5233D68B4D44388F98559DE42903767803EFA7C1F8D01413FC16EE6" "B01403D6D"; case FieldType::AssetField: - return kISSUE_OBJECT; + return kIssueObject; case FieldType::HashOrObjectField: return "5233D68B4D44388F98559DE42903767803EFA7C1F8D01413FC16EE6" "B01403D6D"; case FieldType::TwoAccountArrayField: - return kTWO_ACCOUNT_ARRAY; + return kTwoAccountArray; case FieldType::UInt32Field: return 1; case FieldType::UInt64Field: @@ -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"; @@ -555,7 +555,7 @@ class LedgerEntry_test : public beast::unit_test::Suite using namespace test::jtx; auto cfg = envconfig(); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env{*this, std::move(cfg)}; Account const alice{"alice"}; @@ -584,7 +584,7 @@ class LedgerEntry_test : public beast::unit_test::Suite accountRootIndex = jrr[jss::index].asString(); } { - constexpr char kALICE_ACCT_ROOT_BINARY[]{ + static constexpr char kAliceAcctRootBinary[]{ "1100612200800000240000000425000000032D00000000559CE54C3B934E4" "73A995B477E92EC229F99CED5B62BF4D2ACE4DC42719103AE2F6240000002" "540BE4008114AE123A8556F3CF91154711376AFB0F894F832B3D"}; @@ -597,7 +597,7 @@ class LedgerEntry_test : public beast::unit_test::Suite json::Value const jrr = env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result]; BEAST_EXPECT(jrr.isMember(jss::node_binary)); - BEAST_EXPECT(jrr[jss::node_binary] == kALICE_ACCT_ROOT_BINARY); + BEAST_EXPECT(jrr[jss::node_binary] == kAliceAcctRootBinary); } { // Request alice's account root using the index. @@ -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( @@ -1232,19 +1232,18 @@ class LedgerEntry_test : public beast::unit_test::Suite { // Failed, authorized_credentials is too long - static std::array const kCRED_TYPES = { + static std::array const kCredTypes = { "cred1", "cred2", "cred3", "cred4", "cred5", "cred6", "cred7", "cred8", "cred9"}; - static_assert( - sizeof(kCRED_TYPES) / sizeof(kCRED_TYPES[0]) > kMAX_CREDENTIALS_ARRAY_SIZE); + static_assert(sizeof(kCredTypes) / sizeof(kCredTypes[0]) > kMaxCredentialsArraySize); 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]); - for (auto cred : kCRED_TYPES) + for (auto cred : kCredTypes) { json::Value jo; jo[jss::issuer] = issuer.human(); @@ -1305,7 +1304,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 +1313,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 +1323,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 +1334,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 +1353,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 +1368,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 +1383,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 +1395,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 +1424,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 +1438,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 +1644,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 +1693,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 +1757,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 +1781,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 +1797,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 +1815,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 +1834,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 +1853,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 +1919,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 +1931,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 +2128,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 +2140,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; @@ -2238,7 +2237,7 @@ class LedgerEntry_test : public beast::unit_test::Suite Account const bob{"bob"}; Env env{*this, envconfig([](auto cfg) { - cfg->START_UP = StartUpType::Fresh; + cfg->startUp = StartUpType::Fresh; return cfg; })}; @@ -2302,7 +2301,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)); @@ -2431,7 +2430,7 @@ class LedgerEntry_test : public beast::unit_test::Suite Account const bob{"bob"}; Env env{*this, envconfig([](auto cfg) { - cfg->START_UP = StartUpType::Fresh; + cfg->startUp = StartUpType::Fresh; return cfg; })}; @@ -2499,7 +2498,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 +2695,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))) { @@ -2763,7 +2763,7 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite, // swap door accounts and make sure we get an error value json::Value jvParams; // Sidechain door account is "master", not scDoor - jvParams[jss::bridge_account] = Account::kMASTER.human(); + jvParams[jss::bridge_account] = Account::kMaster.human(); jvParams[jss::bridge] = jvb; jvParams[jss::ledger_hash] = ledgerHash; json::Value const jrr = @@ -2868,7 +2868,7 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite, // send less than quorum of attestations (otherwise funds are // immediately transferred and no "claim" object is created) - size_t constexpr kNUM_ATTEST = 3; + static constexpr size_t kNumAttest = 3; auto attestations = createAccountAttestations( scAttester, jvb, @@ -2880,8 +2880,8 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite, 1, scCarol, signers, - kUT_XCHAIN_DEFAULT_NUM_SIGNERS); - for (size_t i = 0; i < kNUM_ATTEST; ++i) + kUtXchainDefaultNumSigners); + for (size_t i = 0; i < kNumAttest; ++i) { scEnv(attestations[i]); } @@ -2900,7 +2900,7 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite, auto r = jrr[jss::node]; BEAST_EXPECT(r.isMember(jss::Account)); - BEAST_EXPECT(r[jss::Account] == Account::kMASTER.human()); + BEAST_EXPECT(r[jss::Account] == Account::kMaster.human()); BEAST_EXPECT(r.isMember(sfXChainAccountCreateCount.jsonName)); BEAST_EXPECT(r[sfXChainAccountCreateCount.jsonName].asInt() == 1); @@ -2911,13 +2911,12 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite, BEAST_EXPECT(attest.size() == 3); BEAST_EXPECT( attest[json::Value::UInt(0)].isMember(sfXChainCreateAccountProofSig.jsonName)); - json::Value a[kNUM_ATTEST]; - for (size_t i = 0; i < kNUM_ATTEST; ++i) + json::Value a[kNumAttest]; + for (size_t i = 0; i < kNumAttest; ++i) { a[i] = attest[json::Value::UInt(0)][sfXChainCreateAccountProofSig.jsonName]; BEAST_EXPECT( - a[i].isMember(jss::Amount) && - a[i][jss::Amount].asInt() == 1000 * kDROP_PER_XRP); + a[i].isMember(jss::Amount) && a[i][jss::Amount].asInt() == 1000 * kDropPerXrp); BEAST_EXPECT( a[i].isMember(jss::Destination) && a[i][jss::Destination] == scCarol.human()); BEAST_EXPECT( @@ -2935,13 +2934,13 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite, a[i][sfWasLockingChainSend.jsonName] == 1); BEAST_EXPECT( a[i].isMember(sfSignatureReward.jsonName) && - a[i][sfSignatureReward.jsonName].asInt() == 1 * kDROP_PER_XRP); + a[i][sfSignatureReward.jsonName].asInt() == 1 * kDropPerXrp); } } // complete attestations quorum - CreateAccountClaimID should not be // present anymore - for (size_t i = kNUM_ATTEST; i < kUT_XCHAIN_DEFAULT_NUM_SIGNERS; ++i) + for (size_t i = kNumAttest; i < kUtXchainDefaultNumSigners; ++i) { scEnv(attestations[i]); } 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..f35dddffb1 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))) { @@ -267,7 +268,7 @@ class LedgerRPC_test : public beast::unit_test::Suite using namespace test::jtx; auto cfg = envconfig(); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env{*this, std::move(cfg), FeatureBitset{}}; // hashes requested below // assume no amendments env.fund(XRP(10000), "alice"); @@ -436,7 +437,7 @@ class LedgerRPC_test : public beast::unit_test::Suite return cfg; }); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env(*this, std::move(cfg)); json::Value jv; diff --git a/src/test/rpc/LedgerRequest_test.cpp b/src/test/rpc/LedgerRequest_test.cpp index 65c5a57712..4759256b96 100644 --- a/src/test/rpc/LedgerRequest_test.cpp +++ b/src/test/rpc/LedgerRequest_test.cpp @@ -20,12 +20,12 @@ namespace xrpl::RPC { class LedgerRequest_test : public beast::unit_test::Suite { - static constexpr char const* kHASH1 = + static constexpr char const* kHash1 = "3020EB9E7BE24EF7D7A060CB051583EC117384636D1781AFB5B87F3E348DA489"; - static constexpr char const* kACCOUNTHASH1 = + static constexpr char const* kAccountHash1 = "BD8A3D72CA73DDE887AD63666EC2BAD07875CBA997A102579B5B95ECDFFEAED8"; - static constexpr char const* kZEROHASH = + static constexpr char const* kZeroHASH = "0000000000000000000000000000000000000000000000000000000000000000"; public: @@ -149,7 +149,7 @@ public: using namespace test::jtx; auto cfg = envconfig(); - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; Env env{*this, std::move(cfg), FeatureBitset{}}; // the hashes being checked below // assume no amendments Account const gw{"gateway"}; @@ -173,32 +173,32 @@ public: BEAST_EXPECT(result[jss::ledger][jss::ledger_index] == "1"); BEAST_EXPECT(result[jss::ledger][jss::total_coins] == "100000000000000000"); BEAST_EXPECT(result[jss::ledger][jss::closed] == true); - BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHASH1); - BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kZEROHASH); - BEAST_EXPECT(result[jss::ledger][jss::account_hash] == kACCOUNTHASH1); - BEAST_EXPECT(result[jss::ledger][jss::transaction_hash] == kZEROHASH); + BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHash1); + BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kZeroHASH); + BEAST_EXPECT(result[jss::ledger][jss::account_hash] == kAccountHash1); + BEAST_EXPECT(result[jss::ledger][jss::transaction_hash] == kZeroHASH); result = env.rpc("ledger_request", "2")[jss::result]; - constexpr char const* kHASH2 = + static constexpr char const* kHash2 = "CCC3B3E88CCAC17F1BE6B4A648A55999411F19E3FE55EB721960EB0DF28EDDA5"; BEAST_EXPECT(result[jss::ledger][jss::ledger_index] == "2"); BEAST_EXPECT(result[jss::ledger][jss::total_coins] == "100000000000000000"); BEAST_EXPECT(result[jss::ledger][jss::closed] == true); - BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHASH2); - BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHASH1); + BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHash2); + BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHash1); BEAST_EXPECT( result[jss::ledger][jss::account_hash] == "3C834285F7F464FBE99AFEB84D354A968EB2CAA24523FF26797A973D906A3D29"); - BEAST_EXPECT(result[jss::ledger][jss::transaction_hash] == kZEROHASH); + BEAST_EXPECT(result[jss::ledger][jss::transaction_hash] == kZeroHASH); result = env.rpc("ledger_request", "3")[jss::result]; - constexpr char const* kHASH3 = + static constexpr char const* kHash3 = "9FFD8AE09190D5002FE4252A1B29EABCF40DABBCE3B42619C6BD0BE381D51103"; BEAST_EXPECT(result[jss::ledger][jss::ledger_index] == "3"); BEAST_EXPECT(result[jss::ledger][jss::total_coins] == "99999999999999980"); BEAST_EXPECT(result[jss::ledger][jss::closed] == true); - BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHASH3); - BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHASH2); + BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHash3); + BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHash2); BEAST_EXPECT( result[jss::ledger][jss::account_hash] == "35738B8517F37D08983AF6BC7DA483CCA9CF6B41B1FECB31A20028D78FE0BB22"); @@ -207,13 +207,13 @@ public: "CBD7F0948EBFA2241DE4EA627939A0FFEE6B80A90FE09C42C825DA546E9B73FF"); result = env.rpc("ledger_request", "4")[jss::result]; - constexpr char const* kHASH4 = + static constexpr char const* kHash4 = "7C9B614445517B8C6477E0AB10A35FFC1A23A34FEA41A91ECBDE884CC097C6E1"; BEAST_EXPECT(result[jss::ledger][jss::ledger_index] == "4"); BEAST_EXPECT(result[jss::ledger][jss::total_coins] == "99999999999999960"); BEAST_EXPECT(result[jss::ledger][jss::closed] == true); - BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHASH4); - BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHASH3); + BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHash4); + BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHash3); BEAST_EXPECT( result[jss::ledger][jss::account_hash] == "1EE701DD2A150205173E1EDE8D474DF6803EC95253DAAEE965B9D896CFC32A04"); @@ -222,13 +222,13 @@ public: "9BBDDBF926100DFFF364E16268F544B19F5B9BC6ECCBBC104F98D13FA9F3BC35"); result = env.rpc("ledger_request", "5")[jss::result]; - constexpr char const* kHASH5 = + static constexpr char const* kHash5 = "98885D02145CCE4AD2605F1809F17188DB2053B14ED399CAC985DD8E03DCA8C0"; BEAST_EXPECT(result[jss::ledger][jss::ledger_index] == "5"); BEAST_EXPECT(result[jss::ledger][jss::total_coins] == "99999999999999940"); BEAST_EXPECT(result[jss::ledger][jss::closed] == true); - BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHASH5); - BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHASH4); + BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHash5); + BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kHash4); BEAST_EXPECT( result[jss::ledger][jss::account_hash] == "41D64D64796468DEA7AE2A7282C0BB525D6FD7ABC29453C5E5BC6406E947CBCE"); @@ -301,8 +301,8 @@ public: using namespace test::jtx; using namespace std::chrono_literals; Env env{*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; - cfg->NODE_SIZE = 0; + cfg->fees.referenceFee = 10; + cfg->nodeSize = 0; return cfg; })}; Account const gw{"gateway"}; @@ -322,10 +322,10 @@ public: BEAST_EXPECT(result[jss::ledger][jss::ledger_index] == "1"); BEAST_EXPECT(result[jss::ledger][jss::total_coins] == "100000000000000000"); BEAST_EXPECT(result[jss::ledger][jss::closed] == true); - BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHASH1); - BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kZEROHASH); - BEAST_EXPECT(result[jss::ledger][jss::account_hash] == kACCOUNTHASH1); - BEAST_EXPECT(result[jss::ledger][jss::transaction_hash] == kZEROHASH); + BEAST_EXPECT(result[jss::ledger][jss::ledger_hash] == kHash1); + BEAST_EXPECT(result[jss::ledger][jss::parent_hash] == kZeroHASH); + BEAST_EXPECT(result[jss::ledger][jss::account_hash] == kAccountHash1); + BEAST_EXPECT(result[jss::ledger][jss::transaction_hash] == kZeroHASH); } void @@ -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..9c17d291a1 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,15 +293,15 @@ 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() > kWarningThreshold) { using ct = beast::AbstractClock; - c.entry().local_balance = - DecayingSample{steady_clock::now()}; + c.entry().localBalance = + DecayingSample{steady_clock::now()}; } }; - for (auto i = 0; i < xrpl::RPC::Tuning::kNO_RIPPLE_CHECK.rmax + 5; ++i) + for (auto i = 0; i < xrpl::RPC::Tuning::kNoRippleCheck.rmax + 5; ++i) { if (!admin) checkBalance(); @@ -311,13 +311,13 @@ class NoRippleCheckLimits_test : public beast::unit_test::Suite env.memoize(gw); auto const baseFee = env.current()->fees().base; env(pay(env.master, gw, XRP(1000)), - Seq(kAUTOFILL), + Seq(kAutofill), Fee(toDrops(txq.getMetrics(*env.current()).openLedgerFeeLevel, baseFee) + 1), - Sig(kAUTOFILL)); + Sig(kAutofill)); env(fset(gw, asfDefaultRipple), - Seq(kAUTOFILL), + Seq(kAutofill), Fee(toDrops(txq.getMetrics(*env.current()).openLedgerFeeLevel, baseFee) + 1), - Sig(kAUTOFILL)); + Sig(kAutofill)); env(trust(alice, gw["USD"](10)), Fee(toDrops(txq.getMetrics(*env.current()).openLedgerFeeLevel, baseFee) + 1)); env.close(); 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/RPCCall_test.cpp b/src/test/rpc/RPCCall_test.cpp index 436044e771..cd3cd3cb41 100644 --- a/src/test/rpc/RPCCall_test.cpp +++ b/src/test/rpc/RPCCall_test.cpp @@ -66,7 +66,7 @@ struct RPCCallTestData operator=(RPCCallTestData&&) = delete; }; -static RPCCallTestData const kRPC_CALL_TEST_ARRAY[] = { +static RPCCallTestData const kRpcCallTestArray[] = { // account_channels // ------------------------------------------------------------ {"account_channels: minimal.", @@ -5832,9 +5832,9 @@ std::string updateAPIVersionString(char const* const req, unsigned apiVersion) { std::string const versionStr = std::to_string(apiVersion); - static auto const kPLACE_HOLDER = "%API_VER%"; + static auto const kPlaceHolder = "%API_VER%"; std::string jr(req); - boost::replace_all(jr, kPLACE_HOLDER, versionStr); + boost::replace_all(jr, kPlaceHolder, versionStr); return jr; } @@ -5843,7 +5843,7 @@ makeNetworkConfig(uint32_t networkID) { using namespace test::jtx; return envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = networkID; + cfg->networkId = networkID; return cfg; }); } @@ -5856,14 +5856,14 @@ public: { testcase << "RPCCall API version " << apiVersion; if (!BEAST_EXPECT( - apiVersion >= RPC::kAPI_MINIMUM_SUPPORTED_VERSION && - apiVersion <= RPC::kAPI_MAXIMUM_VALID_VERSION)) + apiVersion >= RPC::kApiMinimumSupportedVersion && + apiVersion <= RPC::kApiMaximumValidVersion)) return; test::jtx::Env const env(*this, makeNetworkConfig(11111)); // Used only for its Journal. // For each RPCCall test. - for (RPCCallTestData const& rpcCallTest : kRPC_CALL_TEST_ARRAY) + for (RPCCallTestData const& rpcCallTest : kRpcCallTestArray) { if (!BEAST_EXPECT(!rpcCallTest.exp.empty())) break; @@ -5871,11 +5871,11 @@ public: std::vector const args{rpcCallTest.args.begin(), rpcCallTest.args.end()}; char const* const expVersioned = - (apiVersion - RPC::kAPI_MINIMUM_SUPPORTED_VERSION) < rpcCallTest.exp.size() - ? rpcCallTest.exp[apiVersion - RPC::kAPI_MINIMUM_SUPPORTED_VERSION] + (apiVersion - RPC::kApiMinimumSupportedVersion) < rpcCallTest.exp.size() + ? rpcCallTest.exp[apiVersion - RPC::kApiMinimumSupportedVersion] : rpcCallTest.exp.back(); - // Note that, over the long term, kNONE of these tests should + // Note that, over the long term, kNone of these tests should // throw. But, for the moment, some of them do. So handle it. json::Value got; try 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/ServerInfo_test.cpp b/src/test/rpc/ServerInfo_test.cpp index b47d37c0cf..1d52f3b83e 100644 --- a/src/test/rpc/ServerInfo_test.cpp +++ b/src/test/rpc/ServerInfo_test.cpp @@ -16,9 +16,9 @@ namespace xrpl::test { namespace validator_data { -static auto const kPUBLIC_KEY = "nHBt9fsb4849WmZiCds4r5TXyBeQjqnH5kzPtqgMAQMgi39YZRPa"; +static auto const kPublicKey = "nHBt9fsb4849WmZiCds4r5TXyBeQjqnH5kzPtqgMAQMgi39YZRPa"; -static auto const kTOKEN = +static auto const kToken = "eyJ2YWxpZGF0aW9uX3NlY3JldF9rZXkiOiI5ZWQ0NWY4NjYyNDFjYzE4YTI3NDdiNT\n" "QzODdjMDYyNTkwNzk3MmY0ZTcxOTAyMzFmYWE5Mzc0NTdmYTlkYWY2IiwibWFuaWZl\n" "c3QiOiJKQUFBQUFGeEllMUZ0d21pbXZHdEgyaUNjTUpxQzlnVkZLaWxHZncxL3ZDeE\n" @@ -54,8 +54,7 @@ protocol = wss2 admin = 127.0.0.1 )xrpldConfig"); - p->loadFromString( - boost::str(toLoad % validator_data::kTOKEN % validator_data::kPUBLIC_KEY)); + p->loadFromString(boost::str(toLoad % validator_data::kToken % validator_data::kPublicKey)); setupConfigForUnitTests(*p); @@ -122,7 +121,7 @@ admin = 127.0.0.1 BEAST_EXPECT(result[jss::result].isMember(jss::info)); BEAST_EXPECT( result[jss::result][jss::info][jss::pubkey_validator] == - validator_data::kPUBLIC_KEY); + validator_data::kPublicKey); auto const& ports = result[jss::result][jss::info][jss::ports]; BEAST_EXPECT(ports.isArray() && ports.size() == 3); diff --git a/src/test/rpc/Simulate_test.cpp b/src/test/rpc/Simulate_test.cpp index ca5fa2133c..9206bf42ac 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), sfGeneric).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), sfGeneric).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(); @@ -492,10 +492,10 @@ class Simulate_test : public beast::unit_test::Suite using namespace jtx; Env env{*this, envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = 0; + cfg->networkId = 0; return cfg; })}; - static auto const kNEW_DOMAIN = "123ABC"; + static auto const kNewDomain = "123ABC"; { auto validateOutput = [&](json::Value const& resp, json::Value const& tx) { @@ -521,7 +521,7 @@ class Simulate_test : public beast::unit_test::Suite auto modifiedNode = node[sfModifiedNode]; BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot"); auto finalFields = modifiedNode[sfFinalFields]; - BEAST_EXPECT(finalFields[sfDomain] == kNEW_DOMAIN); + BEAST_EXPECT(finalFields[sfDomain] == kNewDomain); } } BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0); @@ -533,7 +533,7 @@ class Simulate_test : public beast::unit_test::Suite tx[jss::Account] = env.master.human(); tx[jss::TransactionType] = jss::AccountSet; - tx[sfDomain] = kNEW_DOMAIN; + tx[sfDomain] = kNewDomain; // test with autofill testTx(env, tx, validateOutput); @@ -666,7 +666,7 @@ class Simulate_test : public beast::unit_test::Suite using namespace jtx; Env env(*this); - static auto const kNEW_DOMAIN = "123ABC"; + static auto const kNewDomain = "123ABC"; Account const alice("alice"); Account const becky("becky"); Account const carol("carol"); @@ -706,7 +706,7 @@ class Simulate_test : public beast::unit_test::Suite auto modifiedNode = node[sfModifiedNode]; BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot"); auto finalFields = modifiedNode[sfFinalFields]; - BEAST_EXPECT(finalFields[sfDomain] == kNEW_DOMAIN); + BEAST_EXPECT(finalFields[sfDomain] == kNewDomain); } } BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0); @@ -718,12 +718,12 @@ class Simulate_test : public beast::unit_test::Suite tx[jss::Account] = alice.human(); tx[jss::TransactionType] = jss::AccountSet; - tx[sfDomain] = kNEW_DOMAIN; + tx[sfDomain] = kNewDomain; // 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(); @@ -755,7 +755,7 @@ class Simulate_test : public beast::unit_test::Suite using namespace jtx; Env env(*this); - static auto const kNEW_DOMAIN = "123ABC"; + static auto const kNewDomain = "123ABC"; Account const alice{"alice"}; env(regkey(env.master, alice)); env(fset(env.master, asfDisableMaster), Sig(env.master)); @@ -779,7 +779,7 @@ class Simulate_test : public beast::unit_test::Suite tx[jss::Account] = env.master.human(); tx[jss::TransactionType] = jss::AccountSet; - tx[sfDomain] = kNEW_DOMAIN; + tx[sfDomain] = kNewDomain; // master key is disabled, so this is invalid tx[jss::SigningPubKey] = strHex(env.master.pk().slice()); @@ -804,7 +804,7 @@ class Simulate_test : public beast::unit_test::Suite using namespace jtx; Env env(*this); - static auto const kNEW_DOMAIN = "123ABC"; + static auto const kNewDomain = "123ABC"; Account const alice("alice"); Account const becky("becky"); Account const carol("carol"); @@ -834,10 +834,10 @@ class Simulate_test : public beast::unit_test::Suite tx[jss::Account] = env.master.human(); tx[jss::TransactionType] = jss::AccountSet; - tx[sfDomain] = kNEW_DOMAIN; + tx[sfDomain] = kNewDomain; // 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(); @@ -867,7 +867,7 @@ class Simulate_test : public beast::unit_test::Suite using namespace jtx; Env env(*this); - static auto const kNEW_DOMAIN = "123ABC"; + static auto const kNewDomain = "123ABC"; Account const alice("alice"); Account const becky("becky"); Account const carol("carol"); @@ -899,8 +899,8 @@ 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[sfDomain] = kNewDomain; + tx[sfSigners] = json::ValueType::Array; { json::Value signer; signer[jss::Account] = becky.human(); @@ -1032,10 +1032,10 @@ class Simulate_test : public beast::unit_test::Suite using namespace jtx; Env env{*this, envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = 1025; + cfg->networkId = 1025; return cfg; })}; - static auto const kNEW_DOMAIN = "123ABC"; + static auto const kNewDomain = "123ABC"; { auto validateOutput = [&](json::Value const& resp, json::Value const& tx) { @@ -1061,7 +1061,7 @@ class Simulate_test : public beast::unit_test::Suite auto modifiedNode = node[sfModifiedNode]; BEAST_EXPECT(modifiedNode[sfLedgerEntryType] == "AccountRoot"); auto finalFields = modifiedNode[sfFinalFields]; - BEAST_EXPECT(finalFields[sfDomain] == kNEW_DOMAIN); + BEAST_EXPECT(finalFields[sfDomain] == kNewDomain); } } BEAST_EXPECT(metadata[sfTransactionIndex.jsonName] == 0); @@ -1073,7 +1073,7 @@ class Simulate_test : public beast::unit_test::Suite tx[jss::Account] = env.master.human(); tx[jss::TransactionType] = jss::AccountSet; - tx[sfDomain] = kNEW_DOMAIN; + tx[sfDomain] = kNewDomain; // test with autofill testTx(env, tx, validateOutput); @@ -1097,7 +1097,7 @@ class Simulate_test : public beast::unit_test::Suite using namespace jtx; using namespace std::chrono_literals; Env env{*this, envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = 1025; + cfg->networkId = 1025; return cfg; })}; 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..090a599e7c 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) @@ -321,17 +321,17 @@ public: using namespace std::chrono_literals; using namespace jtx; Env env(*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; cfg = singleThreadIo(std::move(cfg)); 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) @@ -474,7 +474,7 @@ public: if (jv[jss::ledger_index] != std::to_string(env.closed()->header().seq)) return false; - if (jv[jss::flags] != (kVF_FULLY_CANONICAL_SIG | kVF_FULL_VALIDATION)) + if (jv[jss::flags] != (kVfFullyCanonicalSig | kVfFullValidation)) return false; if (jv[jss::full] != true) @@ -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]; @@ -932,9 +932,9 @@ public: auto& from = (i % 2 == 0) ? a : b; auto& to = (i % 2 == 0) ? b : a; env(pay(from, to, jtx::XRP(numXRP)), - jtx::Seq(jtx::kAUTOFILL), - jtx::Fee(jtx::kAUTOFILL), - jtx::Sig(jtx::kAUTOFILL)); + jtx::Seq(jtx::kAutofill), + jtx::Fee(jtx::kAutofill), + jtx::Sig(jtx::kAutofill)); } for (int i = 0; i < ledgersToClose; ++i) BEAST_EXPECT(env.syncClose()); @@ -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); @@ -1319,12 +1319,12 @@ public: auto const carol = permDex.carol; auto const domainID = permDex.domainID; auto const gw = permDex.gw; - auto const usd = permDex.USD; + auto const usd = permDex.usd; 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..8724e2974d 100644 --- a/src/test/rpc/TransactionEntry_test.cpp +++ b/src/test/rpc/TransactionEntry_test.cpp @@ -32,7 +32,7 @@ class TransactionEntry_test : public beast::unit_test::Suite testcase("Invalid request params"); using namespace test::jtx; Env env{*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; })}; @@ -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]; @@ -139,7 +139,7 @@ class TransactionEntry_test : public beast::unit_test::Suite testcase("Basic request API version " + std::to_string(apiVersion)); using namespace test::jtx; Env env{*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; })}; @@ -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..8c50736b85 100644 --- a/src/test/rpc/Transaction_test.cpp +++ b/src/test/rpc/Transaction_test.cpp @@ -47,7 +47,7 @@ class Transaction_test : public beast::unit_test::Suite { using namespace test::jtx; return envconfig([&](std::unique_ptr cfg) { - cfg->NETWORK_ID = networkID; + cfg->networkId = networkID; return cfg; }); } @@ -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); @@ -749,7 +749,7 @@ class Transaction_test : public beast::unit_test::Suite using std::to_string; Env env{*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; })}; Account const alice{"alice"}; @@ -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; @@ -827,7 +827,7 @@ class Transaction_test : public beast::unit_test::Suite using std::to_string; Env env{*this, envconfig([](std::unique_ptr cfg) { - cfg->FEES.reference_fee = 10; + cfg->fees.referenceFee = 10; return cfg; })}; Account const alice{"alice"}; @@ -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..20740bfe53 100644 --- a/src/test/rpc/Version_test.cpp +++ b/src/test/rpc/Version_test.cpp @@ -32,7 +32,7 @@ class Version_test : public beast::unit_test::Suite auto jrr = env.rpc( "json", "version", - "{\"api_version\": " + std::to_string(RPC::kAPI_MAXIMUM_SUPPORTED_VERSION) + + "{\"api_version\": " + std::to_string(RPC::kApiMaximumSupportedVersion) + "}")[jss::result]; BEAST_EXPECT(isCorrectReply(jrr)); @@ -62,17 +62,16 @@ class Version_test : public beast::unit_test::Suite auto re = env.rpc( "json", "version", - "{\"api_version\": " + std::to_string(RPC::kAPI_MINIMUM_SUPPORTED_VERSION - 1) + "}"); + "{\"api_version\": " + std::to_string(RPC::kApiMinimumSupportedVersion - 1) + "}"); BEAST_EXPECT(badVersion(re)); - BEAST_EXPECT(env.app().config().BETA_RPC_API); + BEAST_EXPECT(env.app().config().betaRpcApi); re = env.rpc( "json", "version", "{\"api_version\": " + std::to_string( - std::max( - RPC::kAPI_MAXIMUM_SUPPORTED_VERSION.value, RPC::kAPI_BETA_VERSION.value) + + std::max(RPC::kApiMaximumSupportedVersion.value, RPC::kApiBetaVersion.value) + 1) + "}"); BEAST_EXPECT(badVersion(re)); @@ -87,40 +86,38 @@ class Version_test : public beast::unit_test::Suite testcase("test getAPIVersionNumber function"); unsigned int const versionIfUnspecified = - RPC::kAPI_VERSION_IF_UNSPECIFIED < RPC::kAPI_MINIMUM_SUPPORTED_VERSION - ? RPC::kAPI_INVALID_VERSION - : RPC::kAPI_VERSION_IF_UNSPECIFIED; + RPC::kApiVersionIfUnspecified < RPC::kApiMinimumSupportedVersion + ? RPC::kApiInvalidVersion + : RPC::kApiVersionIfUnspecified; - 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; + jObject[jss::api_version] = RPC::kApiVersionIfUnspecified.value; BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == versionIfUnspecified); - jObject[jss::api_version] = RPC::kAPI_MINIMUM_SUPPORTED_VERSION.value; - BEAST_EXPECT( - RPC::getAPIVersionNumber(jObject, false) == RPC::kAPI_MINIMUM_SUPPORTED_VERSION); - jObject[jss::api_version] = RPC::kAPI_MAXIMUM_SUPPORTED_VERSION.value; - BEAST_EXPECT( - RPC::getAPIVersionNumber(jObject, false) == RPC::kAPI_MAXIMUM_SUPPORTED_VERSION); + jObject[jss::api_version] = RPC::kApiMinimumSupportedVersion.value; + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kApiMinimumSupportedVersion); + jObject[jss::api_version] = RPC::kApiMaximumSupportedVersion.value; + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kApiMaximumSupportedVersion); - jObject[jss::api_version] = RPC::kAPI_MINIMUM_SUPPORTED_VERSION - 1; - BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kAPI_INVALID_VERSION); - jObject[jss::api_version] = RPC::kAPI_MAXIMUM_SUPPORTED_VERSION + 1; - BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kAPI_INVALID_VERSION); - jObject[jss::api_version] = RPC::kAPI_BETA_VERSION.value; - BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, true) == RPC::kAPI_BETA_VERSION); - jObject[jss::api_version] = RPC::kAPI_BETA_VERSION + 1; - BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, true) == RPC::kAPI_INVALID_VERSION); + jObject[jss::api_version] = RPC::kApiMinimumSupportedVersion - 1; + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kApiInvalidVersion); + jObject[jss::api_version] = RPC::kApiMaximumSupportedVersion + 1; + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kApiInvalidVersion); + jObject[jss::api_version] = RPC::kApiBetaVersion.value; + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, true) == RPC::kApiBetaVersion); + jObject[jss::api_version] = RPC::kApiBetaVersion + 1; + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, true) == RPC::kApiInvalidVersion); - jObject[jss::api_version] = RPC::kAPI_INVALID_VERSION.value; - BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kAPI_INVALID_VERSION); + jObject[jss::api_version] = RPC::kApiInvalidVersion.value; + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kApiInvalidVersion); jObject[jss::api_version] = "a"; - BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kAPI_INVALID_VERSION); + BEAST_EXPECT(RPC::getAPIVersionNumber(jObject, false) == RPC::kApiInvalidVersion); } void @@ -144,7 +141,7 @@ class Version_test : public beast::unit_test::Suite "\"method\": \"version\", " "\"params\": { " "\"api_version\": " + - std::to_string(RPC::kAPI_MAXIMUM_SUPPORTED_VERSION) + "}}"; + std::to_string(RPC::kApiMaximumSupportedVersion) + "}}"; auto re = env.rpc("json2", '[' + withoutApiVerion + ", " + withApiVerion + ']'); if (!BEAST_EXPECT(re.isArray())) @@ -163,7 +160,7 @@ class Version_test : public beast::unit_test::Suite using namespace test::jtx; Env env{*this}; - BEAST_EXPECT(env.app().config().BETA_RPC_API); + BEAST_EXPECT(env.app().config().betaRpcApi); auto const withoutApiVerion = std::string("{ ") + "\"jsonrpc\": \"2.0\", " "\"ripplerpc\": \"2.0\", " @@ -179,8 +176,7 @@ class Version_test : public beast::unit_test::Suite "\"params\": { " "\"api_version\": " + std::to_string( - std::max(RPC::kAPI_MAXIMUM_SUPPORTED_VERSION.value, RPC::kAPI_BETA_VERSION.value) + - 1) + + std::max(RPC::kApiMaximumSupportedVersion.value, RPC::kApiBetaVersion.value) + 1) + "}}"; auto re = env.rpc("json2", '[' + withoutApiVerion + ", " + withWrongApiVerion + ']'); @@ -198,19 +194,19 @@ class Version_test : public beast::unit_test::Suite testcase("config test"); { Config const c; - BEAST_EXPECT(c.BETA_RPC_API == false); + BEAST_EXPECT(c.betaRpcApi == false); } { Config c; c.loadFromString("\n[beta_rpc_api]\n1\n"); - BEAST_EXPECT(c.BETA_RPC_API == true); + BEAST_EXPECT(c.betaRpcApi == true); } { Config c; c.loadFromString("\n[beta_rpc_api]\n0\n"); - BEAST_EXPECT(c.BETA_RPC_API == false); + BEAST_EXPECT(c.betaRpcApi == false); } } @@ -224,21 +220,21 @@ class Version_test : public beast::unit_test::Suite c->loadFromString("\n[beta_rpc_api]\n1\n"); return c; })}; - if (!BEAST_EXPECT(env.app().config().BETA_RPC_API == true)) + if (!BEAST_EXPECT(env.app().config().betaRpcApi == true)) return; auto jrr = env.rpc( "json", "version", - "{\"api_version\": " + std::to_string(RPC::kAPI_BETA_VERSION) + "}")[jss::result]; + "{\"api_version\": " + std::to_string(RPC::kApiBetaVersion) + "}")[jss::result]; if (!BEAST_EXPECT(jrr.isMember(jss::version))) return; if (!BEAST_EXPECT(jrr[jss::version].isMember(jss::first)) && jrr[jss::version].isMember(jss::last)) return; - BEAST_EXPECT(jrr[jss::version][jss::first] == RPC::kAPI_MINIMUM_SUPPORTED_VERSION.value); - BEAST_EXPECT(jrr[jss::version][jss::last] == RPC::kAPI_BETA_VERSION.value); + BEAST_EXPECT(jrr[jss::version][jss::first] == RPC::kApiMinimumSupportedVersion.value); + BEAST_EXPECT(jrr[jss::version][jss::last] == RPC::kApiBetaVersion.value); } public: diff --git a/src/test/server/ServerStatus_test.cpp b/src/test/server/ServerStatus_test.cpp index 87f1d0e927..6569a2d2a4 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; }; @@ -843,7 +843,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En BEAST_EXPECT(resp.body().find("connectivity is working.") != std::string::npos); // with ELB_SUPPORT, status still does not indicate a problem - env.app().config().ELB_SUPPORT = true; + env.app().config().elbSupport = true; doRequest( yield, @@ -973,7 +973,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En BEAST_EXPECT(resp.result() == boost::beast::http::status::ok); BEAST_EXPECT(resp.body().find("connectivity is working.") != std::string::npos); - env.app().config().ELB_SUPPORT = true; + env.app().config().elbSupport = true; doRequest( yield, @@ -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); @@ -1111,7 +1111,7 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En using namespace test::jtx; Env env{*this, envconfig([](std::unique_ptr cfg) { - cfg->ELB_SUPPORT = true; + cfg->elbSupport = true; return cfg; })}; diff --git a/src/test/server/Server_test.cpp b/src/test/server/Server_test.cpp index 3bddf489d6..263fb9451f 100644 --- a/src/test/server/Server_test.cpp +++ b/src/test/server/Server_test.cpp @@ -48,15 +48,15 @@ public: class TestThread { private: - boost::asio::io_context io_context_; + boost::asio::io_context ioContext_; std::optional> work_; std::thread thread_; public: TestThread() - : work_(std::in_place, boost::asio::make_work_guard(io_context_)) - , thread_([&]() { this->io_context_.run(); }) + : work_(std::in_place, boost::asio::make_work_guard(ioContext_)) + , thread_([&]() { this->ioContext_.run(); }) { } @@ -69,7 +69,7 @@ public: boost::asio::io_context& getIoContext() { - return io_context_; + return ioContext_; } }; @@ -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..b2fc185b31 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 kTableItems = 100; + static constexpr auto kTableItemsExtra = 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..ab7e01e3af 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); @@ -222,7 +222,7 @@ public: testcase("build/tear unbacked"); } { - constexpr std::array kEYS{ + static constexpr std::array keys{ uint256( "b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e" "5a772c6ca8"), @@ -248,7 +248,7 @@ public: "292891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e" "5a772c6ca8")}; - constexpr std::array kHASHES{ + static constexpr std::array kHashes{ uint256( "B7387CFEA0465759ADC718E8C42B52D2309D179B326E239EB5075C" "64B6281F7F"), @@ -278,21 +278,21 @@ public: if (!backed) map.setUnbacked(); - BEAST_EXPECT(map.getHash() == beast::kZERO); - for (int k = 0; k < kEYS.size(); ++k) + BEAST_EXPECT(map.getHash() == beast::kZero); + for (int k = 0; k < keys.size(); ++k) { BEAST_EXPECT(map.addItem( - SHAMapNodeType::TnTransactionNm, makeShamapitem(kEYS[k], intToVuc(k)))); - BEAST_EXPECT(map.getHash().asUint256() == kHASHES[k]); + SHAMapNodeType::TnTransactionNm, makeShamapitem(keys[k], intToVuc(k)))); + BEAST_EXPECT(map.getHash().asUInt256() == kHashes[k]); map.invariants(); } - for (int k = kEYS.size() - 1; k >= 0; --k) + for (int k = keys.size() - 1; k >= 0; --k) { - BEAST_EXPECT(map.getHash().asUint256() == kHASHES[k]); - BEAST_EXPECT(map.delItem(kEYS[k])); + BEAST_EXPECT(map.getHash().asUInt256() == kHashes[k]); + BEAST_EXPECT(map.delItem(keys[k])); map.invariants(); } - BEAST_EXPECT(map.getHash() == beast::kZERO); + BEAST_EXPECT(map.getHash() == beast::kZero); } if (backed) @@ -305,7 +305,7 @@ public: } { - constexpr std::array kEYS{ + static constexpr std::array keys{ uint256( "f22891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e" "5a772c6ca8"), @@ -335,7 +335,7 @@ public: SHAMap map{SHAMapType::FREE, tf}; if (!backed) map.setUnbacked(); - for (auto const& k : kEYS) + for (auto const& k : keys) { map.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(k, intToVuc(0))); map.invariants(); @@ -344,7 +344,7 @@ public: int h = 7; for (auto const& k : map) { - BEAST_EXPECT(k.key() == kEYS[h]); + BEAST_EXPECT(k.key() == keys[h]); --h; } } @@ -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/FileDirGuard.h b/src/test/unit_test/FileDirGuard.h index 4966b8089c..19110469ee 100644 --- a/src/test/unit_test/FileDirGuard.h +++ b/src/test/unit_test/FileDirGuard.h @@ -45,9 +45,9 @@ public: { using namespace boost::filesystem; - static auto kSUB_DIR_COUNTER = 0; + static auto kSubDirCounter = 0; if (useCounter) - subDir_ += std::to_string(++kSUB_DIR_COUNTER); + subDir_ += std::to_string(++kSubDirCounter); if (!exists(subDir_)) { create_directory(subDir_); diff --git a/src/test/unit_test/SuiteJournal.h b/src/test/unit_test/SuiteJournal.h index 32b085ffe6..bd54683031 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,33 +43,33 @@ 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:"; }(); - static std::mutex kLOG_MUTEX; - std::scoped_lock const lock(kLOG_MUTEX); + static std::mutex kLogMutex; + std::scoped_lock const lock(kLogMutex); suite_.log << s << partition_ << text << std::endl; } @@ -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..3a56d22654 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() == kMaxTop && 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() == kMaxTop) 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() < kMaxTop) { 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() > kMaxTop) + topResult.resize(kMaxTop); top = topResult; } @@ -139,28 +139,28 @@ template std::size_t MultiRunnerBase::Inner::checkoutJobIndex() { - return job_index++; + return jobIndex++; } template std::size_t MultiRunnerBase::Inner::checkoutTestIndex() { - return test_index++; + return testIndex++; } template bool MultiRunnerBase::Inner::anyFailed() const { - return any_failed; + return anyFailedFlag; } template void MultiRunnerBase::Inner::anyFailed(bool v) { - any_failed = any_failed || v; + anyFailedFlag = anyFailedFlag || v; } template @@ -183,14 +183,14 @@ template void MultiRunnerBase::Inner::incKeepAliveCount() { - ++keep_alive; + ++keepAlive; } template std::size_t MultiRunnerBase::Inner::getKeepAliveCount() { - return keep_alive; + return keepAlive; } template @@ -218,34 +218,34 @@ MultiRunnerBase::MultiRunnerBase() if (IsParent) { // cleanup any leftover state for any previous failed runs - boost::interprocess::shared_memory_object::remove(kSHARED_MEM_NAME); - boost::interprocess::message_queue::remove(kMESSAGE_QUEUE_NAME); + boost::interprocess::shared_memory_object::remove(kSharedMemName); + boost::interprocess::message_queue::remove(kMessageQueueName); } - shared_mem_ = boost::interprocess::shared_memory_object{ + sharedMem_ = boost::interprocess::shared_memory_object{ std::conditional_t< IsParent, boost::interprocess::create_only_t, boost::interprocess::open_only_t>{}, - kSHARED_MEM_NAME, + kSharedMemName, boost::interprocess::read_write}; if (IsParent) { - shared_mem_.truncate(sizeof(Inner)); - message_queue_ = std::make_unique( + sharedMem_.truncate(sizeof(Inner)); + messageQueue_ = std::make_unique( boost::interprocess::create_only, - kMESSAGE_QUEUE_NAME, + kMessageQueueName, /*max messages*/ 16, /*max message size*/ 1 << 20); } else { - message_queue_ = std::make_unique( - boost::interprocess::open_only, kMESSAGE_QUEUE_NAME); + messageQueue_ = std::make_unique( + boost::interprocess::open_only, kMessageQueueName); } - region_ = boost::interprocess::mapped_region{shared_mem_, boost::interprocess::read_write}; + region_ = boost::interprocess::mapped_region{sharedMem_, boost::interprocess::read_write}; if (IsParent) { inner_ = new (region_.get_address()) Inner{}; @@ -259,8 +259,8 @@ MultiRunnerBase::MultiRunnerBase() { if (IsParent) { - boost::interprocess::shared_memory_object::remove(kSHARED_MEM_NAME); - boost::interprocess::message_queue::remove(kMESSAGE_QUEUE_NAME); + boost::interprocess::shared_memory_object::remove(kSharedMemName); + boost::interprocess::message_queue::remove(kMessageQueueName); } throw; } @@ -272,8 +272,8 @@ MultiRunnerBase::~MultiRunnerBase() if (IsParent) { inner_->~Inner(); - boost::interprocess::shared_memory_object::remove(kSHARED_MEM_NAME); - boost::interprocess::message_queue::remove(kMESSAGE_QUEUE_NAME); + boost::interprocess::shared_memory_object::remove(kSharedMemName); + boost::interprocess::message_queue::remove(kMessageQueueName); } } @@ -340,8 +340,8 @@ MultiRunnerBase::messageQueueSend(MessageType mt, std::string const& s { // must use a mutex since the two "sends" must happen in order std::scoped_lock const l{inner_->m}; - message_queue_->send(&mt, sizeof(mt), /*priority*/ 0); - message_queue_->send(s.c_str(), s.size(), /*priority*/ 0); + messageQueue_->send(&mt, sizeof(mt), /*priority*/ 0); + messageQueue_->send(s.c_str(), s.size(), /*priority*/ 0); } template @@ -376,13 +376,13 @@ namespace test { MultiRunnerParent::MultiRunnerParent() : os_(std::cout) { - message_queue_thread_ = std::thread([this] { + messageQueueThread_ = std::thread([this] { std::vector buf(1 << 20); - while (this->continue_message_queue_ || this->message_queue_->get_num_msg()) + while (this->continueMessageQueue_ || this->messageQueue_->get_num_msg()) { // let children know the parent is still alive this->incKeepAliveCount(); - if (!this->message_queue_->get_num_msg()) + if (!this->messageQueue_->get_num_msg()) { // If a child does not see the keep alive count incremented, // it will assume the parent has died. This sleep time needs @@ -395,13 +395,13 @@ MultiRunnerParent::MultiRunnerParent() : os_(std::cout) { std::size_t recvdSize = 0; unsigned int priority = 0; - this->message_queue_->receive(buf.data(), buf.size(), recvdSize, priority); + this->messageQueue_->receive(buf.data(), buf.size(), recvdSize, priority); if (!recvdSize) continue; assert(recvdSize == 1); MessageType const mt{*reinterpret_cast(buf.data())}; - this->message_queue_->receive(buf.data(), buf.size(), recvdSize, priority); + this->messageQueue_->receive(buf.data(), buf.size(), recvdSize, priority); if (recvdSize) { std::string s{buf.data(), recvdSize}; @@ -412,10 +412,10 @@ MultiRunnerParent::MultiRunnerParent() : os_(std::cout) this->os_.flush(); break; case MessageType::TestStart: - running_suites_.insert(std::move(s)); + runningSuites_.insert(std::move(s)); break; case MessageType::TestEnd: - running_suites_.erase(s); + runningSuites_.erase(s); break; default: assert(0); // unknown message type @@ -440,14 +440,14 @@ MultiRunnerParent::~MultiRunnerParent() { using namespace beast::unit_test; - continue_message_queue_ = false; - message_queue_thread_.join(); + continueMessageQueue_ = false; + messageQueueThread_.join(); - addFailures(running_suites_.size()); + addFailures(runningSuites_.size()); printResults(os_); - for (auto const& s : running_suites_) + for (auto const& s : runningSuites_) { os_ << "\nSuite: " << s << " failed to complete. The child process may have crashed.\n"; } @@ -480,16 +480,13 @@ MultiRunnerParent::addFailures(std::size_t failures) //------------------------------------------------------------------------------ MultiRunnerChild::MultiRunnerChild(std::size_t numJobs, bool quiet, bool printLog) - : job_index_{checkoutJobIndex()} - , num_jobs_{numJobs} - , quiet_{quiet} - , print_log_{!quiet || printLog} + : jobIndex_{checkoutJobIndex()}, numJobs_{numJobs}, quiet_{quiet}, printLog_{!quiet || printLog} { - if (num_jobs_ > 1) + if (numJobs_ > 1) { - keep_alive_thread_ = std::thread([this] { + keepAliveThread_ = std::thread([this] { std::size_t lastCount = getKeepAliveCount(); - while (this->continue_keep_alive_) + while (this->continueKeepAlive_) { // Use a small sleep time so in the normal case the child // process may shutdown quickly. However, to protect against @@ -504,7 +501,7 @@ MultiRunnerChild::MultiRunnerChild(std::size_t numJobs, bool quiet, bool printLo if (curCount == lastCount) { // assume parent process is no longer alive - std::cerr << "multi_runner_child " << job_index_ + std::cerr << "multi_runner_child " << jobIndex_ << ": Assuming parent died, exiting.\n"; std::exit(EXIT_FAILURE); } @@ -517,10 +514,10 @@ MultiRunnerChild::MultiRunnerChild(std::size_t numJobs, bool quiet, bool printLo MultiRunnerChild::~MultiRunnerChild() { - if (num_jobs_ > 1) + if (numJobs_ > 1) { - continue_keep_alive_ = false; - keep_alive_thread_.join(); + continueKeepAlive_ = false; + keepAliveThread_.join(); } add(results_); @@ -548,75 +545,74 @@ MultiRunnerChild::addFailures(std::size_t failures) void MultiRunnerChild::onSuiteBegin(beast::unit_test::SuiteInfo const& info) { - suite_results_ = detail::SuiteResults{info.fullName()}; - messageQueueSend(MessageType::TestStart, suite_results_.name); + suiteResults_ = detail::SuiteResults{info.fullName()}; + messageQueueSend(MessageType::TestStart, suiteResults_.name); } void MultiRunnerChild::onSuiteEnd() { - if (print_log_ || suite_results_.failed > 0) + if (printLog_ || suiteResults_.failed > 0) { std::stringstream s; - if (num_jobs_ > 1) - s << job_index_ << "> "; - s << (suite_results_.failed > 0 ? "failed: " : "") << suite_results_.name << " had " - << suite_results_.failed << " failures." << std::endl; + if (numJobs_ > 1) + s << jobIndex_ << "> "; + s << (suiteResults_.failed > 0 ? "failed: " : "") << suiteResults_.name << " had " + << suiteResults_.failed << " failures." << std::endl; messageQueueSend(MessageType::Log, s.str()); } - results_.add(suite_results_); - messageQueueSend(MessageType::TestEnd, suite_results_.name); + results_.add(suiteResults_); + messageQueueSend(MessageType::TestEnd, suiteResults_.name); } void MultiRunnerChild::onCaseBegin(std::string const& name) { - case_results_ = detail::CaseResults(name); + caseResults_ = detail::CaseResults(name); if (quiet_) return; std::stringstream s; - if (num_jobs_ > 1) - s << job_index_ << "> "; - s << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name)) - << '\n'; + if (numJobs_ > 1) + s << jobIndex_ << "> "; + s << suiteResults_.name << (caseResults_.name.empty() ? "" : (" " + caseResults_.name)) << '\n'; messageQueueSend(MessageType::Log, s.str()); } void MultiRunnerChild::onCaseEnd() { - suite_results_.add(case_results_); + suiteResults_.add(caseResults_); } void MultiRunnerChild::onPass() { - ++case_results_.total; + ++caseResults_.total; } void MultiRunnerChild::onFail(std::string const& reason) { - ++case_results_.failed; - ++case_results_.total; + ++caseResults_.failed; + ++caseResults_.total; std::stringstream s; - if (num_jobs_ > 1) - s << job_index_ << "> "; - s << "#" << case_results_.total << " failed" << (reason.empty() ? "" : ": ") << reason << '\n'; + if (numJobs_ > 1) + s << jobIndex_ << "> "; + s << "#" << caseResults_.total << " failed" << (reason.empty() ? "" : ": ") << reason << '\n'; messageQueueSend(MessageType::Log, s.str()); } void MultiRunnerChild::onLog(std::string const& msg) { - if (!print_log_) + if (!printLog_) return; std::stringstream s; - if (num_jobs_ > 1) - s << job_index_ << "> "; + if (numJobs_ > 1) + s << jobIndex_ << "> "; s << msg; messageQueueSend(MessageType::Log, s.str()); } diff --git a/src/test/unit_test/multi_runner.h b/src/test/unit_test/multi_runner.h index 9c83c29141..8b07559e8c 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 kMaxTop = 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 @@ -89,14 +87,14 @@ class MultiRunnerBase // way they communicate is through message queues. struct Inner { - std::atomic job_index{0}; - std::atomic test_index{0}; - std::atomic any_failed{false}; - // A parent process will periodically increment `keep_alive_`. The child - // processes will check if `keep_alive_` is being incremented. If it is + std::atomic jobIndex{0}; + std::atomic testIndex{0}; + std::atomic anyFailedFlag{false}; + // A parent process will periodically increment `keepAlive`. The child + // processes will check if `keepAlive` is being incremented. If it is // not incremented for a sufficiently long time, the child will assume // the parent process has died. - std::atomic keep_alive{0}; + std::atomic keepAlive{0}; mutable boost::interprocess::interprocess_mutex m; detail::Results results; @@ -133,19 +131,19 @@ class MultiRunnerBase printResults(S& s); }; - static constexpr char const* kSHARED_MEM_NAME = "XrpldUnitTestSharedMem"; + static constexpr char const* kSharedMemName = "XrpldUnitTestSharedMem"; // name of the message queue a multi_runner_child will use to communicate // with multi_runner_parent - static constexpr char const* kMESSAGE_QUEUE_NAME = "XrpldUnitTestMessageQueue"; + static constexpr char const* kMessageQueueName = "XrpldUnitTestMessageQueue"; // `inner_` will be created in shared memory Inner* inner_; // shared memory to use for the `inner` member - boost::interprocess::shared_memory_object shared_mem_; + boost::interprocess::shared_memory_object sharedMem_; boost::interprocess::mapped_region region_; protected: - std::unique_ptr message_queue_; + std::unique_ptr messageQueue_; enum class MessageType : std::uint8_t { TestStart, TestEnd, Log }; void @@ -203,10 +201,10 @@ class MultiRunnerParent : private detail::MultiRunnerBase private: // message_queue_ is used to collect log messages from the children std::ostream& os_; - std::atomic continue_message_queue_{true}; - std::thread message_queue_thread_; + std::atomic continueMessageQueue_{true}; + std::thread messageQueueThread_; // track running suites so if a child crashes the culprit can be flagged - std::set running_suites_; + std::set runningSuites_; public: MultiRunnerParent(MultiRunnerParent const&) = delete; @@ -237,16 +235,16 @@ class MultiRunnerChild : public beast::unit_test::Runner, private detail::MultiRunnerBase { private: - std::size_t job_index_; + std::size_t jobIndex_; detail::Results results_; - detail::SuiteResults suite_results_; - detail::CaseResults case_results_; - std::size_t num_jobs_{0}; + detail::SuiteResults suiteResults_; + detail::CaseResults caseResults_; + std::size_t numJobs_{0}; bool quiet_{false}; - bool print_log_{true}; + bool printLog_{true}; - std::atomic continue_keep_alive_{true}; - std::thread keep_alive_thread_; + std::atomic continueKeepAlive_{true}; + std::thread keepAliveThread_; public: MultiRunnerChild(MultiRunnerChild const&) = delete; @@ -320,12 +318,12 @@ MultiRunnerChild::runMulti(Pred pred) } catch (...) { - if (num_jobs_ <= 1) + if (numJobs_ <= 1) throw; // a single process can die // inform the parent std::stringstream s; - s << job_index_ << "> failed Unhandled exception in test.\n"; + s << jobIndex_ << "> failed Unhandled exception in test.\n"; messageQueueSend(MessageType::Log, s.str()); failed = true; } diff --git a/src/test/unit_test/utils.h b/src/test/unit_test/utils.h index beccf1c92e..028823c763 100644 --- a/src/test/unit_test/utils.h +++ b/src/test/unit_test/utils.h @@ -10,8 +10,8 @@ namespace xrpl::test { inline bool equal(SecretKey const& lhs, SecretKey const& rhs) { - return lhs.size() == SecretKey::kSIZE && rhs.size() == SecretKey::kSIZE && - std::memcmp(lhs.data(), rhs.data(), SecretKey::kSIZE) == 0; + return lhs.size() == SecretKey::kSize && rhs.size() == SecretKey::kSize && + std::memcmp(lhs.data(), rhs.data(), SecretKey::kSize) == 0; } } // namespace xrpl::test 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/basics/Slice.cpp b/src/tests/libxrpl/basics/Slice.cpp index f999d99934..02287dddc6 100644 --- a/src/tests/libxrpl/basics/Slice.cpp +++ b/src/tests/libxrpl/basics/Slice.cpp @@ -8,7 +8,7 @@ using namespace xrpl; -static std::uint8_t const kDATA[] = { +static std::uint8_t const kData[] = { 0xa8, 0xa1, 0x38, 0x45, 0x23, 0xec, 0xe4, 0x23, 0x71, 0x6d, 0x2a, 0x18, 0xb4, 0x70, 0xcb, 0xf5, 0xac, 0x2d, 0x89, 0x4d, 0x19, 0x9c, 0xf0, 0x2c, 0x15, 0xd1, 0xf9, 0x9b, 0x66, 0xd2, 0x30, 0xd3}; @@ -21,9 +21,9 @@ TEST(Slice, equality_and_inequality) EXPECT_EQ(s0, s0); // Test slices of equal and unequal size pointing to same data: - for (std::size_t i = 0; i != sizeof(kDATA); ++i) + for (std::size_t i = 0; i != sizeof(kData); ++i) { - Slice const s1{kDATA, i}; + Slice const s1{kData, i}; EXPECT_EQ(s1.size(), i); EXPECT_NE(s1.data(), nullptr); @@ -37,9 +37,9 @@ TEST(Slice, equality_and_inequality) EXPECT_NE(s1, s0); } - for (std::size_t j = 0; j != sizeof(kDATA); ++j) + for (std::size_t j = 0; j != sizeof(kData); ++j) { - Slice const s2{kDATA, j}; + Slice const s2{kData, j}; if (i == j) { @@ -53,11 +53,11 @@ TEST(Slice, equality_and_inequality) } // Test slices of equal size but pointing to different data: - std::array a{}; - std::array b{}; + std::array a{}; + std::array b{}; - for (std::size_t i = 0; i != sizeof(kDATA); ++i) - a[i] = b[i] = kDATA[i]; + for (std::size_t i = 0; i != sizeof(kData); ++i) + a[i] = b[i] = kData[i]; EXPECT_EQ(makeSlice(a), makeSlice(b)); b[7]++; @@ -68,23 +68,23 @@ TEST(Slice, equality_and_inequality) TEST(Slice, indexing) { - Slice const s{kDATA, sizeof(kDATA)}; + Slice const s{kData, sizeof(kData)}; - for (std::size_t i = 0; i != sizeof(kDATA); ++i) - EXPECT_EQ(s[i], kDATA[i]); + for (std::size_t i = 0; i != sizeof(kData); ++i) + EXPECT_EQ(s[i], kData[i]); } TEST(Slice, advancing) { - for (std::size_t i = 0; i < sizeof(kDATA); ++i) + for (std::size_t i = 0; i < sizeof(kData); ++i) { - for (std::size_t j = 0; i + j < sizeof(kDATA); ++j) + for (std::size_t j = 0; i + j < sizeof(kData); ++j) { - Slice s(kDATA + i, sizeof(kDATA) - i); + Slice s(kData + i, sizeof(kData) - i); s += j; - EXPECT_EQ(s.data(), kDATA + i + j); - EXPECT_EQ(s.size(), sizeof(kDATA) - i - j); + EXPECT_EQ(s.data(), kData + i + j); + EXPECT_EQ(s.size(), sizeof(kData) - i - j); } } } 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..428b7ad95b 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,19 +104,19 @@ 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; } }(); - constexpr auto kRESET = "\033[0m"; + static constexpr auto kReset = "\033[0m"; if (supportsColor) { - stream << color << prefix << " " << text << kRESET << std::endl; + stream << color << prefix << " " << text << kReset << std::endl; } else { 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/helpers/TxTest.cpp b/src/tests/libxrpl/helpers/TxTest.cpp index 29db311fce..32667ba13d 100644 --- a/src/tests/libxrpl/helpers/TxTest.cpp +++ b/src/tests/libxrpl/helpers/TxTest.cpp @@ -41,7 +41,7 @@ namespace xrpl::test { FeatureBitset allFeatures() { - static FeatureBitset const kFEATURES = [] { + static FeatureBitset const kFeatures = [] { auto const& sa = allAmendments(); std::vector feats; feats.reserve(sa.size()); @@ -52,7 +52,7 @@ allFeatures() } return FeatureBitset(feats); }(); - return kFEATURES; + return kFeatures; } //------------------------------------------------------------------------------ @@ -73,7 +73,7 @@ TxTest::TxTest(std::optional features) // Create a genesis ledger as the base closedLedger_ = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) *rules_, fees, @@ -85,7 +85,7 @@ TxTest::TxTest(std::optional features) // Create an open view on top of the genesis ledger openLedger_ = - std::make_shared(kOPEN_LEDGER, closedLedger_.get(), *rules_, closedLedger_); + std::make_shared(kOpenLedger, closedLedger_.get(), *rules_, closedLedger_); } bool @@ -213,7 +213,7 @@ TxTest::close() openLedger_ = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - std::make_shared(kOPEN_LEDGER, closedLedger_.get(), *rules_, closedLedger_); + std::make_shared(kOpenLedger, closedLedger_.get(), *rules_, closedLedger_); } void diff --git a/src/tests/libxrpl/helpers/TxTest.h b/src/tests/libxrpl/helpers/TxTest.h index 8ba9898d99..0b578c7e7f 100644 --- a/src/tests/libxrpl/helpers/TxTest.h +++ b/src/tests/libxrpl/helpers/TxTest.h @@ -46,7 +46,7 @@ template constexpr XRPAmount XRP(T xrp) { - return XRPAmount{static_cast(xrp) * kDROPS_PER_XRP.drops()}; + return XRPAmount{static_cast(xrp) * kDropsPerXrp.drops()}; } /** @@ -58,7 +58,7 @@ template XRPAmount XRP(T xrp) { - return XRPAmount{static_cast(std::round(xrp * kDROPS_PER_XRP.drops()))}; + return XRPAmount{static_cast(std::round(xrp * kDropsPerXrp.drops()))}; } /** @@ -69,7 +69,7 @@ XRP(T xrp) inline XRPAmount XRP(Number const& xrp) { - return XRPAmount{static_cast(xrp * kDROPS_PER_XRP.drops())}; + return XRPAmount{static_cast(xrp * kDropsPerXrp.drops())}; } //------------------------------------------------------------------------------ diff --git a/src/tests/libxrpl/json/Value.cpp b/src/tests/libxrpl/json/Value.cpp index 994491b4db..03f565dffb 100644 --- a/src/tests/libxrpl/json/Value.cpp +++ b/src/tests/libxrpl/json/Value.cpp @@ -23,38 +23,38 @@ namespace xrpl { 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::kMinInt == Int(~(UInt(-1) / 2))); + static_assert(Value::kMaxInt == Int(UInt(-1) / 2)); + static_assert(Value::kMaxUInt == UInt(-1)); } TEST(json_value, construct_and_compare_Json_StaticString) { - static constexpr char kSAMPLE[]{"Contents of a json::StaticString"}; + static constexpr char kSample[]{"Contents of a json::StaticString"}; - static constexpr json::StaticString kTEST1(kSAMPLE); - char const* addrTest1{kTEST1}; + static constexpr json::StaticString kTest1(kSample); + char const* addrTest1{kTest1}; - EXPECT_EQ(addrTest1, &kSAMPLE[0]); - EXPECT_EQ(kTEST1.cStr(), &kSAMPLE[0]); + EXPECT_EQ(addrTest1, &kSample[0]); + EXPECT_EQ(kTest1.cStr(), &kSample[0]); - static constexpr json::StaticString kTEST2{"Contents of a json::StaticString"}; - static constexpr json::StaticString kTEST3{"Another StaticString"}; + static constexpr json::StaticString kTest2{"Contents of a json::StaticString"}; + static constexpr json::StaticString kTest3{"Another StaticString"}; - EXPECT_EQ(kTEST1, kTEST2); - EXPECT_NE(kTEST1, kTEST3); + EXPECT_EQ(kTest1, kTest2); + EXPECT_NE(kTest1, kTest3); - std::string const str{kSAMPLE}; - EXPECT_EQ(str, kTEST2); - EXPECT_NE(str, kTEST3); - EXPECT_EQ(kTEST2, str); - EXPECT_NE(kTEST3, str); + std::string const str{kSample}; + EXPECT_EQ(str, kTest2); + EXPECT_NE(str, kTest3); + EXPECT_EQ(kTest2, str); + EXPECT_NE(kTest3, str); } TEST(json_value, different_types) { // Exercise ValueType constructor - static constexpr json::StaticString kSTATIC_STR{"staticStr"}; + static constexpr json::StaticString kStaticStr{"staticStr"}; auto testCopy = [](json::ValueType typ) { json::Value val{typ}; @@ -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()); @@ -139,11 +139,11 @@ TEST(json_value, different_types) EXPECT_FALSE(stringV.isObjectOrNull()); } { - json::Value const staticStrV{kSTATIC_STR}; + json::Value const staticStrV{kStaticStr}; { 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,74 +1092,74 @@ 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; + static json::StaticString const kStaticThree("three"); + val[kStaticThree] = 3; val["two"] = 2; EXPECT_EQ(val.size(), 2); EXPECT_TRUE(val.isValidIndex(1)); EXPECT_FALSE(val.isValidIndex(2)); - EXPECT_EQ(val[kSTATIC_THREE], 3); + EXPECT_EQ(val[kStaticThree], 3); EXPECT_TRUE(val.isMember("two")); - EXPECT_TRUE(val.isMember(kSTATIC_THREE)); + EXPECT_TRUE(val.isMember(kStaticThree)); EXPECT_FALSE(val.isMember("key")); { json::Value const constVal = val; EXPECT_EQ(constVal["two"], 2); - EXPECT_EQ(constVal["four"].type(), json::NullValue); - EXPECT_EQ(constVal[kSTATIC_THREE], 3); + EXPECT_EQ(constVal["four"].type(), json::ValueType::Null); + EXPECT_EQ(constVal[kStaticThree], 3); EXPECT_TRUE(constVal.isMember("two")); - EXPECT_TRUE(constVal.isMember(kSTATIC_THREE)); + EXPECT_TRUE(constVal.isMember(kStaticThree)); EXPECT_FALSE(constVal.isMember("key")); EXPECT_EQ(val.get(std::string("two"), "backup"), 2); 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); - static json::StaticString const kSTATIC_THREE("three"); - val[kSTATIC_THREE] = 3; + val = json::Value(json::ValueType::Object); + static json::StaticString const kStaticThree("three"); + val[kStaticThree] = 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.removeMember(kStaticThree), 3); EXPECT_EQ(val.size(), 1); - EXPECT_EQ(val.removeMember(kSTATIC_THREE).type(), json::NullValue); + EXPECT_EQ(val.removeMember(kStaticThree).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; @@ -1297,14 +1295,14 @@ TEST(json_value, nest_limits) { // Within object nest limit - auto json{nest(std::min(10u, json::Reader::kNEST_LIMIT))}; + auto json{nest(std::min(10u, json::Reader::kNestLimit))}; json::Value j; EXPECT_TRUE(r.parse(json, j)); } { // Exceed object nest limit - auto json{nest(json::Reader::kNEST_LIMIT + 1)}; + auto json{nest(json::Reader::kNestLimit + 1)}; json::Value j; EXPECT_FALSE(r.parse(json, j)); } @@ -1321,7 +1319,7 @@ TEST(json_value, nest_limits) }; { // Exceed array nest limit - auto json{nest(json::Reader::kNEST_LIMIT + 1)}; + auto json{nest(json::Reader::kNestLimit + 1)}; json::Value j; EXPECT_FALSE(r.parse(json, j)); } @@ -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..a32ab5e20c 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; @@ -159,7 +159,7 @@ canonical_ARRAY() inline STObject canonical_OBJECT() { - return STObject{kSF_GENERIC}; + return STObject{sfGeneric}; } inline STPathSet diff --git a/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp b/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp index e74af94a5f..7479f0c63c 100644 --- a/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp +++ b/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp @@ -33,6 +33,7 @@ TEST(MPTokenIssuanceTests, BuilderSettersRoundTrip) auto const previousTxnLgrSeqValue = canonical_UINT32(); auto const domainIDValue = canonical_UINT256(); auto const mutableFlagsValue = canonical_UINT32(); + auto const referenceHoldingValue = canonical_UINT256(); MPTokenIssuanceBuilder builder{ issuerValue, @@ -50,6 +51,7 @@ TEST(MPTokenIssuanceTests, BuilderSettersRoundTrip) builder.setMPTokenMetadata(mPTokenMetadataValue); builder.setDomainID(domainIDValue); builder.setMutableFlags(mutableFlagsValue); + builder.setReferenceHolding(referenceHoldingValue); builder.setLedgerIndex(index); builder.setFlags(0x1u); @@ -152,6 +154,14 @@ TEST(MPTokenIssuanceTests, BuilderSettersRoundTrip) EXPECT_TRUE(entry.hasMutableFlags()); } + { + auto const& expected = referenceHoldingValue; + auto const actualOpt = entry.getReferenceHolding(); + ASSERT_TRUE(actualOpt.has_value()); + expectEqualField(expected, *actualOpt, "sfReferenceHolding"); + EXPECT_TRUE(entry.hasReferenceHolding()); + } + EXPECT_TRUE(entry.hasLedgerIndex()); auto const ledgerIndex = entry.getLedgerIndex(); ASSERT_TRUE(ledgerIndex.has_value()); @@ -178,6 +188,7 @@ TEST(MPTokenIssuanceTests, BuilderFromSleRoundTrip) auto const previousTxnLgrSeqValue = canonical_UINT32(); auto const domainIDValue = canonical_UINT256(); auto const mutableFlagsValue = canonical_UINT32(); + auto const referenceHoldingValue = canonical_UINT256(); auto sle = std::make_shared(MPTokenIssuance::entryType, index); @@ -194,6 +205,7 @@ TEST(MPTokenIssuanceTests, BuilderFromSleRoundTrip) sle->at(sfPreviousTxnLgrSeq) = previousTxnLgrSeqValue; sle->at(sfDomainID) = domainIDValue; sle->at(sfMutableFlags) = mutableFlagsValue; + sle->at(sfReferenceHolding) = referenceHoldingValue; MPTokenIssuanceBuilder builderFromSle{sle}; EXPECT_TRUE(builderFromSle.validate()); @@ -355,6 +367,19 @@ TEST(MPTokenIssuanceTests, BuilderFromSleRoundTrip) expectEqualField(expected, *fromBuilderOpt, "sfMutableFlags"); } + { + auto const& expected = referenceHoldingValue; + + auto const fromSleOpt = entryFromSle.getReferenceHolding(); + auto const fromBuilderOpt = entryFromBuilder.getReferenceHolding(); + + ASSERT_TRUE(fromSleOpt.has_value()); + ASSERT_TRUE(fromBuilderOpt.has_value()); + + expectEqualField(expected, *fromSleOpt, "sfReferenceHolding"); + expectEqualField(expected, *fromBuilderOpt, "sfReferenceHolding"); + } + EXPECT_EQ(entryFromSle.getKey(), index); EXPECT_EQ(entryFromBuilder.getKey(), index); } @@ -433,5 +458,7 @@ TEST(MPTokenIssuanceTests, OptionalFieldsReturnNullopt) EXPECT_FALSE(entry.getDomainID().has_value()); EXPECT_FALSE(entry.hasMutableFlags()); EXPECT_FALSE(entry.getMutableFlags().has_value()); + EXPECT_FALSE(entry.hasReferenceHolding()); + EXPECT_FALSE(entry.getReferenceHolding().has_value()); } } diff --git a/src/tests/libxrpl/protocol_autogen/transactions/LedgerStateFixTests.cpp b/src/tests/libxrpl/protocol_autogen/transactions/LedgerStateFixTests.cpp index 60034255c7..5b78f0cfdd 100644 --- a/src/tests/libxrpl/protocol_autogen/transactions/LedgerStateFixTests.cpp +++ b/src/tests/libxrpl/protocol_autogen/transactions/LedgerStateFixTests.cpp @@ -31,6 +31,7 @@ TEST(TransactionsLedgerStateFixTests, BuilderSettersRoundTrip) // Transaction-specific field values auto const ledgerFixTypeValue = canonical_UINT16(); auto const ownerValue = canonical_ACCOUNT(); + auto const bookDirectoryValue = canonical_UINT256(); LedgerStateFixBuilder builder{ accountValue, @@ -41,6 +42,7 @@ TEST(TransactionsLedgerStateFixTests, BuilderSettersRoundTrip) // Set optional fields builder.setOwner(ownerValue); + builder.setBookDirectory(bookDirectoryValue); auto tx = builder.build(publicKey, secretKey); @@ -72,6 +74,14 @@ TEST(TransactionsLedgerStateFixTests, BuilderSettersRoundTrip) EXPECT_TRUE(tx.hasOwner()); } + { + auto const& expected = bookDirectoryValue; + auto const actualOpt = tx.getBookDirectory(); + ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBookDirectory should be present"; + expectEqualField(expected, *actualOpt, "sfBookDirectory"); + EXPECT_TRUE(tx.hasBookDirectory()); + } + } // 2 & 4) Start from an STTx, construct a builder from it, build a new wrapper, @@ -90,6 +100,7 @@ TEST(TransactionsLedgerStateFixTests, BuilderFromStTxRoundTrip) // Transaction-specific field values auto const ledgerFixTypeValue = canonical_UINT16(); auto const ownerValue = canonical_ACCOUNT(); + auto const bookDirectoryValue = canonical_UINT256(); // Build an initial transaction LedgerStateFixBuilder initialBuilder{ @@ -100,6 +111,7 @@ TEST(TransactionsLedgerStateFixTests, BuilderFromStTxRoundTrip) }; initialBuilder.setOwner(ownerValue); + initialBuilder.setBookDirectory(bookDirectoryValue); auto initialTx = initialBuilder.build(publicKey, secretKey); @@ -131,6 +143,13 @@ TEST(TransactionsLedgerStateFixTests, BuilderFromStTxRoundTrip) expectEqualField(expected, *actualOpt, "sfOwner"); } + { + auto const& expected = bookDirectoryValue; + auto const actualOpt = rebuiltTx.getBookDirectory(); + ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBookDirectory should be present"; + expectEqualField(expected, *actualOpt, "sfBookDirectory"); + } + } // 3) Verify wrapper throws when constructed from wrong transaction type. @@ -190,6 +209,8 @@ TEST(TransactionsLedgerStateFixTests, OptionalFieldsReturnNullopt) // Verify optional fields are not present EXPECT_FALSE(tx.hasOwner()); EXPECT_FALSE(tx.getOwner().has_value()); + EXPECT_FALSE(tx.hasBookDirectory()); + EXPECT_FALSE(tx.getBookDirectory().has_value()); } } diff --git a/src/tests/libxrpl/tx/AccountSet.cpp b/src/tests/libxrpl/tx/AccountSet.cpp index 4187ec1115..d00df152ae 100644 --- a/src/tests/libxrpl/tx/AccountSet.cpp +++ b/src/tests/libxrpl/tx/AccountSet.cpp @@ -382,7 +382,7 @@ TEST(AccountSet, WalletID) // Clear the wallet locator by setting to zero EXPECT_EQ( - env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(beast::kZERO), alice) + env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(beast::kZero), alice) .ter, tesSUCCESS); env.close(); @@ -414,7 +414,7 @@ TEST(AccountSet, EmailHash) // Clear the email hash by setting to zero EXPECT_EQ( - env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(beast::kZERO), alice).ter, + env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(beast::kZero), alice).ter, tesSUCCESS); env.close(); @@ -619,7 +619,7 @@ TEST(AccountSet, Ticket) // Verify alice has 1 owner object (the ticket) EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 1u); // Verify ticket exists - EXPECT_TRUE(env.getClosedLedger().exists(keylet::kTICKET(alice.id(), ticketSeq))); + EXPECT_TRUE(env.getClosedLedger().exists(keylet::kTicket(alice.id(), ticketSeq))); // Try using a ticket that alice doesn't have EXPECT_EQ( @@ -629,7 +629,7 @@ TEST(AccountSet, Ticket) env.close(); // Verify ticket still exists - EXPECT_TRUE(env.getClosedLedger().exists(keylet::kTICKET(alice.id(), ticketSeq))); + EXPECT_TRUE(env.getClosedLedger().exists(keylet::kTicket(alice.id(), ticketSeq))); // Get alice's sequence before using the ticket std::uint32_t const aliceSeq = env.getAccountRoot(alice.id()).getSequence(); @@ -642,7 +642,7 @@ TEST(AccountSet, Ticket) // Verify ticket is consumed (no owner objects) EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 0u); - EXPECT_FALSE(env.getClosedLedger().exists(keylet::kTICKET(alice.id(), ticketSeq))); + EXPECT_FALSE(env.getClosedLedger().exists(keylet::kTicket(alice.id(), ticketSeq))); // Verify alice's sequence did NOT advance (ticket use doesn't increment seq) EXPECT_EQ(env.getAccountRoot(alice.id()).getSequence(), aliceSeq); diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp index b5a643568b..a474c9c339 100644 --- a/src/xrpld/app/consensus/RCLConsensus.cpp +++ b/src/xrpld/app/consensus/RCLConsensus.cpp @@ -130,7 +130,7 @@ RCLConsensus::Adaptor::Adaptor( JLOG(j_.info()) << "Consensus engine started (cookie: " + std::to_string(valCookie_) + ")"; - if (validatorKeys_.nodeID != beast::kZERO && validatorKeys_.keys) + if (validatorKeys_.nodeID != beast::kZero && validatorKeys_.keys) { JLOG(j_.info()) << "Validator identity: " << toBase58(TokenType::NodePublic, validatorKeys_.keys->masterPublicKey); @@ -214,8 +214,8 @@ RCLConsensus::Adaptor::share(RCLCxTx const& tx) msg.set_rawtransaction(slice.data(), slice.size()); msg.set_status(protocol::tsNEW); msg.set_receivetimestamp(app_.getTimeKeeper().now().time_since_epoch().count()); - static std::set const kSKIP{}; - app_.getOverlay().relay(tx.id(), msg, kSKIP); + static std::set const kSkip{}; + app_.getOverlay().relay(tx.id(), msg, kSkip); } else { @@ -400,13 +400,13 @@ 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), RCLCxPeerPos::Proposal{ initialLedger->header().parentHash, - RCLCxPeerPos::Proposal::kSEQ_JOIN, + RCLCxPeerPos::Proposal::kSeqJoin, setHash, closeTime, app_.getTimeKeeper().closeTime(), @@ -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(); @@ -557,7 +557,7 @@ RCLConsensus::Adaptor::doAccept( auto const wait = curr - seq; - if (wait && (wait % kCENSORSHIP_WARN_INTERNAL == 0)) + if (wait && (wait % kCensorshipWarnInternal == 0)) { std::ostringstream ss; ss << "Potential Censorship: Eligible tx " << id @@ -733,8 +733,8 @@ RCLConsensus::Adaptor::notify( s.set_ledgerseq(ledger.seq()); s.set_networktime(app_.getTimeKeeper().now().time_since_epoch().count()); s.set_ledgerhashprevious( - ledger.parentID().begin(), std::decay_t::kBYTES); - s.set_ledgerhash(ledger.id().begin(), std::decay_t::kBYTES); + ledger.parentID().begin(), std::decay_t::kBytes); + s.set_ledgerhash(ledger.id().begin(), std::decay_t::kBytes); std::uint32_t uMin = 0, uMax = 0; if (!ledgerMaster_.getFullValidatedRange(uMin, uMax)) @@ -831,7 +831,7 @@ RCLConsensus::Adaptor::validate(RCLCxLedger const& ledger, RCLTxSet const& txns, v.setFieldU32(sfLedgerSequence, ledger.seq()); if (proposing) - v.setFlag(kVF_FULL_VALIDATION); + v.setFlag(kVfFullValidation); // Attest to the hash of what we consider to be the last fully // validated ledger. This may be the hash of the ledger we are @@ -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/RCLConsensus.h b/src/xrpld/app/consensus/RCLConsensus.h index 62a83d107e..32759300fa 100644 --- a/src/xrpld/app/consensus/RCLConsensus.h +++ b/src/xrpld/app/consensus/RCLConsensus.h @@ -33,7 +33,7 @@ class RCLConsensus { /** Warn for transactions that haven't been included every so many ledgers. */ - constexpr static unsigned int kCENSORSHIP_WARN_INTERNAL = 15; + static constexpr unsigned int kCensorshipWarnInternal = 15; // Implements the Adaptor template interface required by Consensus. class Adaptor 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..8520fc941f 100644 --- a/src/xrpld/app/ledger/LedgerHistory.cpp +++ b/src/xrpld/app/ledger/LedgerHistory.cpp @@ -36,14 +36,14 @@ namespace xrpl { LedgerHistory::LedgerHistory(beast::insight::Collector::ptr const& collector, Application& app) : app_(app) , collector_(collector) - , mismatch_counter_(collector->makeCounter("ledger.history", "mismatch")) - , ledgers_by_hash_( + , mismatchCounter_(collector->makeCounter("ledger.history", "mismatch")) + , ledgersByHash_( "LedgerCache", app_.config().getValueFor(SizedItem::LedgerSize), std::chrono::seconds{app_.config().getValueFor(SizedItem::LedgerAge)}, stopwatch(), app_.getJournal("TaggedCache")) - , consensus_validated_( + , consensusValidated_( "ConsensusValidated", 64, std::chrono::minutes{5}, @@ -62,10 +62,9 @@ LedgerHistory::insert(std::shared_ptr const& ledger, bool validate XRPL_ASSERT( ledger->stateMap().getHash().isNonZero(), "xrpl::LedgerHistory::insert : nonzero hash"); - std::unique_lock const sl(ledgers_by_hash_.peekMutex()); + std::unique_lock const sl(ledgersByHash_.peekMutex()); - bool const alreadyHad = - ledgers_by_hash_.canonicalizeReplaceCache(ledger->header().hash, ledger); + bool const alreadyHad = ledgersByHash_.canonicalizeReplaceCache(ledger->header().hash, ledger); if (validated) ledgersByIndex_[ledger->header().seq] = ledger->header().hash; @@ -75,7 +74,7 @@ LedgerHistory::insert(std::shared_ptr const& ledger, bool validate LedgerHash LedgerHistory::getLedgerHash(LedgerIndex index) { - std::unique_lock const sl(ledgers_by_hash_.peekMutex()); + std::unique_lock const sl(ledgersByHash_.peekMutex()); if (auto it = ledgersByIndex_.find(index); it != ledgersByIndex_.end()) return it->second; return {}; @@ -85,7 +84,7 @@ std::shared_ptr LedgerHistory::getLedgerBySeq(LedgerIndex index) { { - std::unique_lock sl(ledgers_by_hash_.peekMutex()); + std::unique_lock sl(ledgersByHash_.peekMutex()); auto it = ledgersByIndex_.find(index); if (it != ledgersByIndex_.end()) @@ -97,7 +96,7 @@ LedgerHistory::getLedgerBySeq(LedgerIndex index) } Rules const rules{app_.config().features}; - Fees const fees = app_.config().FEES.toFees(); + Fees const fees = app_.config().fees.toFees(); std::shared_ptr ret = loadByIndex(index, rules, fees, app_); if (!ret) @@ -108,11 +107,11 @@ LedgerHistory::getLedgerBySeq(LedgerIndex index) { // Add this ledger to the local tracking by index - std::unique_lock const sl(ledgers_by_hash_.peekMutex()); + std::unique_lock const sl(ledgersByHash_.peekMutex()); XRPL_ASSERT( ret->isImmutable(), "xrpl::LedgerHistory::getLedgerBySeq : immutable result ledger"); - ledgers_by_hash_.canonicalizeReplaceClient(ret->header().hash, ret); + ledgersByHash_.canonicalizeReplaceClient(ret->header().hash, ret); ledgersByIndex_[ret->header().seq] = ret->header().hash; return (ret->header().seq == index) ? ret : nullptr; } @@ -121,7 +120,7 @@ LedgerHistory::getLedgerBySeq(LedgerIndex index) std::shared_ptr LedgerHistory::getLedgerByHash(LedgerHash const& hash) { - auto ret = ledgers_by_hash_.fetch(hash); + auto ret = ledgersByHash_.fetch(hash); if (ret) { @@ -137,7 +136,7 @@ LedgerHistory::getLedgerByHash(LedgerHash const& hash) } Rules const rules{app_.config().features}; - Fees const fees = app_.config().FEES.toFees(); + Fees const fees = app_.config().fees.toFees(); ret = loadByHash(hash, rules, fees, app_); if (!ret) @@ -148,7 +147,7 @@ LedgerHistory::getLedgerByHash(LedgerHash const& hash) XRPL_ASSERT( ret->header().hash == hash, "xrpl::LedgerHistory::getLedgerByHash : loaded ledger hash match"); - ledgers_by_hash_.canonicalizeReplaceClient(ret->header().hash, ret); + ledgersByHash_.canonicalizeReplaceClient(ret->header().hash, ret); XRPL_ASSERT( ret->header().hash == hash, "xrpl::LedgerHistory::getLedgerByHash : result hash match"); @@ -164,7 +163,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 +244,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 +285,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); } } @@ -319,7 +318,7 @@ LedgerHistory::handleMismatch( json::Value const& consensus) { XRPL_ASSERT(built != valid, "xrpl::LedgerHistory::handleMismatch : unequal hashes"); - ++mismatch_counter_; + ++mismatchCounter_; auto builtLedger = getLedgerByHash(built); auto validLedger = getLedgerByHash(valid); @@ -430,10 +429,10 @@ LedgerHistory::builtLedger( LedgerHash const hash = ledger->header().hash; XRPL_ASSERT(!hash.isZero(), "xrpl::LedgerHistory::builtLedger : nonzero hash"); - std::unique_lock const sl(consensus_validated_.peekMutex()); + std::unique_lock const sl(consensusValidated_.peekMutex()); auto entry = std::make_shared(); - consensus_validated_.canonicalizeReplaceClient(index, entry); + consensusValidated_.canonicalizeReplaceClient(index, entry); if (entry->validated && !entry->built) { @@ -469,10 +468,10 @@ LedgerHistory::validatedLedger( LedgerHash const hash = ledger->header().hash; XRPL_ASSERT(!hash.isZero(), "xrpl::LedgerHistory::validatedLedger : nonzero hash"); - std::unique_lock const sl(consensus_validated_.peekMutex()); + std::unique_lock const sl(consensusValidated_.peekMutex()); auto entry = std::make_shared(); - consensus_validated_.canonicalizeReplaceClient(index, entry); + consensusValidated_.canonicalizeReplaceClient(index, entry); if (entry->built && !entry->validated) { @@ -504,7 +503,7 @@ LedgerHistory::validatedLedger( bool LedgerHistory::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash) { - std::unique_lock const sl(ledgers_by_hash_.peekMutex()); + std::unique_lock const sl(ledgersByHash_.peekMutex()); auto it = ledgersByIndex_.find(ledgerIndex); if ((it != ledgersByIndex_.end()) && (it->second != ledgerHash)) @@ -518,11 +517,11 @@ LedgerHistory::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash) void LedgerHistory::clearLedgerCachePrior(LedgerIndex seq) { - for (LedgerHash const it : ledgers_by_hash_.getKeys()) + for (LedgerHash const it : ledgersByHash_.getKeys()) { auto const ledger = getLedgerByHash(it); if (!ledger || ledger->header().seq < seq) - ledgers_by_hash_.del(it, false); + ledgersByHash_.del(it, false); } } diff --git a/src/xrpld/app/ledger/LedgerHistory.h b/src/xrpld/app/ledger/LedgerHistory.h index 01c88b1517..057de7b1bc 100644 --- a/src/xrpld/app/ledger/LedgerHistory.h +++ b/src/xrpld/app/ledger/LedgerHistory.h @@ -30,7 +30,7 @@ public: float getCacheHitRate() { - return ledgers_by_hash_.getHitRate(); + return ledgersByHash_.getHitRate(); } /** Get a ledger given its sequence number */ @@ -53,8 +53,8 @@ public: void sweep() { - ledgers_by_hash_.sweep(); - consensus_validated_.sweep(); + ledgersByHash_.sweep(); + consensusValidated_.sweep(); } /** Report that we have locally built a particular ledger */ @@ -99,11 +99,11 @@ private: Application& app_; beast::insight::Collector::ptr collector_; - beast::insight::Counter mismatch_counter_; + beast::insight::Counter mismatchCounter_; using LedgersByHash = TaggedCache; - LedgersByHash ledgers_by_hash_; + LedgersByHash ledgersByHash_; // Maps ledger indexes to the corresponding hashes // For debug and logging purposes @@ -121,7 +121,7 @@ private: std::optional consensus; }; using ConsensusValidated = TaggedCache; - ConsensusValidated consensus_validated_; + ConsensusValidated consensusValidated_; // Maps ledger indexes to the corresponding hash. std::map ledgersByIndex_; // validated ledgers diff --git a/src/xrpld/app/ledger/LedgerMaster.h b/src/xrpld/app/ledger/LedgerMaster.h index 0b3310ea79..885ab6db25 100644 --- a/src/xrpld/app/ledger/LedgerMaster.h +++ b/src/xrpld/app/ledger/LedgerMaster.h @@ -347,20 +347,20 @@ private: bool const standalone_; // How many ledgers before the current ledger do we allow peers to request? - std::uint32_t const fetch_depth_; + std::uint32_t const fetchDepth_; // How much history do we want to keep - std::uint32_t const ledger_history_; + std::uint32_t const ledgerHistorySize_; - std::uint32_t const ledger_fetch_size_; + std::uint32_t const ledgerFetchSize_; - TaggedCache fetch_packs_; + TaggedCache fetchPacks_; - std::uint32_t fetch_seq_{0}; + std::uint32_t fetchSeq_{0}; // Try to keep a validator from switching from test to live network // without first wiping the database. - LedgerIndex const max_ledger_difference_{1000000}; + LedgerIndex const maxLedgerDifference_{1000000}; // Time that the previous upgrade warning was issued. TimeKeeper::time_point upgradeWarningPrevTime_; diff --git a/src/xrpld/app/ledger/LedgerReplayer.h b/src/xrpld/app/ledger/LedgerReplayer.h index 5d537bfd24..e2d256f597 100644 --- a/src/xrpld/app/ledger/LedgerReplayer.h +++ b/src/xrpld/app/ledger/LedgerReplayer.h @@ -17,33 +17,33 @@ class LedgerReplayClient; namespace LedgerReplayParameters { // timeout value for LedgerReplayTask -auto constexpr kTASK_TIMEOUT = std::chrono::milliseconds{500}; +constexpr auto kTaskTimeout = std::chrono::milliseconds{500}; // for LedgerReplayTask to calculate max allowed timeouts -// = max( kTASK_MAX_TIMEOUTS_MINIMUM, -// (# of ledger to replay) * kTASK_MAX_TIMEOUTS_MULTIPLIER) -std::uint32_t constexpr kTASK_MAX_TIMEOUTS_MULTIPLIER = 2; -std::uint32_t constexpr kTASK_MAX_TIMEOUTS_MINIMUM = 10; +// = max( kTaskMaxTimeoutsMinimum, +// (# of ledger to replay) * kTaskMaxTimeoutsMultiplier) +constexpr std::uint32_t kTaskMaxTimeoutsMultiplier = 2; +constexpr std::uint32_t kTaskMaxTimeoutsMinimum = 10; // timeout value for subtasks: LedgerDeltaAcquire and SkipListAcquire -auto constexpr kSUB_TASK_TIMEOUT = std::chrono::milliseconds{250}; +constexpr auto kSubTaskTimeout = std::chrono::milliseconds{250}; // max of allowed subtask timeouts -std::uint32_t constexpr kSUB_TASK_MAX_TIMEOUTS = 10; +constexpr std::uint32_t kSubTaskMaxTimeouts = 10; // max number of peers that do not support the ledger replay feature // returned by the PeerSet before switch to fallback -auto constexpr kMAX_NO_FEATURE_PEER_COUNT = 2; +constexpr auto kMaxNoFeaturePeerCount = 2; // subtask timeout value after fallback -auto constexpr kSUB_TASK_FALLBACK_TIMEOUT = std::chrono::milliseconds{1000}; +constexpr auto kSubTaskFallbackTimeout = std::chrono::milliseconds{1000}; // for LedgerReplayer to limit the number of LedgerReplayTask -std::uint32_t constexpr kMAX_TASKS = 10; +constexpr std::uint32_t kMaxTasks = 10; // for LedgerReplayer to limit the number of ledgers to replay in one task -std::uint32_t constexpr kMAX_TASK_SIZE = 256; +constexpr std::uint32_t kMaxTaskSize = 256; // to limit the number of LedgerReplay related jobs in JobQueue -std::uint32_t constexpr kMAX_QUEUED_TASKS = 100; +constexpr std::uint32_t kMaxQueuedTasks = 100; } // namespace LedgerReplayParameters /** 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/LocalTxs.h b/src/xrpld/app/ledger/LocalTxs.h index 779dd4f02c..1575a18075 100644 --- a/src/xrpld/app/ledger/LocalTxs.h +++ b/src/xrpld/app/ledger/LocalTxs.h @@ -17,7 +17,7 @@ public: // The number of ledgers to hold a transaction is essentially // arbitrary. It should be sufficient to allow the transaction to // get into a fully-validated ledger. - static constexpr int kHOLD_LEDGERS = 5; + static constexpr int kHoldLedgers = 5; virtual ~LocalTxs() = default; diff --git a/src/xrpld/app/ledger/OpenLedger.h b/src/xrpld/app/ledger/OpenLedger.h index 884b6b02db..02e073bc9a 100644 --- a/src/xrpld/app/ledger/OpenLedger.h +++ b/src/xrpld/app/ledger/OpenLedger.h @@ -33,8 +33,8 @@ class OpenLedger private: beast::Journal const j_; CachedSLEs& cache_; - std::mutex mutable modify_mutex_; - std::mutex mutable current_mutex_; + std::mutex mutable modifyMutex_; + std::mutex mutable currentMutex_; std::shared_ptr current_; public: 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/BuildLedger.cpp b/src/xrpld/app/ledger/detail/BuildLedger.cpp index 5143769178..a77c1c9c50 100644 --- a/src/xrpld/app/ledger/detail/BuildLedger.cpp +++ b/src/xrpld/app/ledger/detail/BuildLedger.cpp @@ -73,7 +73,7 @@ buildLedgerImpl( // Accept ledger XRPL_ASSERT( - built->header().seq < kXRP_LEDGER_EARLIEST_FEES || built->read(keylet::fees()), + built->header().seq < kXrpLedgerEarliestFees || built->read(keylet::fees()), "xrpl::buildLedgerImpl : valid ledger fees"); built->setAccepted(closeTime, closeResolution, closeTimeCorrect); @@ -225,7 +225,7 @@ buildLedger( return buildLedgerImpl( replayData.parent(), replayLedger->header().closeTime, - ((replayLedger->header().closeFlags & kS_LCF_NO_CONSENSUS_TIME) == 0), + ((replayLedger->header().closeFlags & kSLcfNoConsensusTime) == 0), replayLedger->header().closeTimeResolution, app, j, diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp index b4082485d3..9ba7bdf22e 100644 --- a/src/xrpld/app/ledger/detail/InboundLedger.cpp +++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp @@ -55,39 +55,17 @@ 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 kPeerCountStart = 5; // Number of peers to start with +static constexpr auto kPeerCountAdd = 3; // Number of peers to add on a timeout +static constexpr auto kLedgerTimeoutRetriesMax = 6; // how many timeouts before we give up +static constexpr auto kLedgerBecomeAggressiveThreshold = + 4; // how many timeouts before we get aggressive +static constexpr auto kMissingNodesFind = 256; // Number of nodes to find initially +static constexpr auto kReqNodesReply = 128; // Number of nodes to request for a reply +static constexpr auto kReqNodes = 12; // Number of nodes to request blindly // millisecond for each ledger timeout -auto constexpr kLEDGER_ACQUIRE_TIMEOUT = 3000ms; +constexpr auto kLedgerAcquireTimeout = 3000ms; InboundLedger::InboundLedger( Application& app, @@ -99,7 +77,7 @@ InboundLedger::InboundLedger( : TimeoutCounter( app, hash, - kLEDGER_ACQUIRE_TIMEOUT, + kLedgerAcquireTimeout, {.jobType = JtLedgerData, .jobName = "InboundLedger", .jobLimit = 5}, app.getJournal("InboundLedger")) , clock_(clock) @@ -131,7 +109,7 @@ InboundLedger::init(ScopedLockType& collectionLock) JLOG(journal_.debug()) << "Acquiring ledger we already have in " << " local store. " << hash_; XRPL_ASSERT( - ledger_->header().seq < kXRP_LEDGER_EARLIEST_FEES || ledger_->read(keylet::fees()), + ledger_->header().seq < kXrpLedgerEarliestFees || ledger_->read(keylet::fees()), "xrpl::InboundLedger::init : valid ledger fees"); ledger_->setImmutable(); @@ -353,7 +331,7 @@ InboundLedger::tryDB(NodeStore::Database& srcDB) JLOG(journal_.debug()) << "Had everything locally"; complete_ = true; XRPL_ASSERT( - ledger_->header().seq < kXRP_LEDGER_EARLIEST_FEES || ledger_->read(keylet::fees()), + ledger_->header().seq < kXrpLedgerEarliestFees || ledger_->read(keylet::fees()), "xrpl::InboundLedger::tryDB : valid ledger fees"); ledger_->setImmutable(); } @@ -372,7 +350,7 @@ InboundLedger::onTimer(bool wasProgress, ScopedLockType&) return; } - if (timeouts_ > LedgerTimeoutRetriesMax) + if (timeouts_ > kLedgerTimeoutRetriesMax) { if (seq_ != 0) { @@ -413,7 +391,7 @@ void InboundLedger::addPeers() { peerSet_->addPeers( - (getPeerCount() == 0) ? PeerCountStart : PeerCountAdd, + (getPeerCount() == 0) ? kPeerCountStart : kPeerCountAdd, [this](auto peer) { return peer->hasLedger(hash_, seq_); }, [this](auto peer) { // For historical nodes, do not trigger too soon @@ -449,7 +427,7 @@ InboundLedger::done() if (complete_ && !failed_ && ledger_) { XRPL_ASSERT( - ledger_->header().seq < kXRP_LEDGER_EARLIEST_FEES || ledger_->read(keylet::fees()), + ledger_->header().seq < kXrpLedgerEarliestFees || ledger_->read(keylet::fees()), "xrpl::InboundLedger::done : valid ledger fees"); ledger_->setImmutable(); switch (reason_) @@ -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_ > kLedgerBecomeAggressiveThreshold)) { 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(kMissingNodesFind, &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(kMissingNodesFind, &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) ? kReqNodesReply : kReqNodes; if (nodes.size() > limit) nodes.resize(limit); @@ -1055,7 +1033,7 @@ InboundLedger::processData(std::shared_ptr peer, protocol::TMLedgerData& p if (packet.nodes().empty()) { JLOG(journal_.warn()) << peer->id() << ": empty header data"; - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "ledger_data empty header"); + peer->charge(Resource::kFeeMalformedRequest, "ledger_data empty header"); return -1; } @@ -1070,7 +1048,7 @@ InboundLedger::processData(std::shared_ptr peer, protocol::TMLedgerData& p if (!takeHeader(packet.nodes(0).nodedata())) { JLOG(journal_.warn()) << "Got invalid header data"; - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "ledger_data invalid header"); + peer->charge(Resource::kFeeMalformedRequest, "ledger_data invalid header"); return -1; } @@ -1093,7 +1071,7 @@ InboundLedger::processData(std::shared_ptr peer, protocol::TMLedgerData& p { JLOG(journal_.warn()) << "Included AS/TX root invalid: " << ex.what(); using namespace std::string_literals; - peer->charge(Resource::kFEE_INVALID_DATA, "ledger_data "s + ex.what()); + peer->charge(Resource::kFeeInvalidData, "ledger_data "s + ex.what()); return -1; } @@ -1109,7 +1087,7 @@ InboundLedger::processData(std::shared_ptr peer, protocol::TMLedgerData& p if (packet.nodes().empty()) { JLOG(journal_.info()) << peer->id() << ": response with no nodes"; - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "ledger_data no nodes"); + peer->charge(Resource::kFeeMalformedRequest, "ledger_data no nodes"); return -1; } @@ -1121,7 +1099,7 @@ InboundLedger::processData(std::shared_ptr peer, protocol::TMLedgerData& p if (!node.has_nodeid() || !node.has_nodedata()) { JLOG(journal_.warn()) << "Got bad node"; - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "ledger_data bad node"); + peer->charge(Resource::kFeeMalformedRequest, "ledger_data bad node"); return -1; } } @@ -1223,7 +1201,7 @@ void InboundLedger::runData() { // Maximum number of peers to request data from - constexpr std::size_t kMAX_USEFUL_PEERS = 6; + static constexpr std::size_t kMaxUsefulPeers = 6; decltype(receivedData_) data; @@ -1261,7 +1239,7 @@ InboundLedger::runData() // Select a random sample of the peers that gives us the most nodes that are // useful dataCounts.prune(); - dataCounts.sampleN(kMAX_USEFUL_PEERS, [&](std::shared_ptr const& peer) { + dataCounts.sampleN(kMaxUsefulPeers, [&](std::shared_ptr const& peer) { trigger(peer, TriggerReason::Reply); }); } @@ -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..95e3e46f73 100644 --- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp +++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp @@ -53,7 +53,7 @@ private: public: // How long before we try again to acquire the same ledger - static constexpr std::chrono::minutes const kREACQUIRE_INTERVAL{5}; + static constexpr std::chrono::minutes kReacquireInterval{5}; InboundLedgersImp( Application& app, @@ -232,7 +232,7 @@ public: { ScopedLockType const sl(lock_); - beast::expire(recentFailures_, kREACQUIRE_INTERVAL); + beast::expire(recentFailures_, kReacquireInterval); return recentFailures_.find(h) != recentFailures_.end(); } @@ -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; @@ -405,7 +405,7 @@ public: } } - beast::expire(recentFailures_, kREACQUIRE_INTERVAL); + beast::expire(recentFailures_, kReacquireInterval); } JLOG(j_.debug()) diff --git a/src/xrpld/app/ledger/detail/InboundTransactions.cpp b/src/xrpld/app/ledger/detail/InboundTransactions.cpp index 598a8b5c4c..d744075869 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 kStartPeers = 2; // ideal number of peers to start with +static constexpr auto kSetKeepRounds = 3; // how many rounds to keep a set class InboundTransactionSet { @@ -120,7 +114,7 @@ public: obj.seq = seq_; } - ta->init(StartPeers); + ta->init(kStartPeers); return {}; } @@ -142,7 +136,7 @@ public: if (ta == nullptr) { - peer->charge(Resource::kFEE_USELESS_DATA, "ledger_data"); + peer->charge(Resource::kFeeUselessData, "ledger_data"); return; } @@ -153,7 +147,7 @@ public: { if (!node.has_nodeid() || !node.has_nodedata()) { - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "ledger_data"); + peer->charge(Resource::kFeeMalformedRequest, "ledger_data"); return; } @@ -161,7 +155,7 @@ public: if (!id) { - peer->charge(Resource::kFEE_INVALID_DATA, "ledger_data"); + peer->charge(Resource::kFeeInvalidData, "ledger_data"); return; } @@ -169,7 +163,7 @@ public: } if (!ta->takeNodes(data, peer).isUseful()) - peer->charge(Resource::kFEE_USELESS_DATA, "ledger_data not useful"); + peer->charge(Resource::kFeeUselessData, "ledger_data not useful"); } void @@ -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 < kSetKeepRounds) ? 0 : (seq - kSetKeepRounds); + std::uint32_t const maxSeq = seq + kSetKeepRounds; while (it != map_.end()) { diff --git a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp index 86201ca627..9f2db9d2f2 100644 --- a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp +++ b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp @@ -257,7 +257,7 @@ private: app_.getInboundLedgers().acquire( ledger->header().hash, ledger->header().seq, InboundLedger::Reason::GENERIC); } - return hash ? *hash : beast::kZERO; // kludge + return hash ? *hash : beast::kZero; // kludge } /** Process a single ledger @@ -286,7 +286,7 @@ private: } Rules const rules{app_.config().features}; - Fees const fees = app_.config().FEES.toFees(); + Fees const fees = app_.config().fees.toFees(); auto const dbLedger = loadByIndex(ledgerIndex, rules, fees, app_); if (!dbLedger || (dbLedger->header().hash != ledgerHash) || (dbLedger->header().parentHash != nodeLedger->header().parentHash)) diff --git a/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp b/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp index 9ebe890ae1..4c79068bca 100644 --- a/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp +++ b/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp @@ -41,10 +41,10 @@ LedgerDeltaAcquire::LedgerDeltaAcquire( : TimeoutCounter( app, ledgerHash, - LedgerReplayParameters::kSUB_TASK_TIMEOUT, + LedgerReplayParameters::kSubTaskTimeout, {.jobType = JtReplayTask, .jobName = "LedReplDelta", - .jobLimit = LedgerReplayParameters::kMAX_QUEUED_TASKS}, + .jobLimit = LedgerReplayParameters::kMaxQueuedTasks}, app.getJournal("LedgerReplayDelta")) , inboundLedgers_(inboundLedgers) , ledgerSeq_(ledgerSeq) @@ -99,10 +99,10 @@ LedgerDeltaAcquire::trigger(std::size_t limit, ScopedLockType& sl) } else { - if (++noFeaturePeerCount_ >= LedgerReplayParameters::kMAX_NO_FEATURE_PEER_COUNT) + if (++noFeaturePeerCount_ >= LedgerReplayParameters::kMaxNoFeaturePeerCount) { JLOG(journal_.debug()) << "Fall back for " << hash_; - timerInterval_ = LedgerReplayParameters::kSUB_TASK_FALLBACK_TIMEOUT; + timerInterval_ = LedgerReplayParameters::kSubTaskFallbackTimeout; fallBack_ = true; } } @@ -117,7 +117,7 @@ void LedgerDeltaAcquire::onTimer(bool progress, ScopedLockType& sl) { JLOG(journal_.trace()) << "timeouts_=" << timeouts_ << " for " << hash_; - if (timeouts_ > LedgerReplayParameters::kSUB_TASK_MAX_TIMEOUTS) + if (timeouts_ > LedgerReplayParameters::kSubTaskMaxTimeouts) { failed_ = true; JLOG(journal_.debug()) << "too many timeouts " << hash_; diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp index 34ded1d14f..9baad0ec90 100644 --- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp +++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp @@ -81,13 +81,13 @@ namespace xrpl { // Don't catch up more than 100 ledgers (cannot exceed 256) -static constexpr int kMAX_LEDGER_GAP{100}; +static constexpr int kMaxLedgerGap{100}; // Don't acquire history if ledger is too old -static constexpr std::chrono::minutes kMAX_LEDGER_AGE_ACQUIRE{1}; +static constexpr std::chrono::minutes kMaxLedgerAgeAcquire{1}; // Don't acquire history if write load is too high -static constexpr int kMAX_WRITE_LOAD_ACQUIRE{8192}; +static constexpr int kMaxWriteLoadAcquire{8192}; // Helper function for LedgerMaster::doAdvance() // Return true if candidateLedger should be fetched from the network. @@ -127,10 +127,10 @@ LedgerMaster::LedgerMaster( , journal_(journal) , ledgerHistory_(collector, app) , standalone_(app_.config().standalone()) - , fetch_depth_(app_.getSHAMapStore().clampFetchDepth(app_.config().FETCH_DEPTH)) - , ledger_history_(app_.config().LEDGER_HISTORY) - , ledger_fetch_size_(app_.config().getValueFor(SizedItem::LedgerFetch)) - , fetch_packs_( + , fetchDepth_(app_.getSHAMapStore().clampFetchDepth(app_.config().fetchDepth)) + , ledgerHistorySize_(app_.config().ledgerHistory) + , ledgerFetchSize_(app_.config().getValueFor(SizedItem::LedgerFetch)) + , fetchPacks_( "FetchPack", 65536, std::chrono::seconds{45}, @@ -189,12 +189,12 @@ LedgerMaster::getPublishedLedgerAge() std::chrono::seconds ret = app_.getTimeKeeper().closeTime().time_since_epoch(); ret -= pubClose; ret = (ret > 0s) ? ret : 0s; - static std::chrono::seconds kLAST_RET = -1s; + static std::chrono::seconds kLastRet = -1s; - if (ret != kLAST_RET) + if (ret != kLastRet) { JLOG(journal_.trace()) << "Published ledger age is " << ret.count(); - kLAST_RET = ret; + kLastRet = ret; } return ret; } @@ -214,12 +214,12 @@ LedgerMaster::getValidatedLedgerAge() std::chrono::seconds ret = app_.getTimeKeeper().closeTime().time_since_epoch(); ret -= valClose; ret = (ret > 0s) ? ret : 0s; - static std::chrono::seconds kLAST_RET = -1s; + static std::chrono::seconds kLastRet = -1s; - if (ret != kLAST_RET) + if (ret != kLastRet) { JLOG(journal_.trace()) << "Validated ledger age is " << ret.count(); - kLAST_RET = ret; + kLastRet = ret; } return ret; } @@ -286,9 +286,9 @@ LedgerMaster::setValidLedger(std::shared_ptr const& l) validLedgerSign_ = signTime.time_since_epoch().count(); XRPL_ASSERT( validLedgerSeq_ || !app_.getMaxDisallowedLedger() || - l->header().seq + max_ledger_difference_ > app_.getMaxDisallowedLedger(), + l->header().seq + maxLedgerDifference_ > app_.getMaxDisallowedLedger(), "xrpl::LedgerMaster::setValidLedger : valid ledger sequence"); - (void)max_ledger_difference_; + (void)maxLedgerDifference_; validLedgerSeq_ = l->header().seq; app_.getOPs().updateLocalTx(*l); @@ -629,9 +629,9 @@ LedgerMaster::getEarliestFetch() // unless that creates a larger range than allowed std::uint32_t e = getClosedLedger()->header().seq; - if (e > fetch_depth_) + if (e > fetchDepth_) { - e -= fetch_depth_; + e -= fetchDepth_; } else { @@ -1047,12 +1047,12 @@ LedgerMaster::checkAccept(std::shared_ptr const& ledger) // and (3) the calculation won't cause divide-by-zero. if (higherVersionCount > 0 && xrpldCount > 0) { - constexpr std::size_t kREPORTING_PERCENT = 90; - constexpr std::size_t kCUTOFF_PERCENT = 60; + static constexpr std::size_t kReportingPercent = 90; + static constexpr std::size_t kCutoffPercent = 60; auto const unlSize{app_.getValidators().getQuorumKeys().second.size()}; needPrint = unlSize > 0 && - calculatePercent(vals.size(), unlSize) >= kREPORTING_PERCENT && - calculatePercent(higherVersionCount, xrpldCount) >= kCUTOFF_PERCENT; + calculatePercent(vals.size(), unlSize) >= kReportingPercent && + calculatePercent(higherVersionCount, xrpldCount) >= kCutoffPercent; } } // To throttle the warning messages, instead of printing a warning @@ -1219,7 +1219,7 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock& sl return {validLedger_.get()}; } - if (validLedgerSeq_ > (pubLedgerSeq_ + kMAX_LEDGER_GAP)) + if (validLedgerSeq_ > (pubLedgerSeq_ + kMaxLedgerGap)) { JLOG(journal_.warn()) << "Gap in validated ledger stream " << pubLedgerSeq_ << " - " << validLedgerSeq_ - 1; @@ -1257,7 +1257,7 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock& sl // VFALCO TODO Restructure this code so that zero is not // used. if (!hash) - hash = beast::kZERO; // kludge + hash = beast::kZero; // kludge if (seq == valSeq) { // We need to publish the ledger we just fully validated @@ -1277,10 +1277,10 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock& sl ledger = ledgerHistory_.getLedgerByHash(*hash); } - if (!app_.config().LEDGER_REPLAY) + if (!app_.config().ledgerReplay) { // Can we try to acquire the ledger we need? - if (!ledger && (++acqCount < ledger_fetch_size_)) + if (!ledger && (++acqCount < ledgerFetchSize_)) { ledger = app_.getInboundLedgers().acquire( *hash, seq, InboundLedger::Reason::GENERIC); @@ -1304,7 +1304,7 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock& sl << ex.what(); } - if (app_.config().LEDGER_REPLAY) + if (app_.config().ledgerReplay) { /* Narrow down the gap of ledgers, and try to replay them. * When replaying a ledger gap, if the local node has @@ -1737,7 +1737,7 @@ void LedgerMaster::sweep() { ledgerHistory_.sweep(); - fetch_packs_.sweep(); + fetchPacks_.sweep(); } float @@ -1789,11 +1789,11 @@ LedgerMaster::fetchForHistory( if (!app_.getInboundLedgers().isFailure(*hash)) { ledger = app_.getInboundLedgers().acquire(*hash, missing, reason); - if (!ledger && missing != fetch_seq_ && + if (!ledger && missing != fetchSeq_ && missing > app_.getNodeStore().earliestLedgerSeq()) { JLOG(journal_.trace()) << "fetchForHistory want fetch pack " << missing; - fetch_seq_ = missing; + fetchSeq_ = missing; getFetchPack(missing, reason); } else @@ -1833,8 +1833,7 @@ LedgerMaster::fetchForHistory( // Do not fetch ledger sequences lower // than the earliest ledger sequence fetchSz = app_.getNodeStore().earliestLedgerSeq(); - fetchSz = - missing >= fetchSz ? std::min(ledger_fetch_size_, (missing - fetchSz) + 1) : 0; + fetchSz = missing >= fetchSz ? std::min(ledgerFetchSize_, (missing - fetchSz) + 1) : 0; try { for (std::uint32_t i = 0; i < fetchSz; ++i) @@ -1884,8 +1883,8 @@ LedgerMaster::doAdvance(std::unique_lock& sl) if (!standalone_ && !app_.getFeeTrack().isLoadedLocal() && (app_.getJobQueue().getJobCount(JtPuboldledger) < 10) && (validLedgerSeq_ == pubLedgerSeq_) && - (getValidatedLedgerAge() < kMAX_LEDGER_AGE_ACQUIRE) && - (app_.getNodeStore().getWriteLoad() < kMAX_WRITE_LOAD_ACQUIRE)) + (getValidatedLedgerAge() < kMaxLedgerAgeAcquire) && + (app_.getNodeStore().getWriteLoad() < kMaxWriteLoadAcquire)) { // We are in sync, so can acquire InboundLedger::Reason const reason = InboundLedger::Reason::HISTORY; @@ -1903,7 +1902,7 @@ LedgerMaster::doAdvance(std::unique_lock& sl) if ((fillInProgress_ == 0 || *missing > fillInProgress_) && shouldAcquire( validLedgerSeq_, - ledger_history_, + ledgerHistorySize_, app_.getSHAMapStore().minimumOnline(), *missing, journal_)) @@ -1962,16 +1961,16 @@ LedgerMaster::doAdvance(std::unique_lock& sl) void LedgerMaster::addFetchPack(uint256 const& hash, std::shared_ptr data) { - fetch_packs_.canonicalizeReplaceClient(hash, data); + fetchPacks_.canonicalizeReplaceClient(hash, data); } std::optional LedgerMaster::getFetchPack(uint256 const& hash) { Blob data; - if (fetch_packs_.retrieve(hash, data)) + if (fetchPacks_.retrieve(hash, data)) { - fetch_packs_.del(hash, false); + fetchPacks_.del(hash, false); if (hash == sha512Half(makeSlice(data))) return data; } @@ -2035,7 +2034,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); @@ -2076,21 +2075,21 @@ LedgerMaster::makeFetchPack( if (!have) { JLOG(journal_.info()) << "Peer requests fetch pack for ledger we don't have: " << have; - peer->charge(Resource::kFEE_REQUEST_NO_REPLY, "get_object ledger"); + peer->charge(Resource::kFeeRequestNoReply, "get_object ledger"); return; } if (have->open()) { JLOG(journal_.warn()) << "Peer requests fetch pack from open ledger: " << have; - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "get_object ledger open"); + peer->charge(Resource::kFeeMalformedRequest, "get_object ledger open"); return; } if (have->header().seq < getEarliestFetch()) { JLOG(journal_.debug()) << "Peer requests fetch pack that is too early"; - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "get_object ledger early"); + peer->charge(Resource::kFeeMalformedRequest, "get_object ledger early"); return; } @@ -2100,7 +2099,7 @@ LedgerMaster::makeFetchPack( { JLOG(journal_.info()) << "Peer requests fetch pack for ledger whose predecessor we " << "don't have: " << have; - peer->charge(Resource::kFEE_REQUEST_NO_REPLY, "get_object ledger no parent"); + peer->charge(Resource::kFeeRequestNoReply, "get_object ledger no parent"); return; } @@ -2170,7 +2169,7 @@ LedgerMaster::makeFetchPack( std::size_t LedgerMaster::getFetchPackCacheSize() const { - return fetch_packs_.getCacheSize(); + return fetchPacks_.getCacheSize(); } // Returns the minimum ledger sequence in SQL database, if any. diff --git a/src/xrpld/app/ledger/detail/LedgerPersistence.cpp b/src/xrpld/app/ledger/detail/LedgerPersistence.cpp index 70e2684e1c..579f66063c 100644 --- a/src/xrpld/app/ledger/detail/LedgerPersistence.cpp +++ b/src/xrpld/app/ledger/detail/LedgerPersistence.cpp @@ -122,7 +122,7 @@ finishLoadByIndexOrHash(std::shared_ptr const& ledger, beast::Journal j) return; XRPL_ASSERT( - ledger->header().seq < kXRP_LEDGER_EARLIEST_FEES || ledger->read(keylet::fees()), + ledger->header().seq < kXrpLedgerEarliestFees || ledger->read(keylet::fees()), "xrpl::finishLoadByIndexOrHash : valid ledger fees"); ledger->setImmutable(); 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/LedgerReplayTask.cpp b/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp index dcc09faa13..f9f1aa3188 100644 --- a/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp +++ b/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp @@ -86,18 +86,18 @@ LedgerReplayTask::LedgerReplayTask( : TimeoutCounter( app, parameter.finishHash, - LedgerReplayParameters::kTASK_TIMEOUT, + LedgerReplayParameters::kTaskTimeout, {.jobType = JtReplayTask, .jobName = "LedReplTask", - .jobLimit = LedgerReplayParameters::kMAX_QUEUED_TASKS}, + .jobLimit = LedgerReplayParameters::kMaxQueuedTasks}, app.getJournal("LedgerReplayTask")) , inboundLedgers_(inboundLedgers) , replayer_(replayer) , parameter_(parameter) , maxTimeouts_( std::max( - LedgerReplayParameters::kTASK_MAX_TIMEOUTS_MINIMUM, - parameter.totalLedgers * LedgerReplayParameters::kTASK_MAX_TIMEOUTS_MULTIPLIER)) + LedgerReplayParameters::kTaskMaxTimeoutsMinimum, + parameter.totalLedgers * LedgerReplayParameters::kTaskMaxTimeoutsMultiplier)) , skipListAcquirer_(skipListAcquirer) { JLOG(journal_.trace()) << "Create " << hash_; diff --git a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp index 132bf9ccaa..3bb5ca9434 100644 --- a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp +++ b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp @@ -51,7 +51,7 @@ LedgerReplayer::replay( { XRPL_ASSERT( finishLedgerHash.isNonZero() && totalNumLedgers > 0 && - totalNumLedgers <= LedgerReplayParameters::kMAX_TASK_SIZE, + totalNumLedgers <= LedgerReplayParameters::kMaxTaskSize, "xrpl::LedgerReplayer::replay : valid inputs"); // NOLINTNEXTLINE(misc-const-correctness) @@ -64,7 +64,7 @@ LedgerReplayer::replay( std::scoped_lock const lock(mtx_); if (app_.isStopping()) return; - if (tasks_.size() >= LedgerReplayParameters::kMAX_TASKS) + if (tasks_.size() >= LedgerReplayParameters::kMaxTasks) { JLOG(j_.info()) << "Too many replay tasks, dropping new task " << parameter.finishHash; return; diff --git a/src/xrpld/app/ledger/detail/LedgerToJson.cpp b/src/xrpld/app/ledger/detail/LedgerToJson.cpp index 5248c3621a..7a581e2389 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; } } } @@ -325,13 +337,13 @@ fillJson(json::Value& json, LedgerFill const& fill) fill.ledger.header(), bFull, ((fill.context != nullptr) ? fill.context->apiVersion - : RPC::kAPI_MAXIMUM_SUPPORTED_VERSION)); + : RPC::kApiMaximumSupportedVersion)); } - 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/LocalTxs.cpp b/src/xrpld/app/ledger/detail/LocalTxs.cpp index 0f355367e5..d843acfe44 100644 --- a/src/xrpld/app/ledger/detail/LocalTxs.cpp +++ b/src/xrpld/app/ledger/detail/LocalTxs.cpp @@ -48,7 +48,7 @@ class LocalTx public: LocalTx(LedgerIndex index, std::shared_ptr const& txn) : txn_(txn) - , expire_(index + LocalTxs::kHOLD_LEDGERS) + , expire_(index + LocalTxs::kHoldLedgers) , id_(txn->getTransactionID()) , account_(txn->getAccountID(sfAccount)) , seqProxy_(txn->getSeqProxy()) @@ -163,7 +163,7 @@ public: // Ticket should have been created by now. Remove if ticket // does not exist. - return !view.exists(keylet::kTICKET(acctID, seqProx)); + return !view.exists(keylet::kTicket(acctID, seqProx)); }); } diff --git a/src/xrpld/app/ledger/detail/OpenLedger.cpp b/src/xrpld/app/ledger/detail/OpenLedger.cpp index 5774dd8863..3bee4b9d13 100644 --- a/src/xrpld/app/ledger/detail/OpenLedger.cpp +++ b/src/xrpld/app/ledger/detail/OpenLedger.cpp @@ -48,26 +48,26 @@ OpenLedger::OpenLedger( bool OpenLedger::empty() const { - std::scoped_lock const lock(modify_mutex_); + std::scoped_lock const lock(modifyMutex_); return current_->txCount() == 0; } std::shared_ptr OpenLedger::current() const { - std::scoped_lock const lock(current_mutex_); + std::scoped_lock const lock(currentMutex_); return current_; } bool OpenLedger::modify(modify_type const& f) { - std::scoped_lock const lock1(modify_mutex_); + std::scoped_lock const lock1(modifyMutex_); auto next = std::make_shared(*current_); auto const changed = f(*next, j_); if (changed) { - std::scoped_lock const lock2(current_mutex_); + std::scoped_lock const lock2(currentMutex_); current_ = std::move(next); } return changed; @@ -96,7 +96,7 @@ OpenLedger::accept( // Block calls to modify, otherwise // new tx going into the open ledger // would get lost. - std::scoped_lock const lock1(modify_mutex_); + std::scoped_lock const lock1(modifyMutex_); // Apply tx from the current open view if (!current_->txs.empty()) { @@ -154,7 +154,7 @@ OpenLedger::accept( } // Switch to the new open view - std::scoped_lock const lock2(current_mutex_); + std::scoped_lock const lock2(currentMutex_); current_ = std::move(next); } @@ -164,7 +164,7 @@ std::shared_ptr OpenLedger::create(Rules const& rules, std::shared_ptr const& ledger) { return std::make_shared( - kOPEN_LEDGER, rules, std::make_shared(ledger, cache_)); + kOpenLedger, rules, std::make_shared(ledger, cache_)); } auto diff --git a/src/xrpld/app/ledger/detail/SkipListAcquire.cpp b/src/xrpld/app/ledger/detail/SkipListAcquire.cpp index e6b41198bb..6c6679ed87 100644 --- a/src/xrpld/app/ledger/detail/SkipListAcquire.cpp +++ b/src/xrpld/app/ledger/detail/SkipListAcquire.cpp @@ -35,10 +35,10 @@ SkipListAcquire::SkipListAcquire( : TimeoutCounter( app, ledgerHash, - LedgerReplayParameters::kSUB_TASK_TIMEOUT, + LedgerReplayParameters::kSubTaskTimeout, {.jobType = JtReplayTask, .jobName = "SkipListAcq", - .jobLimit = LedgerReplayParameters::kMAX_QUEUED_TASKS}, + .jobLimit = LedgerReplayParameters::kMaxQueuedTasks}, app.getJournal("LedgerReplaySkipList")) , inboundLedgers_(inboundLedgers) , peerSet_(std::move(peerSet)) @@ -94,10 +94,10 @@ SkipListAcquire::trigger(std::size_t limit, ScopedLockType& sl) { JLOG(journal_.trace()) << "Add a no feature peer " << peer->id() << " for " << hash_; - if (++noFeaturePeerCount_ >= LedgerReplayParameters::kMAX_NO_FEATURE_PEER_COUNT) + if (++noFeaturePeerCount_ >= LedgerReplayParameters::kMaxNoFeaturePeerCount) { JLOG(journal_.debug()) << "Fall back for " << hash_; - timerInterval_ = LedgerReplayParameters::kSUB_TASK_FALLBACK_TIMEOUT; + timerInterval_ = LedgerReplayParameters::kSubTaskFallbackTimeout; fallBack_ = true; } } @@ -112,7 +112,7 @@ void SkipListAcquire::onTimer(bool progress, ScopedLockType& sl) { JLOG(journal_.trace()) << "timeouts_=" << timeouts_ << " for " << hash_; - if (timeouts_ > LedgerReplayParameters::kSUB_TASK_MAX_TIMEOUTS) + if (timeouts_ > LedgerReplayParameters::kSubTaskMaxTimeouts) { failed_ = true; JLOG(journal_.debug()) << "too many timeouts " << hash_; diff --git a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp index f79620f99d..62312b04d2 100644 --- a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp +++ b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp @@ -29,14 +29,10 @@ namespace xrpl { using namespace std::chrono_literals; // Timeout interval in milliseconds -auto constexpr kTX_ACQUIRE_TIMEOUT = 250ms; +constexpr auto kTxAcquireTimeout = 250ms; -// Need to be named before converting -// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class) -enum { - NormTimeouts = 4, - MaxTimeouts = 20, -}; +static constexpr auto kNormTimeouts = 4; +static constexpr auto kMaxTimeouts = 20; TransactionAcquire::TransactionAcquire( Application& app, @@ -45,7 +41,7 @@ TransactionAcquire::TransactionAcquire( : TimeoutCounter( app, hash, - kTX_ACQUIRE_TIMEOUT, + kTxAcquireTimeout, {.jobType = JtTxnData, .jobName = "TxAcq", .jobLimit = {}}, app.getJournal("TransactionAcquire")) , peerSet_(std::move(peerSet)) @@ -85,14 +81,14 @@ TransactionAcquire::done() void TransactionAcquire::onTimer(bool progress, ScopedLockType& psl) { - if (timeouts_ > MaxTimeouts) + if (timeouts_ > kMaxTimeouts) { failed_ = true; done(); return; } - if (timeouts_ >= NormTimeouts) + if (timeouts_ >= kNormTimeouts) trigger(nullptr); addPeers(1); @@ -259,7 +255,7 @@ TransactionAcquire::stillNeed() { ScopedLockType const sl(mtx_); - timeouts_ = std::min(timeouts_, NormTimeouts); + timeouts_ = std::min(timeouts_, kNormTimeouts); failed_ = false; } diff --git a/src/xrpld/app/ledger/detail/TransactionMaster.cpp b/src/xrpld/app/ledger/detail/TransactionMaster.cpp index 71a1ca629f..129681b906 100644 --- a/src/xrpld/app/ledger/detail/TransactionMaster.cpp +++ b/src/xrpld/app/ledger/detail/TransactionMaster.cpp @@ -142,7 +142,7 @@ void TransactionMaster::canonicalize(std::shared_ptr* pTransaction) { uint256 const tid = (*pTransaction)->getID(); - if (tid != beast::kZERO) + if (tid != beast::kZero) { auto txn = *pTransaction; // VFALCO NOTE canonicalize can change the value of txn! diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp index 800d398eca..a18462f0f7 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) @@ -286,14 +286,14 @@ public: return 1; #else - if (config.IO_WORKERS > 0) - return config.IO_WORKERS; + if (config.ioWorkers > 0) + return config.ioWorkers; auto const cores = std::thread::hardware_concurrency(); // Use a single thread when running on under-provisioned systems // or if we are configured to use minimal resources. - if ((cores == 1) || ((config.NODE_SIZE == 0) && (cores == 2))) + if ((cores == 1) || ((config.nodeSize == 0) && (cores == 2))) return 1; // Otherwise, prefer six threads. @@ -316,7 +316,7 @@ public: // PerfLog must be started before any other threads are launched. , perfLog_( perf::makePerfLog( - perf::setupPerfLog(config_->section("perf"), config_->CONFIG_DIR), + perf::setupPerfLog(config_->section("perf"), config_->configDir), *this, logs_->journal("PerfLog"), [this] { signalStop("PerfLog"); })) @@ -326,22 +326,22 @@ public: , jobQueue_( std::make_unique( [](std::unique_ptr const& config) { - if (config->standalone() && !config->FORCE_MULTI_THREAD) + if (config->standalone() && !config->forceMultiThread) return 1; - if (config->WORKERS) - return config->WORKERS; + if (config->workers) + return config->workers; auto count = static_cast(std::thread::hardware_concurrency()); // Be more aggressive about the number of threads to use // for the job queue if the server is configured as // "large" or "huge" if there are enough cores. - if (config->NODE_SIZE >= 4 && count >= 16) + if (config->nodeSize >= 4 && count >= 16) { count = 6 + std::min(count, 8); } - else if (config->NODE_SIZE >= 3 && count >= 8) + else if (config->nodeSize >= 3 && count >= 8) { count = 4 + std::min(count, 6); } @@ -370,16 +370,16 @@ public: std::chrono::minutes(1), stopwatch(), logs_->journal("CachedSLEs")) - , networkIDService_(std::make_unique(config_->NETWORK_ID)) + , networkIDService_(std::make_unique(config_->networkId)) , validatorKeys_(*config_, journal_) , resourceManager_( Resource::makeManager(collectorManager_->collector(), logs_->journal("Resource"))) , nodeStore_(shaMapStore_->makeNodeStore( - config_->PREFETCH_WORKERS > 0 ? config_->PREFETCH_WORKERS : 4)) + config_->prefetchWorkers > 0 ? config_->prefetchWorkers : 4)) , nodeFamily_(*this, *collectorManager_) , orderBookDB_(makeOrderBookDb( *this, - {.pathSearchMax = config_->PATH_SEARCH_MAX, .standalone = config_->standalone()})) + {.pathSearchMax = config_->pathSearchMax, .standalone = config_->standalone()})) , pathRequestManager_( std::make_unique( *this, @@ -415,8 +415,8 @@ public: *this, stopwatch(), config_->standalone(), - config_->NETWORK_QUORUM, - config_->START_VALID, + config_->networkQuorum, + config_->startValid, *jobQueue_, *ledgerMaster_, validatorKeys_, @@ -435,7 +435,7 @@ public: *timeKeeper_, config_->legacy("database_path"), logs_->journal("ValidatorList"), - config_->VALIDATION_QUORUM)) + config_->validationQuorum)) , validatorSites_(std::make_unique(*this)) , serverHandler_(makeServerHandler( *this, @@ -918,7 +918,7 @@ public: { using namespace std::chrono; sweepTimer_.expires_after( - seconds{config_->SWEEP_INTERVAL.value_or( + seconds{config_->sweepInterval.value_or( config_->getValueFor(SizedItem::SweepInterval))}); sweepTimer_.async_wait(std::move(*optionalCountedHandler)); } @@ -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() @@ -1226,7 +1226,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) amendmentTable_ = makeAmendmentTable( *this, - config().AMENDMENT_MAJORITY_TIME, + config().amendmentMajorityTime, supported, upVoted, downVoted, @@ -1235,7 +1235,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) Pathfinder::initPathTable(); - auto const startUp = config_->START_UP; + auto const startUp = config_->startUp; JLOG(journal_.debug()) << "startUp: " << startUp; if (startUp == StartUpType::Fresh) { @@ -1250,13 +1250,13 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) JLOG(journal_.info()) << "Loading specified Ledger"; if (!loadOldLedger( - config_->START_LEDGER, + config_->startLedger, startUp == StartUpType::Replay, startUp == StartUpType::LoadFile, - config_->TRAP_TX_HASH)) + config_->trapTxHash)) { JLOG(journal_.error()) << "The specified ledger could not be loaded."; - if (config_->FAST_LOAD) + if (config_->fastLoad) { // Fall back to syncing from the network, such as // when there's no existing data. @@ -1282,7 +1282,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) startGenesisLedger(); } - if (auto const& forcedRange = config().FORCED_LEDGER_RANGE_PRESENT) + if (auto const& forcedRange = config().forcedLedgerRangePresent) { ledgerMaster_->setLedgerRangePresent(forcedRange->first, forcedRange->second); } @@ -1328,7 +1328,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) localSigningKey, config().section(SECTION_VALIDATORS).values(), config().section(SECTION_VALIDATOR_LIST_KEYS).values(), - config().VALIDATOR_LIST_THRESHOLD)) + config().validatorListThreshold)) { JLOG(journal_.fatal()) << "Invalid entry in validator configuration."; return false; @@ -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_, @@ -1399,7 +1399,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) { // Should this message be here, conceptually? In theory this sort // of message, if displayed, should be displayed from PeerFinder. - if (config_->PEER_PRIVATE && config_->IPS_FIXED.empty()) + if (config_->peerPrivate && config_->ipsFixed.empty()) { JLOG(journal_.warn()) << "No outbound peer connections will be made"; } @@ -1451,7 +1451,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) JLOG(journal_.fatal()) << "Startup RPC: " << jvCommand << std::endl; } - Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; + Resource::Charge loadType = Resource::kFeeReferenceRpc; Resource::Consumer c; RPC::JsonContext context{ {.j = getJournal("RPCHandler"), @@ -1463,7 +1463,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline) .role = Role::ADMIN, .coro = {}, .infoSub = {}, - .apiVersion = RPC::kAPI_MAXIMUM_SUPPORTED_VERSION}, + .apiVersion = RPC::kApiMaximumSupportedVersion}, jvCommand}; json::Value jvResult; @@ -1659,14 +1659,14 @@ ApplicationImp::fdRequired() const void ApplicationImp::startGenesisLedger() { - std::vector const initialAmendments = (config_->START_UP == StartUpType::Fresh) + std::vector const initialAmendments = (config_->startUp == StartUpType::Fresh) ? amendmentTable_->getDesired() : std::vector{}; std::shared_ptr const genesis = std::make_shared( - kCREATE_GENESIS, + kCreateGenesis, Rules{config_->features}, - config_->FEES.toFees(), + config_->fees.toFees(), initialAmendments, nodeFamily_); ledgerMaster_->storeLedger(genesis); @@ -1674,7 +1674,7 @@ ApplicationImp::startGenesisLedger() auto const next = std::make_shared(*genesis, getTimeKeeper().closeTime()); next->updateSkipList(); XRPL_ASSERT( - next->header().seq < kXRP_LEDGER_EARLIEST_FEES || next->read(keylet::fees()), + next->header().seq < kXrpLedgerEarliestFees || next->read(keylet::fees()), "xrpl::ApplicationImp::startGenesisLedger : valid ledger fees"); next->setImmutable(); openLedger_.emplace(next, cachedSLEs_, logs_->journal("OpenLedger")); @@ -1690,13 +1690,13 @@ ApplicationImp::getLastFullLedger() try { auto const [ledger, seq, hash] = - getLatestLedger(Rules{config_->features}, config_->FEES.toFees(), *this); + getLatestLedger(Rules{config_->features}, config_->fees.toFees(), *this); if (!ledger) return ledger; XRPL_ASSERT( - ledger->header().seq < kXRP_LEDGER_EARLIEST_FEES || ledger->read(keylet::fees()), + ledger->header().seq < kXrpLedgerEarliestFees || ledger->read(keylet::fees()), "xrpl::ApplicationImp::getLastFullLedger : valid ledger fees"); ledger->setImmutable(); @@ -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; } @@ -1802,7 +1802,7 @@ ApplicationImp::loadLedgerFromFile(std::string const& name) } auto loadLedger = std::make_shared( - seq, closeTime, Rules{config_->features}, config_->FEES.toFees(), nodeFamily_); + seq, closeTime, Rules{config_->features}, config_->fees.toFees(), nodeFamily_); loadLedger->setTotalDrops(totalDrops); for (json::UInt index = 0; index < ledger.get().size(); ++index) @@ -1847,8 +1847,7 @@ ApplicationImp::loadLedgerFromFile(std::string const& name) loadLedger->stateMap().flushDirty(NodeObjectType::AccountNode); XRPL_ASSERT( - loadLedger->header().seq < kXRP_LEDGER_EARLIEST_FEES || - loadLedger->read(keylet::fees()), + loadLedger->header().seq < kXrpLedgerEarliestFees || loadLedger->read(keylet::fees()), "xrpl::ApplicationImp::loadLedgerFromFile : valid ledger fees"); loadLedger->setAccepted(closeTime, closeTimeResolution, !closeTimeEstimated); @@ -1884,7 +1883,7 @@ ApplicationImp::loadOldLedger( if (hash.parseHex(ledgerID)) { loadLedger = - loadByHash(hash, Rules{config_->features}, config_->FEES.toFees(), *this); + loadByHash(hash, Rules{config_->features}, config_->fees.toFees(), *this); if (!loadLedger) { @@ -1913,7 +1912,7 @@ ApplicationImp::loadOldLedger( if (beast::lexicalCastChecked(index, ledgerID)) { loadLedger = - loadByIndex(index, Rules{config_->features}, config_->FEES.toFees(), *this); + loadByIndex(index, Rules{config_->features}, config_->fees.toFees(), *this); } } @@ -1932,7 +1931,7 @@ ApplicationImp::loadOldLedger( loadLedger = loadByHash( replayLedger->header().parentHash, Rules{config_->features}, - config_->FEES.toFees(), + config_->fees.toFees(), *this); if (!loadLedger) { @@ -1964,13 +1963,13 @@ ApplicationImp::loadOldLedger( } using namespace std::chrono_literals; using namespace date; - static constexpr NetClock::time_point kLEDGER_WARN_TIME_POINT{ + static constexpr NetClock::time_point kLedgerWarnTimePoint{ sys_days{January / 1 / 2018} - sys_days{January / 1 / 2000}}; - if (loadLedger->header().closeTime < kLEDGER_WARN_TIME_POINT) + if (loadLedger->header().closeTime < kLedgerWarnTimePoint) { JLOG(journal_.fatal()) << "\n\n*** WARNING ***\n" "You are replaying a ledger from before " - << to_string(kLEDGER_WARN_TIME_POINT) + << to_string(kLedgerWarnTimePoint) << " UTC.\n" "This replay will not handle your ledger as it was " "originally " @@ -2079,7 +2078,7 @@ ApplicationImp::loadOldLedger( bool ApplicationImp::serverOkay(std::string& reason) { - if (!config().ELB_SUPPORT) + if (!config().elbSupport) return true; if (isStopping()) diff --git a/src/xrpld/app/main/BasicApp.cpp b/src/xrpld/app/main/BasicApp.cpp index 71138c6517..c530c170cb 100644 --- a/src/xrpld/app/main/BasicApp.cpp +++ b/src/xrpld/app/main/BasicApp.cpp @@ -9,14 +9,14 @@ BasicApp::BasicApp(std::size_t numberOfThreads) { - work_.emplace(boost::asio::make_work_guard(io_context_)); + work_.emplace(boost::asio::make_work_guard(ioContext_)); threads_.reserve(numberOfThreads); for (std::size_t i = 0; i < numberOfThreads; ++i) { threads_.emplace_back([this, i]() { beast::setCurrentThreadName("io svc #" + std::to_string(i)); - this->io_context_.run(); + this->ioContext_.run(); }); } } diff --git a/src/xrpld/app/main/BasicApp.h b/src/xrpld/app/main/BasicApp.h index d55ab858db..5ba7c719e3 100644 --- a/src/xrpld/app/main/BasicApp.h +++ b/src/xrpld/app/main/BasicApp.h @@ -12,7 +12,7 @@ class BasicApp private: std::optional> work_; std::vector threads_; - boost::asio::io_context io_context_; + boost::asio::io_context ioContext_; public: BasicApp(std::size_t numberOfThreads); @@ -21,7 +21,7 @@ public: boost::asio::io_context& getIoContext() { - return io_context_; + return ioContext_; } [[nodiscard]] size_t diff --git a/src/xrpld/app/main/GRPCServer.cpp b/src/xrpld/app/main/GRPCServer.cpp index e0f0798dbc..7a622f632f 100644 --- a/src/xrpld/app/main/GRPCServer.cpp +++ b/src/xrpld/app/main/GRPCServer.cpp @@ -204,7 +204,7 @@ GRPCServerImpl::CallData::process(std::shared_ptr("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,8 +543,8 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedger, doLedgerGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedger, - RPC::NoCondition, - Resource::kFEE_MEDIUM_BURDEN_RPC, + Condition::NoCondition, + Resource::kFeeMediumBurdenRpc, secureGatewayIPs_)); } { @@ -559,8 +560,8 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedgerData, doLedgerDataGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedgerData, - RPC::NoCondition, - Resource::kFEE_MEDIUM_BURDEN_RPC, + Condition::NoCondition, + Resource::kFeeMediumBurdenRpc, secureGatewayIPs_)); } { @@ -576,8 +577,8 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedgerDiff, doLedgerDiffGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedgerDiff, - RPC::NoCondition, - Resource::kFEE_MEDIUM_BURDEN_RPC, + Condition::NoCondition, + Resource::kFeeMediumBurdenRpc, secureGatewayIPs_)); } { @@ -593,8 +594,8 @@ GRPCServerImpl::setupListeners() &org::xrpl::rpc::v1::XRPLedgerAPIService::AsyncService::RequestGetLedgerEntry, doLedgerEntryGrpc, &org::xrpl::rpc::v1::XRPLedgerAPIService::Stub::GetLedgerEntry, - RPC::NoCondition, - Resource::kFEE_MEDIUM_BURDEN_RPC, + Condition::NoCondition, + Resource::kFeeMediumBurdenRpc, secureGatewayIPs_)); } return requests; diff --git a/src/xrpld/app/main/GRPCServer.h b/src/xrpld/app/main/GRPCServer.h index 6d9af236dc..7d299474d9 100644 --- a/src/xrpld/app/main/GRPCServer.h +++ b/src/xrpld/app/main/GRPCServer.h @@ -93,7 +93,7 @@ private: template using Handler = std::function(RPC::GRPCContext&)>; // This implementation is currently limited to v1 of the API - static unsigned constexpr kAPI_VERSION = 1; + static constexpr unsigned kApiVersion = 1; template using Forward = std::function(steady_clock::now() - lastHeartbeat); - constexpr auto kREPORTING_INTERVAL_SECONDS = 10s; - constexpr auto kSTALL_FATAL_LOG_MESSAGE_TIME_LIMIT = 90s; - constexpr auto kSTALL_LOGIC_ERROR_TIME_LIMIT = 600s; + static constexpr auto kReportingIntervalSeconds = 10s; + static constexpr auto kStallFatalLogMessageTimeLimit = 90s; + static constexpr auto kStallLogicErrorTimeLimit = 600s; - if (armed && (timeSpentStalled >= kREPORTING_INTERVAL_SECONDS)) + if (armed && (timeSpentStalled >= kReportingIntervalSeconds)) { // Report the stalled condition every reportingIntervalSeconds - if ((timeSpentStalled % kREPORTING_INTERVAL_SECONDS) == 0s) + if ((timeSpentStalled % kReportingIntervalSeconds) == 0s) { - if (timeSpentStalled < kSTALL_FATAL_LOG_MESSAGE_TIME_LIMIT) + if (timeSpentStalled < kStallFatalLogMessageTimeLimit) { JLOG(journal_.warn()) << "Server stalled for " << timeSpentStalled.count() << " seconds."; @@ -141,7 +141,7 @@ LoadManager::run() // If we go over the stallLogicErrorTimeLimit spent stalled, it // means that the stall resolution code has failed, which qualifies // as a LogicError - if (timeSpentStalled >= kSTALL_LOGIC_ERROR_TIME_LIMIT) + if (timeSpentStalled >= kStallLogicErrorTimeLimit) { JLOG(journal_.fatal()) << "LogicError: Fatal server stall detected. Stalled time: " << timeSpentStalled.count() << "s"; diff --git a/src/xrpld/app/main/Main.cpp b/src/xrpld/app/main/Main.cpp index 167cd2b023..f470a2d80f 100644 --- a/src/xrpld/app/main/Main.cpp +++ b/src/xrpld/app/main/Main.cpp @@ -627,7 +627,7 @@ run(int argc, char** argv) { throw std::runtime_error("Invalid force_ledger_present_range parameter"); } - config->FORCED_LEDGER_RANGE_PRESENT.emplace(r[0], r[1]); + config->forcedLedgerRangePresent.emplace(r[0], r[1]); } else { @@ -646,7 +646,7 @@ run(int argc, char** argv) if (vm.contains("start")) { - config->START_UP = StartUpType::Fresh; + config->startUp = StartUpType::Fresh; } if (vm.contains("import")) @@ -654,17 +654,17 @@ run(int argc, char** argv) if (vm.contains("ledger")) { - config->START_LEDGER = vm["ledger"].as(); + config->startLedger = vm["ledger"].as(); if (vm.contains("replay")) { - config->START_UP = StartUpType::Replay; + config->startUp = StartUpType::Replay; if (vm.contains("trap_tx_hash")) { uint256 tmp = {}; auto hash = vm["trap_tx_hash"].as(); if (tmp.parseHex(hash)) { - config->TRAP_TX_HASH = tmp; + config->trapTxHash = tmp; } else { @@ -677,17 +677,17 @@ run(int argc, char** argv) } else { - config->START_UP = StartUpType::Load; + config->startUp = StartUpType::Load; } } else if (vm.contains("ledgerfile")) { - config->START_LEDGER = vm["ledgerfile"].as(); - config->START_UP = StartUpType::LoadFile; + config->startLedger = vm["ledgerfile"].as(); + config->startUp = StartUpType::LoadFile; } - else if (vm.contains("load") || config->FAST_LOAD) + else if (vm.contains("load") || config->fastLoad) { - config->START_UP = StartUpType::Load; + config->startUp = StartUpType::Load; } if (vm.contains("trap_tx_hash") && !vm.contains("replay")) @@ -696,20 +696,20 @@ run(int argc, char** argv) return -1; } - if (vm.contains("net") && !config->FAST_LOAD) + if (vm.contains("net") && !config->fastLoad) { - if ((config->START_UP == StartUpType::Load) || (config->START_UP == StartUpType::Replay)) + if ((config->startUp == StartUpType::Load) || (config->startUp == StartUpType::Replay)) { std::cerr << "Net and load/replay options are incompatible" << std::endl; return -1; } - config->START_UP = StartUpType::Network; + config->startUp = StartUpType::Network; } if (vm.contains("valid")) { - config->START_VALID = true; + config->startValid = true; } // Override the RPC destination IP address. This must @@ -747,15 +747,15 @@ run(int argc, char** argv) } } - config->rpc_ip = std::move(*endpoint); + config->rpcIp = std::move(*endpoint); } if (vm.contains("quorum")) { try { - config->VALIDATION_QUORUM = vm["quorum"].as(); - if (config->VALIDATION_QUORUM == std::size_t{}) + config->validationQuorum = vm["quorum"].as(); + if (config->validationQuorum == std::size_t{}) { throw std::domain_error("0"); } @@ -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/main/Tuning.h b/src/xrpld/app/main/Tuning.h index 4d2c4e01e7..d61f27ec03 100644 --- a/src/xrpld/app/main/Tuning.h +++ b/src/xrpld/app/main/Tuning.h @@ -4,9 +4,9 @@ namespace xrpl { -constexpr std::size_t kFULL_BELOW_TARGET_SIZE = 524288; -constexpr std::chrono::seconds kFULL_BELOW_EXPIRATION = std::chrono::minutes{10}; +constexpr std::size_t kFullBelowTargetSize = 524288; +constexpr std::chrono::seconds kFullBelowExpiration = std::chrono::minutes{10}; -constexpr std::size_t kMAX_POPPED_TRANSACTIONS = 10; +constexpr std::size_t kMaxPoppedTransactions = 10; } // namespace xrpl diff --git a/src/xrpld/app/misc/FeeVoteImpl.cpp b/src/xrpld/app/misc/FeeVoteImpl.cpp index 4369a4642d..c4e6c3cdc2 100644 --- a/src/xrpld/app/misc/FeeVoteImpl.cpp +++ b/src/xrpld/app/misc/FeeVoteImpl.cpp @@ -135,13 +135,10 @@ FeeVoteImpl::doValidation(Fees const& lastFees, Rules const& rules, STValidation v[sfield] = target; } }; - vote(lastFees.base, target_.reference_fee, "base fee", sfBaseFeeDrops); - vote(lastFees.reserve, target_.account_reserve, "base reserve", sfReserveBaseDrops); + vote(lastFees.base, target_.referenceFee, "base fee", sfBaseFeeDrops); + vote(lastFees.reserve, target_.accountReserve, "base reserve", sfReserveBaseDrops); vote( - lastFees.increment, - target_.owner_reserve, - "reserve increment", - sfReserveIncrementDrops); + lastFees.increment, target_.ownerReserve, "reserve increment", sfReserveIncrementDrops); } else { @@ -162,11 +159,11 @@ FeeVoteImpl::doValidation(Fees const& lastFees, Rules const& rules, STValidation } }; - vote(lastFees.base, target_.reference_fee, to64, "base fee", sfBaseFee); - vote(lastFees.reserve, target_.account_reserve, to32, "base reserve", sfReserveBase); + vote(lastFees.base, target_.referenceFee, to64, "base fee", sfBaseFee); + vote(lastFees.reserve, target_.accountReserve, to32, "base reserve", sfReserveBase); vote( lastFees.increment, - target_.owner_reserve, + target_.ownerReserve, to32, "reserve increment", sfReserveIncrement); @@ -184,11 +181,11 @@ FeeVoteImpl::doVoting( lastClosedLedger && isFlagLedger(lastClosedLedger->seq()), "xrpl::FeeVoteImpl::doVoting : has a flag ledger"); - detail::VotableValue baseFeeVote(lastClosedLedger->fees().base, target_.reference_fee); + detail::VotableValue baseFeeVote(lastClosedLedger->fees().base, target_.referenceFee); - detail::VotableValue baseReserveVote(lastClosedLedger->fees().reserve, target_.account_reserve); + detail::VotableValue baseReserveVote(lastClosedLedger->fees().reserve, target_.accountReserve); - detail::VotableValue incReserveVote(lastClosedLedger->fees().increment, target_.owner_reserve); + detail::VotableValue incReserveVote(lastClosedLedger->fees().increment, target_.ownerReserve); auto const& rules = lastClosedLedger->rules(); if (rules.enabled(featureXRPFees)) @@ -295,7 +292,7 @@ FeeVoteImpl::doVoting( baseReserve.first.dropsAs(baseReserveVote.current()); obj[sfReserveIncrement] = incReserve.first.dropsAs(incReserveVote.current()); - obj[sfReferenceFeeUnits] = kFEE_UNITS_DEPRECATED; + obj[sfReferenceFeeUnits] = kFeeUnitsDeprecated; } }); diff --git a/src/xrpld/app/misc/NegativeUNLVote.cpp b/src/xrpld/app/misc/NegativeUNLVote.cpp index 0da94ad75f..2ed440fba8 100644 --- a/src/xrpld/app/misc/NegativeUNLVote.cpp +++ b/src/xrpld/app/misc/NegativeUNLVote.cpp @@ -141,7 +141,7 @@ NodeID NegativeUNLVote::choose(uint256 const& randomPadData, std::vector const& candidates) { XRPL_ASSERT(!candidates.empty(), "xrpl::NegativeUNLVote::choose : non-empty input"); - static_assert(NodeID::kBYTES <= uint256::kBYTES); + static_assert(NodeID::kBytes <= uint256::kBytes); NodeID const randomPad = NodeID::fromVoid(randomPadData.data()); NodeID txNodeID = candidates[0]; for (int j = 1; j < candidates.size(); ++j) @@ -167,7 +167,7 @@ NegativeUNLVote::buildScoreTable( // Ask the validation container to keep enough validation message history // for next time. auto const seq = prevLedger->header().seq + 1; - validations.setSeqToKeep(seq - 1, seq + kFLAG_LEDGER_INTERVAL); + validations.setSeqToKeep(seq - 1, seq + kFlagLedgerInterval); // Find FLAG_LEDGER_INTERVAL (i.e. 256) previous ledger hashes auto const hashIndex = prevLedger->read(keylet::skip()); @@ -178,7 +178,7 @@ NegativeUNLVote::buildScoreTable( } auto const ledgerAncestors = hashIndex->getFieldV256(sfHashes).value(); auto const numAncestors = ledgerAncestors.size(); - if (numAncestors < kFLAG_LEDGER_INTERVAL) + if (numAncestors < kFlagLedgerInterval) { JLOG(j_.debug()) << "N-UNL: ledger " << seq << " not enough history. Can trace back only " << numAncestors << " ledgers."; @@ -194,7 +194,7 @@ NegativeUNLVote::buildScoreTable( // Query the validation container for every ledger hash and fill // the score table. - for (int i = 0; i < kFLAG_LEDGER_INTERVAL; ++i) + for (int i = 0; i < kFlagLedgerInterval; ++i) { for (auto const& v : validations.getTrustedForLedger(ledgerAncestors[numAncestors - 1 - i], seq - 2 - i)) @@ -211,16 +211,16 @@ NegativeUNLVote::buildScoreTable( return it->second; return 0; }(); - if (myValidationCount < kNEGATIVE_UNL_MIN_LOCAL_VALS_TO_VOTE) + if (myValidationCount < kNegativeUnlMinLocalValsToVote) { JLOG(j_.debug()) << "N-UNL: ledger " << seq << ". Local node only issued " - << myValidationCount << " validations in last " << kFLAG_LEDGER_INTERVAL + << myValidationCount << " validations in last " << kFlagLedgerInterval << " ledgers." << " The reliability measurement could be wrong."; return {}; } - if (myValidationCount > kNEGATIVE_UNL_MIN_LOCAL_VALS_TO_VOTE && - myValidationCount <= kFLAG_LEDGER_INTERVAL) + if (myValidationCount > kNegativeUnlMinLocalValsToVote && + myValidationCount <= kFlagLedgerInterval) { return scoreTable; } @@ -228,7 +228,7 @@ NegativeUNLVote::buildScoreTable( // cannot happen because validations.getTrustedForLedger does not // return multiple validations of the same ledger from a validator. JLOG(j_.error()) << "N-UNL: ledger " << seq << ". Local node issued " << myValidationCount - << " validations in last " << kFLAG_LEDGER_INTERVAL << " ledgers. Too many!"; + << " validations in last " << kFlagLedgerInterval << " ledgers. Too many!"; return {}; } @@ -241,7 +241,7 @@ NegativeUNLVote::findAllCandidates( // Compute if need to find more validators to disable auto const canAdd = [&]() -> bool { auto const maxNegativeListed = - static_cast(std::ceil(unl.size() * kNEGATIVE_UNL_MAX_LISTED)); + static_cast(std::ceil(unl.size() * kNegativeUnlMaxListed)); std::size_t negativeListed = 0; for (auto const& n : unl) { @@ -250,10 +250,9 @@ NegativeUNLVote::findAllCandidates( } bool const result = negativeListed < maxNegativeListed; JLOG(j_.trace()) << "N-UNL: nodeId " << myId_ << " lowWaterMark " - << kNEGATIVE_UNL_LOW_WATER_MARK << " highWaterMark " - << kNEGATIVE_UNL_HIGH_WATER_MARK << " canAdd " << result - << " negativeListed " << negativeListed << " maxNegativeListed " - << maxNegativeListed; + << kNegativeUnlLowWaterMark << " highWaterMark " + << kNegativeUnlHighWaterMark << " canAdd " << result << " negativeListed " + << negativeListed << " maxNegativeListed " << maxNegativeListed; return result; }(); @@ -267,7 +266,7 @@ NegativeUNLVote::findAllCandidates( // (2) has less than negativeUNLLowWaterMark validations, // (3) is not in negUnl, and // (4) is not a new validator. - if (canAdd && score < kNEGATIVE_UNL_LOW_WATER_MARK && !negUnl.contains(nodeId) && + if (canAdd && score < kNegativeUnlLowWaterMark && !negUnl.contains(nodeId) && !newValidators_.contains(nodeId)) { JLOG(j_.trace()) << "N-UNL: toDisable candidate " << nodeId; @@ -277,7 +276,7 @@ NegativeUNLVote::findAllCandidates( // Find toReEnable Candidates: check if // (1) has more than negativeUNLHighWaterMark validations, // (2) is in negUnl - if (score > kNEGATIVE_UNL_HIGH_WATER_MARK && negUnl.contains(nodeId)) + if (score > kNegativeUnlHighWaterMark && negUnl.contains(nodeId)) { JLOG(j_.trace()) << "N-UNL: toReEnable candidate " << nodeId; candidates.toReEnableCandidates.push_back(nodeId); @@ -328,7 +327,7 @@ NegativeUNLVote::purgeNewValidators(LedgerIndex seq) auto i = newValidators_.begin(); while (i != newValidators_.end()) { - if (seq - i->second > kNEW_VALIDATOR_DISABLE_SKIP) + if (seq - i->second > kNewValidatorDisableSkip) { i = newValidators_.erase(i); } diff --git a/src/xrpld/app/misc/NegativeUNLVote.h b/src/xrpld/app/misc/NegativeUNLVote.h index 4cedc4743f..5c2d3f8630 100644 --- a/src/xrpld/app/misc/NegativeUNLVote.h +++ b/src/xrpld/app/misc/NegativeUNLVote.h @@ -32,26 +32,26 @@ public: * An unreliable validator is a candidate to be disabled by the NegativeUNL * protocol. */ - static constexpr size_t kNEGATIVE_UNL_LOW_WATER_MARK = kFLAG_LEDGER_INTERVAL * 50 / 100; + static constexpr size_t kNegativeUnlLowWaterMark = kFlagLedgerInterval * 50 / 100; /** * An unreliable validator must have more than negativeUNLHighWaterMark * validations in the last flag ledger period to be re-enabled. */ - static constexpr size_t kNEGATIVE_UNL_HIGH_WATER_MARK = kFLAG_LEDGER_INTERVAL * 80 / 100; + static constexpr size_t kNegativeUnlHighWaterMark = kFlagLedgerInterval * 80 / 100; /** * The minimum number of validations of the local node for it to * participate in the voting. */ - static constexpr size_t kNEGATIVE_UNL_MIN_LOCAL_VALS_TO_VOTE = kFLAG_LEDGER_INTERVAL * 90 / 100; + static constexpr size_t kNegativeUnlMinLocalValsToVote = kFlagLedgerInterval * 90 / 100; /** * We don't want to disable new validators immediately after adding them. * So we skip voting for disabling them for 2 flag ledgers. */ - static constexpr size_t kNEW_VALIDATOR_DISABLE_SKIP = kFLAG_LEDGER_INTERVAL * 2; + static constexpr size_t kNewValidatorDisableSkip = kFlagLedgerInterval * 2; /** * We only want to put 25% of the UNL on the NegativeUNL. */ - static constexpr float kNEGATIVE_UNL_MAX_LISTED = 0.25; + static constexpr float kNegativeUnlMaxListed = 0.25; /** * A flag indicating whether a UNLModify Tx is to disable or to re-enable diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp index 638489a9fa..12c79b821c 100644 --- a/src/xrpld/app/misc/NetworkOPs.cpp +++ b/src/xrpld/app/misc/NetworkOPs.cpp @@ -189,7 +189,7 @@ class NetworkOPsImp final : public NetworkOPs Running, }; - static std::array const kSTATES; + static std::array const kStates; /** * State accounting records two attributes for each possible server state: @@ -221,7 +221,7 @@ class NetworkOPsImp final : public NetworkOPs std::chrono::steady_clock::time_point start_ = std::chrono::steady_clock::now(); std::chrono::steady_clock::time_point const processStart_ = start_; std::uint64_t initialSyncUs_{0}; - static std::array const kSTATES; + static std::array const kStates; public: explicit StateAccounting() @@ -327,7 +327,7 @@ public: validatorKeys.keys ? validatorKeys.keys->masterPublicKey : decltype(validatorMasterPK_){}) , ledgerMaster_(ledgerMaster) - , job_queue_(jobQueue) + , jobQueue_(jobQueue) , standalone_(standalone) , minPeerCount_(startValid ? 0 : minPeerCount) , stats_(std::bind(&NetworkOPsImp::collectMetrics, this), collector) @@ -828,7 +828,7 @@ private: ServerFeeSummary lastFeeSummary_; - JobQueue& job_queue_; + JobQueue& jobQueue_; // Whether we are in standalone mode. bool const standalone_; @@ -853,34 +853,34 @@ private: template Stats(Handler const& handler, beast::insight::Collector::ptr const& collector) : hook(collector->makeHook(handler)) - , disconnected_duration( + , disconnectedDuration( collector->makeGauge("State_Accounting", "Disconnected_duration")) - , connected_duration(collector->makeGauge("State_Accounting", "Connected_duration")) - , syncing_duration(collector->makeGauge("State_Accounting", "Syncing_duration")) - , tracking_duration(collector->makeGauge("State_Accounting", "Tracking_duration")) - , full_duration(collector->makeGauge("State_Accounting", "Full_duration")) - , disconnected_transitions( + , connectedDuration(collector->makeGauge("State_Accounting", "Connected_duration")) + , syncingDuration(collector->makeGauge("State_Accounting", "Syncing_duration")) + , trackingDuration(collector->makeGauge("State_Accounting", "Tracking_duration")) + , fullDuration(collector->makeGauge("State_Accounting", "Full_duration")) + , disconnectedTransitions( collector->makeGauge("State_Accounting", "Disconnected_transitions")) - , connected_transitions( + , connectedTransitions( collector->makeGauge("State_Accounting", "Connected_transitions")) - , syncing_transitions(collector->makeGauge("State_Accounting", "Syncing_transitions")) - , tracking_transitions(collector->makeGauge("State_Accounting", "Tracking_transitions")) - , full_transitions(collector->makeGauge("State_Accounting", "Full_transitions")) + , syncingTransitions(collector->makeGauge("State_Accounting", "Syncing_transitions")) + , trackingTransitions(collector->makeGauge("State_Accounting", "Tracking_transitions")) + , fullTransitions(collector->makeGauge("State_Accounting", "Full_transitions")) { } beast::insight::Hook hook; - beast::insight::Gauge disconnected_duration; - beast::insight::Gauge connected_duration; - beast::insight::Gauge syncing_duration; - beast::insight::Gauge tracking_duration; - beast::insight::Gauge full_duration; + beast::insight::Gauge disconnectedDuration; + beast::insight::Gauge connectedDuration; + beast::insight::Gauge syncingDuration; + beast::insight::Gauge trackingDuration; + beast::insight::Gauge fullDuration; - beast::insight::Gauge disconnected_transitions; - beast::insight::Gauge connected_transitions; - beast::insight::Gauge syncing_transitions; - beast::insight::Gauge tracking_transitions; - beast::insight::Gauge full_transitions; + beast::insight::Gauge disconnectedTransitions; + beast::insight::Gauge connectedTransitions; + beast::insight::Gauge syncingTransitions; + beast::insight::Gauge trackingTransitions; + beast::insight::Gauge fullTransitions; }; std::mutex statsMutex_; // Mutex to lock stats_ @@ -893,19 +893,19 @@ private: //------------------------------------------------------------------------------ -static std::array const kSTATE_NAMES{ +static std::array const kStateNames{ {"disconnected", "connected", "syncing", "tracking", "full"}}; -std::array const NetworkOPsImp::kSTATES = kSTATE_NAMES; +std::array const NetworkOPsImp::kStates = kStateNames; -std::array const NetworkOPsImp::StateAccounting::kSTATES = { - {json::StaticString(kSTATE_NAMES[0]), - json::StaticString(kSTATE_NAMES[1]), - json::StaticString(kSTATE_NAMES[2]), - json::StaticString(kSTATE_NAMES[3]), - json::StaticString(kSTATE_NAMES[4])}}; +std::array const NetworkOPsImp::StateAccounting::kStates = { + {json::StaticString(kStateNames[0]), + json::StaticString(kStateNames[1]), + json::StaticString(kStateNames[2]), + json::StaticString(kStateNames[3]), + json::StaticString(kStateNames[4])}}; -static auto const kGENESIS_ACCOUNT_ID = +static auto const kGenesisAccountId = calcAccountID(generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase")).first); //------------------------------------------------------------------------------ @@ -954,20 +954,20 @@ NetworkOPsImp::isFull() std::string NetworkOPsImp::getHostId(bool forAdmin) { - static std::string const kHOSTNAME = boost::asio::ip::host_name(); + static std::string const kHostname = boost::asio::ip::host_name(); if (forAdmin) - return kHOSTNAME; + return kHostname; // For non-admin uses hash the node public key into a // single RFC1751 word: - static std::string const kSHROUDED_HOST_ID = [this]() { + static std::string const kShroudedHostId = [this]() { auto const& id = registry_.get().getApp().nodeIdentity(); return RFC1751::getWordFromBlob(id.first.data(), id.first.size()); }(); - return kSHROUDED_HOST_ID; + return kShroudedHostId; } void @@ -990,7 +990,7 @@ NetworkOPsImp::setTimer( // Only start the timer if waitHandlerCounter_ is not yet joined. if (auto optionalCountedHandler = waitHandlerCounter_.wrap([this, onExpire, onError](boost::system::error_code const& e) { - if ((e.value() == boost::system::errc::success) && (!job_queue_.isStopped())) + if ((e.value() == boost::system::errc::success) && (!jobQueue_.isStopped())) { onExpire(); } @@ -1017,7 +1017,7 @@ NetworkOPsImp::setHeartbeatTimer() heartbeatTimer_, consensus_.parms().ledgerGRANULARITY, [this]() { - job_queue_.addJob(JtNetopTimer, "NetHeart", [this]() { processHeartbeatTimer(); }); + jobQueue_.addJob(JtNetopTimer, "NetHeart", [this]() { processHeartbeatTimer(); }); }, [this]() { setHeartbeatTimer(); }); } @@ -1031,7 +1031,7 @@ NetworkOPsImp::setClusterTimer() clusterTimer_, 10s, [this]() { - job_queue_.addJob(JtNetopCluster, "NetCluster", [this]() { processClusterTimer(); }); + jobQueue_.addJob(JtNetopCluster, "NetCluster", [this]() { processClusterTimer(); }); }, [this]() { setClusterTimer(); }); } @@ -1194,7 +1194,7 @@ NetworkOPsImp::strOperatingMode(OperatingMode const mode, bool const admin) cons } } - return kSTATES[static_cast(mode)]; + return kStates[static_cast(mode)]; } void @@ -1247,7 +1247,7 @@ NetworkOPsImp::submitTransaction(std::shared_ptr const& iTrans) auto tx = std::make_shared(trans, reason, registry_.get().getApp()); - job_queue_.addJob(JtTransaction, "SubmitTxn", [this, tx]() { + jobQueue_.addJob(JtTransaction, "SubmitTxn", [this, tx]() { auto t = tx; processTransaction(t, false, false, FailHard::No); }); @@ -1312,7 +1312,7 @@ NetworkOPsImp::processTransaction( bool bLocal, FailHard failType) { - auto ev = job_queue_.makeLoadEvent(JtTxnProc, "ProcessTXN"); + auto ev = jobQueue_.makeLoadEvent(JtTxnProc, "ProcessTXN"); // preProcessTransaction can change our pointer if (!preProcessTransaction(transaction)) @@ -1344,7 +1344,7 @@ NetworkOPsImp::doTransactionAsync( if (dispatchState_ == DispatchState::None) { - if (job_queue_.addJob(JtBatch, "TxBatchAsync", [this]() { transactionBatch(); })) + if (jobQueue_.addJob(JtBatch, "TxBatchAsync", [this]() { transactionBatch(); })) { dispatchState_ = DispatchState::Scheduled; } @@ -1389,7 +1389,7 @@ NetworkOPsImp::doTransactionSyncBatch( if (!transactions_.empty()) { // More transactions need to be applied, but by another job. - if (job_queue_.addJob(JtBatch, "TxBatchSync", [this]() { transactionBatch(); })) + if (jobQueue_.addJob(JtBatch, "TxBatchSync", [this]() { transactionBatch(); })) { dispatchState_ = DispatchState::Scheduled; } @@ -1401,7 +1401,7 @@ NetworkOPsImp::doTransactionSyncBatch( void NetworkOPsImp::processTransactionSet(CanonicalTXSet const& set) { - auto ev = job_queue_.makeLoadEvent(JtTxnProc, "ProcessTXNSet"); + auto ev = jobQueue_.makeLoadEvent(JtTxnProc, "ProcessTXNSet"); std::vector> candidates; candidates.reserve(set.size()); for (auto const& [_, tx] : set) @@ -1569,7 +1569,7 @@ NetworkOPsImp::apply(std::unique_lock& batchLock) std::size_t count = 0; for (auto txNext = ledgerMaster_.popAcctTransaction(txCur); - txNext && count < kMAX_POPPED_TRANSACTIONS; + txNext && count < kMaxPoppedTransactions; txNext = ledgerMaster_.popAcctTransaction(txCur), ++count) { if (!batchLock.owns_lock()) @@ -1618,7 +1618,7 @@ NetworkOPsImp::apply(std::unique_lock& batchLock) // 1. It was submitted locally. (Note that this flag is only // true on the initial submission.) // 2. The transaction has a LastLedgerSequence, and the - // LastLedgerSequence is fewer than LocalTxs::kHOLD_LEDGERS + // LastLedgerSequence is fewer than LocalTxs::kHoldLedgers // (5) ledgers into the future. (Remember that an // unseated optional compares as less than all seated // values, so it has to be checked explicitly first.) @@ -1629,7 +1629,7 @@ NetworkOPsImp::apply(std::unique_lock& batchLock) // the other conditions, so don't hold it again. Time's // up!) // - if (e.local || (ledgersLeft && ledgersLeft <= LocalTxs::kHOLD_LEDGERS) || + if (e.local || (ledgersLeft && ledgersLeft <= LocalTxs::kHoldLedgers) || registry_.get().getHashRouter().setFlags( e.transaction->getID(), HashRouterFlags::HELD)) { @@ -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); @@ -2257,9 +2258,9 @@ NetworkOPsImp::ServerFeeSummary::operator!=(NetworkOPsImp::ServerFeeSummary cons static std::uint32_t trunc32(std::uint64_t v) { - constexpr std::uint64_t kMAX32 = std::numeric_limits::max(); + constexpr std::uint64_t kMax32 = std::numeric_limits::max(); - return std::min(kMAX32, v); + return std::min(kMax32, v); }; void @@ -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, @@ -2291,7 +2292,7 @@ NetworkOPsImp::pubServer() auto const loadFactor = std::max( safeCast(f.loadFactorServer), mulDiv(f.em->openLedgerFeeLevel, f.loadBaseServer, f.em->referenceFeeLevel) - .value_or(xrpl::kMULDIV_MAX)); + .value_or(xrpl::kMuldivMax)); jvObj[jss::load_factor] = trunc32(loadFactor); jvObj[jss::load_factor_fee_escalation] = f.em->openLedgerFeeLevel.jsonClipped(); @@ -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)); } @@ -2432,7 +2433,7 @@ NetworkOPsImp::pubValidation(std::shared_ptr const& val) // for consumers supporting different API versions MultiApiJson multiObj{jvObj}; multiObj.visit( - RPC::kAPI_VERSION<1>, // + RPC::kApiVersion<1>, // [](json::Value& jvTx) { // Type conversion for older API versions to string if (jvTx.isMember(jss::ledger_index)) @@ -2570,7 +2571,7 @@ NetworkOPsImp::recvValidation(std::shared_ptr const& val, std::str // We will always relay trusted validations; if configured, we will // also relay all untrusted validations. - return registry_.get().getApp().config().RELAY_UNTRUSTED_VALIDATIONS == 1 || val->isTrusted(); + return registry_.get().getApp().config().relayUntrustedValidations == 1 || val->isTrusted(); } json::Value @@ -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); } @@ -2630,8 +2631,8 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) info[jss::hostid] = getHostId(admin); // domain: if configured with a domain, report it: - if (!registry_.get().getApp().config().SERVER_DOMAIN.empty()) - info[jss::server_domain] = registry_.get().getApp().config().SERVER_DOMAIN; + if (!registry_.get().getApp().config().serverDomain.empty()) + info[jss::server_domain] = registry_.get().getApp().config().serverDomain; info[jss::build_version] = BuildInfo::getVersionString(); @@ -2651,7 +2652,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) // Note: By default the node size is "tiny". When parsing it's an error if the final // NODE_SIZE is over 4 so below code should be safe. // NOLINTNEXTLINE(bugprone-switch-missing-default-case) - switch (registry_.get().getApp().config().NODE_SIZE) + switch (registry_.get().getApp().config().nodeSize) { case 0: info[jss::node_size] = "tiny"; @@ -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) @@ -2786,7 +2787,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) // info[jss::consensus] = consensus_.getJson(); if (admin) - info[jss::load] = job_queue_.getJson(); + info[jss::load] = jobQueue_.getJson(); if (auto const netid = registry_.get().getOverlay().networkID()) info[jss::network_id] = static_cast(*netid); @@ -2803,7 +2804,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) escalationMetrics.openLedgerFeeLevel, loadBaseServer, escalationMetrics.referenceFeeLevel) - .value_or(xrpl::kMULDIV_MAX); + .value_or(xrpl::kMuldivMax); auto const loadFactor = std::max(safeCast(loadFactorServer), loadFactorFeeEscalation); @@ -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); @@ -2894,11 +2895,11 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) std::abs(closeOffset.count()) >= 60) l[jss::close_time_offset] = static_cast(closeOffset.count()); - constexpr std::chrono::seconds kHIGH_AGE_THRESHOLD{1000000}; + static constexpr std::chrono::seconds kHighAgeThreshold{1000000}; if (ledgerMaster_.haveValidated()) { auto const age = ledgerMaster_.getValidatedLedgerAge(); - l[jss::age] = json::UInt(age < kHIGH_AGE_THRESHOLD ? age.count() : 0); + l[jss::age] = json::UInt(age < kHighAgeThreshold ? age.count() : 0); } else { @@ -2908,7 +2909,7 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) { using namespace std::chrono_literals; auto age = closeTime - lCloseTime; - l[jss::age] = json::UInt(age < kHIGH_AGE_THRESHOLD ? age.count() : 0); + l[jss::age] = json::UInt(age < kHighAgeThreshold ? age.count() : 0); } } } @@ -2942,31 +2943,31 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters) std::to_string(registry_.get().getOverlay().getPeerDisconnectCharges()); // This array must be sorted in increasing order. - static constexpr std::array kPROTOCOLS{ + static constexpr std::array kProtocols{ "http", "https", "peer", "ws", "ws2", "wss", "wss2"}; - static_assert(std::ranges::is_sorted(kPROTOCOLS)); + 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 if (!admin && - !(port.admin_nets_v4.empty() && port.admin_nets_v6.empty() && - port.admin_user.empty() && port.admin_password.empty())) + !(port.adminNetsV4.empty() && port.adminNetsV6.empty() && port.adminUser.empty() && + port.adminPassword.empty())) continue; std::vector proto; // NOLINTNEXTLINE(modernize-use-ranges) std::set_intersection( std::begin(port.protocol), std::end(port.protocol), - std::begin(kPROTOCOLS), - std::end(kPROTOCOLS), + std::begin(kProtocols), + std::end(kProtocols), 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"); } } @@ -3015,7 +3016,7 @@ NetworkOPsImp::pubProposedTransaction( if (transaction->isFlag(tfInnerBatchTxn)) return; - MultiApiJson jvObj = transJson(transaction, result, false, ledger, std::nullopt); + MultiApiJson const jvObj = transJson(transaction, result, false, ledger, std::nullopt); { std::scoped_lock const sl(subLock_); @@ -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; @@ -3080,7 +3081,7 @@ NetworkOPsImp::pubLedger(std::shared_ptr const& lpAccepted) jvObj[jss::network_id] = registry_.get().getNetworkIDService().getNetworkID(); if (!lpAccepted->rules().enabled(featureXRPFees)) - jvObj[jss::fee_ref] = kFEE_UNITS_DEPRECATED; + jvObj[jss::fee_ref] = kFeeUnitsDeprecated; jvObj[jss::fee_base] = lpAccepted->fees().base.jsonClipped(); jvObj[jss::reserve_base] = lpAccepted->fees().reserve.jsonClipped(); jvObj[jss::reserve_inc] = lpAccepted->fees().increment.jsonClipped(); @@ -3130,11 +3131,11 @@ NetworkOPsImp::pubLedger(std::shared_ptr const& lpAccepted) } { - static bool kFIRST_TIME = true; - if (kFIRST_TIME) + static bool kFirstTime = true; + if (kFirstTime) { // First validated ledger, start delayed SubAccountHistory - kFIRST_TIME = false; + kFirstTime = false; for (auto& outer : subAccountHistory_) { for (auto& inner : outer.second) @@ -3169,14 +3170,14 @@ NetworkOPsImp::reportFeeChange() // only schedule the job if something has changed if (f != lastFeeSummary_) { - job_queue_.addJob(JtClientFeeChange, "PubFee", [this]() { pubServer(); }); + jobQueue_.addJob(JtClientFeeChange, "PubFee", [this]() { pubServer(); }); } } void NetworkOPsImp::reportConsensusStateChange(ConsensusPhase phase) { - job_queue_.addJob(JtClientConsensus, "PubCons", [this, phase]() { pubConsensus(phase); }); + jobQueue_.addJob(JtClientConsensus, "PubCons", [this, phase]() { pubConsensus(phase); }); } inline void @@ -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()); @@ -3307,7 +3308,7 @@ NetworkOPsImp::pubValidatedTransaction( // Create two different Json objects, for different API versions auto const metaRef = std::ref(transaction.getMeta()); auto const trResult = transaction.getResult(); - MultiApiJson jvObj = transJson(stTxn, trResult, true, ledger, metaRef); + MultiApiJson const jvObj = transJson(stTxn, trResult, true, ledger, metaRef); { std::scoped_lock const sl(subLock_); @@ -3668,7 +3669,7 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo) * genesis account: first tx is the one with seq 1 * other account: first tx is the one created the account */ - if (accountId == kGENESIS_ACCOUNT_ID) + if (accountId == kGenesisAccountId) { auto stx = tx->getSTransaction(); if (stx->getAccountID(sfAccount) == accountId && stx->getSeqValue() == 1) @@ -3748,7 +3749,7 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo) int feeChargeCount = 0; if (auto sptr = subInfo.sinkWptr.lock(); sptr) { - sptr->getConsumer().charge(Resource::kFEE_MEDIUM_BURDEN_RPC); + sptr->getConsumer().charge(Resource::kFeeMediumBurdenRpc); ++feeChargeCount; } else @@ -3893,7 +3894,7 @@ NetworkOPsImp::subAccountHistoryStart( << ", no need to add AccountHistory job."; return; } - if (accountId == kGENESIS_ACCOUNT_ID) + if (accountId == kGenesisAccountId) { if (auto const sleAcct = ledger->read(accountKeylet); sleAcct) { @@ -4059,7 +4060,7 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, json::Value& jvResult) jvResult[jss::ledger_time] = json::Value::UInt(lpClosed->header().closeTime.time_since_epoch().count()); if (!lpClosed->rules().enabled(featureXRPFees)) - jvResult[jss::fee_ref] = kFEE_UNITS_DEPRECATED; + jvResult[jss::fee_ref] = kFeeUnitsDeprecated; jvResult[jss::fee_base] = lpClosed->fees().base.jsonClipped(); jvResult[jss::reserve_base] = lpClosed->fees().reserve.jsonClipped(); jvResult[jss::reserve_inc] = lpClosed->fees().increment.jsonClipped(); @@ -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); @@ -4404,7 +4405,7 @@ NetworkOPsImp::getBookPage( AuthHandling::ZeroIfUnauthorized, viewJ); - if (saOwnerFunds < beast::kZERO) + if (saOwnerFunds < beast::kZero) { // Treat negative funds as zero. @@ -4413,13 +4414,13 @@ NetworkOPsImp::getBookPage( } } - json::Value jvOffer = sleOffer->getJson(JsonOptions::KNone); + json::Value jvOffer = sleOffer->getJson(JsonOptions::Values::None); STAmount saTakerGetsFunded; STAmount saOwnerFundsLimit = saOwnerFunds; - Rate offerRate = kPARITY_RATE; + Rate offerRate = kParityRate; - if (rate != kPARITY_RATE + if (rate != kParityRate // Have a transfer fee. && uTakerID != book.out.getIssuer() // Not taking offers of own IOUs. @@ -4448,7 +4449,7 @@ NetworkOPsImp::getBookPage( .setJson(jvOffer[jss::taker_pays_funded]); } - STAmount const saOwnerPays = (kPARITY_RATE == offerRate) + STAmount const saOwnerPays = (kParityRate == offerRate) ? saTakerGetsFunded : std::min(saOwnerFunds, multiply(saTakerGetsFunded, offerRate)); @@ -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; @@ -4548,7 +4549,7 @@ NetworkOPsImp::getBookPage( uOfferOwnerID, book.out.currency, book.out.account, - FreezeHandling::fhZERO_IF_FROZEN); + FreezeHandling::ZeroIfFrozen); if (saOwnerFunds.isNegative()) { @@ -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 @@ -4625,26 +4626,25 @@ NetworkOPsImp::collectMetrics() counters[static_cast(mode)].dur += current; std::scoped_lock const lock(statsMutex_); - stats_.disconnected_duration.set( + stats_.disconnectedDuration.set( counters[static_cast(OperatingMode::DISCONNECTED)].dur.count()); - stats_.connected_duration.set( + stats_.connectedDuration.set( counters[static_cast(OperatingMode::CONNECTED)].dur.count()); - stats_.syncing_duration.set( + stats_.syncingDuration.set( counters[static_cast(OperatingMode::SYNCING)].dur.count()); - stats_.tracking_duration.set( + stats_.trackingDuration.set( counters[static_cast(OperatingMode::TRACKING)].dur.count()); - stats_.full_duration.set(counters[static_cast(OperatingMode::FULL)].dur.count()); + stats_.fullDuration.set(counters[static_cast(OperatingMode::FULL)].dur.count()); - stats_.disconnected_transitions.set( + stats_.disconnectedTransitions.set( counters[static_cast(OperatingMode::DISCONNECTED)].transitions); - stats_.connected_transitions.set( + stats_.connectedTransitions.set( counters[static_cast(OperatingMode::CONNECTED)].transitions); - stats_.syncing_transitions.set( + stats_.syncingTransitions.set( counters[static_cast(OperatingMode::SYNCING)].transitions); - stats_.tracking_transitions.set( + stats_.trackingTransitions.set( counters[static_cast(OperatingMode::TRACKING)].transitions); - stats_.full_transitions.set( - counters[static_cast(OperatingMode::FULL)].transitions); + stats_.fullTransitions.set(counters[static_cast(OperatingMode::FULL)].transitions); } void @@ -4674,13 +4674,13 @@ 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; - auto& state = obj[jss::state_accounting][kSTATES[i]]; + 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..fc3f71c0cc 100644 --- a/src/xrpld/app/misc/SHAMapStoreImp.cpp +++ b/src/xrpld/app/misc/SHAMapStoreImp.cpp @@ -116,7 +116,7 @@ SHAMapStoreImp::SHAMapStoreImp( section.set("cache_mb", std::to_string(config.getValueFor(SizedItem::HashNodeDbCache))); } - if (!section.exists("filter_bits") && (config.NODE_SIZE >= 2)) + if (!section.exists("filter_bits") && (config.nodeSize >= 2)) section.set("filter_bits", "10"); } @@ -141,22 +141,22 @@ SHAMapStoreImp::SHAMapStoreImp( getIfExists(section, "advisory_delete", advisoryDelete_); auto const minInterval = - config.standalone() ? kMINIMUM_DELETION_INTERVAL_SA : kMINIMUM_DELETION_INTERVAL; + config.standalone() ? kMinimumDeletionIntervalSa : kMinimumDeletionInterval; if (deleteInterval_ < minInterval) { Throw( "online_delete must be at least " + std::to_string(minInterval)); } - if (config.LEDGER_HISTORY > deleteInterval_) + if (config.ledgerHistory > deleteInterval_) { Throw( "online_delete must not be less than ledger_history " "(currently " + - std::to_string(config.LEDGER_HISTORY) + ")"); + std::to_string(config.ledgerHistory) + ")"); } - state_db_.init(config, dbName_); + stateDb_.init(config, dbName_); dbPaths(); } } @@ -169,14 +169,14 @@ SHAMapStoreImp::makeNodeStore(int readThreads) if (deleteInterval_ != 0u) { - SavedState state = state_db_.getState(); + SavedState state = stateDb_.getState(); auto writableBackend = makeBackendRotating(state.writableDb); auto archiveBackend = makeBackendRotating(state.archiveDb); if (state.writableDb.empty()) { state.writableDb = writableBackend->getName(); state.archiveDb = archiveBackend->getName(); - state_db_.setState(state); + stateDb_.setState(state); } // Create NodeStore with two backends to allow online deletion of @@ -187,7 +187,7 @@ SHAMapStoreImp::makeNodeStore(int readThreads) std::move(writableBackend), std::move(archiveBackend), nscfg, - app_.getJournal(kNODE_STORE_NAME)); + app_.getJournal(kNodeStoreName)); fdRequired_ += dbr->fdRequired(); dbRotating_ = dbr.get(); db.reset(dynamic_cast(dbr.release())); @@ -199,7 +199,7 @@ SHAMapStoreImp::makeNodeStore(int readThreads) scheduler_, readThreads, nscfg, - app_.getJournal(kNODE_STORE_NAME)); + app_.getJournal(kNodeStoreName)); fdRequired_ += db->fdRequired(); } return db; @@ -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) @@ -251,12 +251,12 @@ void SHAMapStoreImp::run() { beast::setCurrentThreadName("SHAMapStore"); - LedgerIndex lastRotated = state_db_.getState().lastRotated; + LedgerIndex lastRotated = stateDb_.getState().lastRotated; netOPs_ = &app_.getOPs(); ledgerMaster_ = &app_.getLedgerMaster(); if (advisoryDelete_) - canDelete_ = state_db_.getCanDelete(); + canDelete_ = stateDb_.getCanDelete(); while (true) { @@ -286,7 +286,7 @@ SHAMapStoreImp::run() if (lastRotated == 0u) { lastRotated = validatedSeq; - state_db_.setLastRotated(lastRotated); + stateDb_.setLastRotated(lastRotated); } bool const readyToRotate = validatedSeq >= lastRotated + deleteInterval_ && @@ -354,7 +354,7 @@ SHAMapStoreImp::run() savedState.writableDb = writableName; savedState.archiveDb = archiveName; savedState.lastRotated = lastRotated; - state_db_.setState(savedState); + stateDb_.setState(savedState); clearCaches(validatedSeq); }); @@ -383,7 +383,7 @@ SHAMapStoreImp::dbPaths() boost::filesystem::create_directories(dbPath); } - SavedState state = state_db_.getState(); + SavedState state = stateDb_.getState(); { auto update = [&dbPath](std::string& sPath) { @@ -403,7 +403,7 @@ SHAMapStoreImp::dbPaths() if (update(state.writableDb)) { update(state.archiveDb); - state_db_.setState(state); + stateDb_.setState(state); } } @@ -482,7 +482,7 @@ SHAMapStoreImp::makeBackendRotating(std::string path) section, megabytes(app_.config().getValueFor(SizedItem::BurstSize, std::nullopt)), scheduler_, - app_.getJournal(kNODE_STORE_NAME))}; + app_.getJournal(kNodeStoreName))}; backend->open(); return backend; } diff --git a/src/xrpld/app/misc/SHAMapStoreImp.h b/src/xrpld/app/misc/SHAMapStoreImp.h index c205d2dd90..4f0ce04e0d 100644 --- a/src/xrpld/app/misc/SHAMapStoreImp.h +++ b/src/xrpld/app/misc/SHAMapStoreImp.h @@ -57,16 +57,16 @@ private: // check health/stop status as records are copied std::uint64_t const checkHealthInterval_ = 1000; // minimum # of ledgers to maintain for health of network - static std::uint32_t const kMINIMUM_DELETION_INTERVAL = 256; + static std::uint32_t const kMinimumDeletionInterval = 256; // minimum # of ledgers required for standalone mode. - static std::uint32_t const kMINIMUM_DELETION_INTERVAL_SA = 8; + static std::uint32_t const kMinimumDeletionIntervalSa = 8; // minimum ledger to maintain online. std::atomic minimumOnline_; NodeStore::Scheduler& scheduler_; beast::Journal const journal_; NodeStore::DatabaseRotating* dbRotating_ = nullptr; - SavedStateDB state_db_; + SavedStateDB stateDb_; std::thread thread_; bool stop_ = false; bool healthy_ = true; @@ -94,7 +94,7 @@ private: NetworkOPs* netOPs_ = nullptr; LedgerMaster* ledgerMaster_ = nullptr; - static constexpr auto kNODE_STORE_NAME = "NodeStore"; + static constexpr auto kNodeStoreName = "NodeStore"; public: SHAMapStoreImp(Application& app, NodeStore::Scheduler& scheduler, beast::Journal journal); @@ -113,7 +113,7 @@ public: { if (advisoryDelete_) canDelete_ = seq; - return state_db_.setCanDelete(seq); + return stateDb_.setCanDelete(seq); } bool @@ -127,7 +127,7 @@ public: LedgerIndex getLastRotated() override { - return state_db_.getState().lastRotated; + return stateDb_.getState().lastRotated; } // All ledgers before and including this are unprotected diff --git a/src/xrpld/app/misc/TxQ.h b/src/xrpld/app/misc/TxQ.h index 4cd73acaec..ad689abed4 100644 --- a/src/xrpld/app/misc/TxQ.h +++ b/src/xrpld/app/misc/TxQ.h @@ -40,7 +40,7 @@ class TxQ { public: /// Fee level for single-signed reference transaction. - static constexpr FeeLevel64 kBASE_LEVEL{256}; + static constexpr FeeLevel64 kBaseLevel{256}; /** Structure used to customize @ref TxQ behavior. @@ -76,7 +76,7 @@ public: std::uint32_t retrySequencePercent = 25; /// Minimum value of the escalation multiplier, regardless /// of the prior ledger's median fee level. - FeeLevel64 minimumEscalationMultiplier = kBASE_LEVEL * 500; + FeeLevel64 minimumEscalationMultiplier = kBaseLevel * 500; /// Minimum number of transactions to allow into the ledger /// before escalation, regardless of the prior ledger's size. std::uint32_t minimumTxnInLedger = 32; @@ -512,7 +512,7 @@ private: their `retriesRemaining` forced down as part of the penalty. */ - int retriesRemaining{kRETRIES_ALLOWED}; + int retriesRemaining{kRetriesAllowed}; /// Flags provided to `apply`. If the transaction is later /// attempted with different flags, it will need to be /// `preflight`ed again. @@ -548,7 +548,7 @@ private: that the queue doesn't fill up with stale transactions which prevent lower fee level transactions from queuing. */ - static constexpr int kRETRIES_ALLOWED = 10; + static constexpr int kRetriesAllowed = 10; /** The hash of the parent ledger. @@ -761,7 +761,7 @@ private: /** parentHash_ used for logging only */ - LedgerHash parentHash_{beast::kZERO}; + LedgerHash parentHash_{beast::kZero}; /** Most queue operations are done under the master lock, but use this mutex for the RPC "fee" command, which isn't. @@ -831,13 +831,13 @@ template XRPAmount toDrops(FeeLevel const& level, XRPAmount baseFee) { - return mulDiv(level, baseFee, TxQ::kBASE_LEVEL).value_or(XRPAmount(STAmount::kMAX_NATIVE_N)); + return mulDiv(level, baseFee, TxQ::kBaseLevel).value_or(XRPAmount(STAmount::kMaxNativeN)); } inline FeeLevel64 toFeeLevel(XRPAmount const& drops, XRPAmount const& baseFee) { - return mulDiv(drops, TxQ::kBASE_LEVEL, baseFee) + return mulDiv(drops, TxQ::kBaseLevel, baseFee) .value_or(FeeLevel64(std::numeric_limits::max())); } diff --git a/src/xrpld/app/misc/ValidatorList.h b/src/xrpld/app/misc/ValidatorList.h index 5f051fe527..dcd7a24499 100644 --- a/src/xrpld/app/misc/ValidatorList.h +++ b/src/xrpld/app/misc/ValidatorList.h @@ -246,12 +246,12 @@ class ValidatorList hash_set negativeUNL_; // Currently supported versions of publisher list format - static constexpr std::uint32_t kSUPPORTED_LIST_VERSIONS[]{1, 2}; + static constexpr std::uint32_t kSupportedListVersions[]{1, 2}; // In the initial release, to prevent potential abuse and attacks, any VL // collection with more than 5 entries will be considered malformed. - static constexpr std::size_t kMAX_SUPPORTED_BLOBS = 5; + static constexpr std::size_t kMaxSupportedBlobs = 5; // Prefix of the file name used to store cache files. - static std::string const kFILE_PREFIX; + static std::string const kFilePrefix; public: ValidatorList( @@ -360,7 +360,7 @@ public: std::string const& rawManifest, std::map const& blobInfos, std::vector& messages, - std::size_t maxSize = kMAXIMUM_MESSAGE_SIZE); + std::size_t maxSize = kMaximumMessageSize); /** Apply multiple published lists of public keys, then broadcast it to all peers that have not seen it or sent it. diff --git a/src/xrpld/app/misc/ValidatorSite.h b/src/xrpld/app/misc/ValidatorSite.h index c4d2545217..55f060baf1 100644 --- a/src/xrpld/app/misc/ValidatorSite.h +++ b/src/xrpld/app/misc/ValidatorSite.h @@ -96,10 +96,10 @@ private: Application& app_; beast::Journal const j_; - // If both mutex are to be locked at the same time, `sites_mutex_` must be - // locked before `state_mutex_` or we may deadlock. - std::mutex mutable sites_mutex_; - std::mutex mutable state_mutex_; + // If both mutex are to be locked at the same time, `sitesMutex_` must be + // locked before `stateMutex_` or we may deadlock. + std::mutex mutable sitesMutex_; + std::mutex mutable stateMutex_; std::condition_variable cv_; std::weak_ptr work_; diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp index 56b97d3f7e..65771f6aa3 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 @@ -49,7 +49,7 @@ namespace xrpl { static std::vector> parseSection(Section const& section) { - static boost::regex const kRE1( + static boost::regex const kRe1( "^" // start of line "(?:\\s*)" // whitespace (optional) "([abcdefABCDEF0-9]{64})" // @@ -64,7 +64,7 @@ parseSection(Section const& section) { boost::smatch match; - if (!boost::regex_match(line, match, kRE1)) + if (!boost::regex_match(line, match, kRe1)) Throw("Invalid entry '" + line + "' in [" + section.name() + "]"); uint256 id; @@ -176,9 +176,9 @@ public: // from that validator. So flapping due to that validator being off // line will happen less frequently than every 24 hours. using namespace std::chrono_literals; - static constexpr NetClock::duration kEXPIRES_AFTER = 24h; + static constexpr NetClock::duration kExpiresAfter = 24h; - auto const newTimeout = closeTime + kEXPIRES_AFTER; + auto const newTimeout = closeTime + kExpiresAfter; // Walk all validations and replace previous votes from trusted // validators with these newest votes. @@ -330,8 +330,8 @@ public: threshold_ = std::max( 1L, static_cast( - (trustedValidations_ * kAMENDMENT_MAJORITY_CALC_THRESHOLD.num) / - kAMENDMENT_MAJORITY_CALC_THRESHOLD.den)); + (trustedValidations_ * kAmendmentMajorityCalcThreshold.num) / + kAmendmentMajorityCalcThreshold.den)); } [[nodiscard]] bool @@ -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 a963c68456..a3b03c115b 100644 --- a/src/xrpld/app/misc/detail/TxQ.cpp +++ b/src/xrpld/app/misc/detail/TxQ.cpp @@ -75,7 +75,7 @@ getFeeLevelPaid(ReadView const& view, STTx const& tx) return FeeLevel64(0); } - return mulDiv(effectiveFeePaid, TxQ::kBASE_LEVEL, baseFee) + return mulDiv(effectiveFeePaid, TxQ::kBaseLevel, baseFee) .value_or(FeeLevel64(std::numeric_limits::max())); } @@ -91,7 +91,7 @@ static FeeLevel64 increase(FeeLevel64 level, std::uint32_t increasePercent) { return mulDiv(level, 100 + increasePercent, 100) - .value_or(static_cast(xrpl::kMULDIV_MAX)); + .value_or(static_cast(xrpl::kMuldivMax)); } ////////////////////////////////////////////////////////////////////////// @@ -128,15 +128,15 @@ TxQ::FeeMetrics::update( // upperLimit must be >= minimumTxnCount_ or std::clamp can give // unexpected results auto const upperLimit = std::max( - mulDiv(txnsExpected_, cutPct, 100).value_or(xrpl::kMULDIV_MAX), minimumTxnCount_); + mulDiv(txnsExpected_, cutPct, 100).value_or(xrpl::kMuldivMax), minimumTxnCount_); txnsExpected_ = std::clamp( - mulDiv(size, cutPct, 100).value_or(xrpl::kMULDIV_MAX), minimumTxnCount_, upperLimit); + mulDiv(size, cutPct, 100).value_or(xrpl::kMuldivMax), minimumTxnCount_, upperLimit); recentTxnCounts_.clear(); } else if (size > txnsExpected_ || size > targetTxnCount_) { recentTxnCounts_.push_back(mulDiv(size, 100 + setup.normalConsensusIncreasePercent, 100) - .value_or(xrpl::kMULDIV_MAX)); + .value_or(xrpl::kMuldivMax)); auto const iter = std::ranges::max_element(recentTxnCounts_); BOOST_ASSERT(iter != recentTxnCounts_.end()); auto const next = [&] { @@ -192,15 +192,15 @@ TxQ::FeeMetrics::scaleFeeLevel(Snapshot const& snapshot, OpenView const& view) // Compute escalated fee level // Don't care about the overflow flag return mulDiv(multiplier, current * current, target * target) - .value_or(static_cast(xrpl::kMULDIV_MAX)); + .value_or(static_cast(xrpl::kMuldivMax)); } - return kBASE_LEVEL; + return kBaseLevel; } namespace detail { -constexpr static std::pair +static constexpr std::pair sumOfFirstSquares(std::size_t xIn) { // sum(n = 1->x) : n * n = x(x + 1)(2x + 1) / 6 @@ -392,7 +392,7 @@ TxQ::canBeHeld( // PreviousTxnID is deprecated and should never be used. // AccountTxnID is not supported by the transaction // queue yet, but should be added in the future. - // tapFAIL_HARD transactions are never held + // TapFailHard transactions are never held if (tx.isFieldPresent(sfPreviousTxnID) || tx.isFieldPresent(sfAccountTxnID) || ((flags & TapFailHard) != 0u)) return telCAN_NOT_QUEUE; @@ -739,6 +739,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: // @@ -756,7 +759,7 @@ TxQ::apply( // If the transaction needs a Ticket is that Ticket in the ledger? SeqProxy const acctSeqProx = SeqProxy::sequence((*sleAccount)[sfSequence]); SeqProxy const txSeqProx = tx->getSeqProxy(); - if (txSeqProx.isTicket() && !view.exists(keylet::kTICKET(account, txSeqProx))) + if (txSeqProx.isTicket() && !view.exists(keylet::kTicket(account, txSeqProx))) { if (txSeqProx.value() < acctSeqProx.value()) { @@ -1022,8 +1025,8 @@ TxQ::apply( // Sum fees and spending for all of the queued transactions // so we know how much to remove from the account balance // for the trial preclaim. - XRPAmount potentialSpend = beast::kZERO; - XRPAmount totalFee = beast::kZERO; + XRPAmount potentialSpend = beast::kZero; + XRPAmount totalFee = beast::kZero; for (auto iter = txIter->first; iter != txIter->end; ++iter) { // If we're replacing this transaction don't include @@ -1146,7 +1149,7 @@ TxQ::apply( return {pcresult.ter, false}; // Too low of a fee should get caught by preclaim - XRPL_ASSERT(feeLevelPaid >= kBASE_LEVEL, "xrpl::TxQ::apply : minimum fee"); + XRPL_ASSERT(feeLevelPaid >= kBaseLevel, "xrpl::TxQ::apply : minimum fee"); JLOG(j_.trace()) << "Transaction " << transactionID << " from account " << account << " has fee level of " << feeLevelPaid << " needs at least " @@ -1171,10 +1174,10 @@ TxQ::apply( conditions change, but don't waste the effort to clear). */ if (txSeqProx.isSeq() && txIter && multiTxn.has_value() && - txIter->first->second.retriesRemaining == MaybeTx::kRETRIES_ALLOWED && - feeLevelPaid > requiredFeeLevel && requiredFeeLevel > kBASE_LEVEL) + txIter->first->second.retriesRemaining == MaybeTx::kRetriesAllowed && + feeLevelPaid > requiredFeeLevel && requiredFeeLevel > kBaseLevel) { - OpenView sandbox(kOPEN_LEDGER, &view, view.rules()); + OpenView sandbox(kOpenLedger, &view, view.rules()); auto result = tryClearAccountQueueUpThruTx( app, @@ -1241,7 +1244,7 @@ TxQ::apply( if (lastRIter->feeLevel > feeLevelPaid || endAccount.transactions.size() == 1) return lastRIter->feeLevel; - constexpr FeeLevel64 kMAX{std::numeric_limits::max()}; + constexpr FeeLevel64 kMax{std::numeric_limits::max()}; auto endTotal = std::accumulate( endAccount.transactions.begin(), endAccount.transactions.end(), @@ -1250,8 +1253,8 @@ TxQ::apply( // Check for overflow. auto next = txn.second.feeLevel / endAccount.transactions.size(); auto mod = txn.second.feeLevel % endAccount.transactions.size(); - if (total.first >= kMAX - next || total.second >= kMAX - mod) - return {kMAX, FeeLevel64{0}}; + if (total.first >= kMax - next || total.second >= kMax - mod) + return {kMax, FeeLevel64{0}}; return {total.first + next, total.second + mod}; }); @@ -1742,9 +1745,9 @@ TxQ::getMetrics(OpenView const& view) const result.txQMaxSize = maxSize_; result.txInLedger = view.txCount(); result.txPerLedger = snapshot.txnsExpected; - result.referenceFeeLevel = kBASE_LEVEL; + result.referenceFeeLevel = kBaseLevel; result.minProcessingFeeLevel = - isFull() ? byFee_.rbegin()->feeLevel + FeeLevel64{1} : kBASE_LEVEL; + isFull() ? byFee_.rbegin()->feeLevel + FeeLevel64{1} : kBaseLevel; result.medFeeLevel = snapshot.escalationMultiplier; result.openLedgerFeeLevel = FeeMetrics::scaleFeeLevel(snapshot, view); @@ -1767,7 +1770,7 @@ TxQ::getTxRequiredFeeAndSeq(OpenView const& view, std::shared_ptr co std::uint32_t const accountSeq = sle ? (*sle)[sfSequence] : 0; std::uint32_t const availableSeq = nextQueuableSeqImpl(sle, lock).value(); return { - .fee = mulDiv(fee, baseFee, kBASE_LEVEL) + .fee = mulDiv(fee, baseFee, kBaseLevel) .value_or(XRPAmount(std::numeric_limits::max())), .accountSeq = accountSeq, .availableSeq = availableSeq}; @@ -1820,9 +1823,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..57b65814e1 100644 --- a/src/xrpld/app/misc/detail/ValidatorList.cpp +++ b/src/xrpld/app/misc/detail/ValidatorList.cpp @@ -130,7 +130,7 @@ ValidatorList::MessageWithHash::MessageWithHash( { } -std::string const ValidatorList::kFILE_PREFIX = "cache."; +std::string const ValidatorList::kFilePrefix = "cache."; ValidatorList::ValidatorList( ManifestCache& validatorManifests, @@ -291,7 +291,7 @@ ValidatorList::load( boost::filesystem::path ValidatorList::getCacheFileName(ValidatorList::scoped_lock const&, PublicKey const& pubKey) const { - return dataPath_ / (kFILE_PREFIX + strHex(pubKey)); + return dataPath_ / (kFilePrefix + strHex(pubKey)); } // static @@ -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; @@ -420,7 +420,7 @@ ValidatorList::parseBlobs(std::uint32_t version, json::Value const& body) case 2: default: { if (!body.isMember(jss::blobs_v2) || !body[jss::blobs_v2].isArray() || - body[jss::blobs_v2].size() > kMAX_SUPPORTED_BLOBS || + body[jss::blobs_v2].size() > kMaxSupportedBlobs || // If any of the v1 fields are present, the VL is malformed body.isMember(jss::blob) || body.isMember(jss::signature)) return {}; @@ -462,7 +462,7 @@ ValidatorList::parseBlobs(protocol::TMValidatorList const& body) std::vector ValidatorList::parseBlobs(protocol::TMValidatorListCollection const& body) { - if (body.blobs_size() > kMAX_SUPPORTED_BLOBS) + if (body.blobs_size() > kMaxSupportedBlobs) return {}; std::vector result; result.reserve(body.blobs_size()); @@ -536,7 +536,7 @@ splitMessageParts( smallMsg.set_manifest(blob.manifest()); XRPL_ASSERT( - Message::totalSize(smallMsg) <= kMAXIMUM_MESSAGE_SIZE, + Message::totalSize(smallMsg) <= kMaximumMessageSize, "xrpl::splitMessageParts : maximum message size"); messages.emplace_back( @@ -593,7 +593,7 @@ buildValidatorListMessage( msg.set_version(version); XRPL_ASSERT( - Message::totalSize(msg) <= kMAXIMUM_MESSAGE_SIZE, + Message::totalSize(msg) <= kMaximumMessageSize, "xrpl::buildValidatorListMessage(ValidatorBlobInfo) : maximum " "message size"); messages.emplace_back( @@ -659,7 +659,7 @@ ValidatorList::buildValidatorListMessages( std::string const& rawManifest, std::map const& blobInfos, std::vector& messages, - std::size_t maxSize /*= kMAXIMUM_MESSAGE_SIZE*/) + std::size_t maxSize /*= kMaximumMessageSize*/) { XRPL_ASSERT( !blobInfos.empty(), @@ -978,8 +978,8 @@ ValidatorList::applyLists( std::string siteUri, std::optional const& hash /* = {} */) { - if (std::count( - std::begin(kSUPPORTED_LIST_VERSIONS), std::end(kSUPPORTED_LIST_VERSIONS), version) != 1) + if (std::count(std::begin(kSupportedListVersions), std::end(kSupportedListVersions), version) != + 1) return PublisherListStats{ListDisposition::UnsupportedVersion}; std::scoped_lock const lock{mutex_}; @@ -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..76fd078174 100644 --- a/src/xrpld/app/misc/detail/ValidatorSite.cpp +++ b/src/xrpld/app/misc/detail/ValidatorSite.cpp @@ -44,9 +44,9 @@ namespace xrpl { -auto constexpr kDEFAULT_REFRESH_INTERVAL = std::chrono::minutes{5}; -auto constexpr kERROR_RETRY_INTERVAL = std::chrono::seconds{30}; -unsigned short constexpr kMAX_REDIRECTS = 3; +constexpr auto kDefaultRefreshInterval = std::chrono::minutes{5}; +constexpr auto kErrorRetryInterval = std::chrono::seconds{30}; +unsigned constexpr short kMaxRedirects = 3; ValidatorSite::Site::Resource::Resource(std::string inUri) : uri{std::move(inUri)} { @@ -92,7 +92,7 @@ ValidatorSite::Site::Resource::Resource(std::string inUri) : uri{std::move(inUri ValidatorSite::Site::Site(std::string uri) : loadedResource{std::make_shared(std::move(uri))} , startingResource{loadedResource} - , refreshInterval{kDEFAULT_REFRESH_INTERVAL} + , refreshInterval{kDefaultRefreshInterval} , nextRefresh{clock_type::now()} { @@ -114,7 +114,7 @@ ValidatorSite::ValidatorSite( ValidatorSite::~ValidatorSite() { - std::unique_lock lock{state_mutex_}; + std::unique_lock lock{stateMutex_}; if (timer_.expiry() > clock_type::time_point{}) { if (!stopping_) @@ -141,7 +141,7 @@ ValidatorSite::load(std::vector const& siteURIs) { JLOG(j_.debug()) << "Loading configured validator list sites"; - std::scoped_lock const lock{sites_mutex_}; + std::scoped_lock const lock{sitesMutex_}; return load(siteURIs, lock); } @@ -178,8 +178,8 @@ ValidatorSite::load( void ValidatorSite::start() { - std::scoped_lock const l0{sites_mutex_}; - std::scoped_lock const l1{state_mutex_}; + std::scoped_lock const l0{sitesMutex_}; + std::scoped_lock const l1{stateMutex_}; if (timer_.expiry() == clock_type::time_point{}) setTimer(l0, l1); } @@ -187,14 +187,14 @@ ValidatorSite::start() void ValidatorSite::join() { - std::unique_lock lock{state_mutex_}; + std::unique_lock lock{stateMutex_}; cv_.wait(lock, [&] { return !pending_; }); } void ValidatorSite::stop() { - std::unique_lock lock{state_mutex_}; + std::unique_lock lock{stateMutex_}; stopping_ = true; // work::cancel() must be called before the // cv wait in order to kick any asio async operations @@ -246,7 +246,7 @@ ValidatorSite::makeRequest( sites_[siteIdx].activeResource = resource; std::shared_ptr sp; auto timeoutCancel = [this]() { - std::scoped_lock const lockState{state_mutex_}; + std::scoped_lock const lockState{stateMutex_}; // docs indicate cancel_one() can throw, but this // should be reconsidered if it changes to noexcept try @@ -312,7 +312,7 @@ ValidatorSite::makeRequest( sp->run(); // start a timer for the request, which shouldn't take more // than requestTimeout_ to complete - std::scoped_lock const lockState{state_mutex_}; + std::scoped_lock const lockState{stateMutex_}; timer_.expires_after(requestTimeout_); timer_.async_wait([this, siteIdx](boost::system::error_code const& ec) { this->onRequestTimeout(siteIdx, ec); @@ -326,7 +326,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec) return; { - std::scoped_lock const lockSite{sites_mutex_}; + std::scoped_lock const lockSite{sitesMutex_}; // In some circumstances, both this function and the response // handler (onSiteFetch or onTextFetch) can get queued and // processed. In all observed cases, the response handler @@ -343,7 +343,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec) "already been processed"; } - std::scoped_lock const lockState{state_mutex_}; + std::scoped_lock const lockState{stateMutex_}; if (auto sp = work_.lock()) sp->cancel(); } @@ -362,7 +362,7 @@ ValidatorSite::onTimer(std::size_t siteIdx, error_code const& ec) try { - std::scoped_lock const lock{sites_mutex_}; + std::scoped_lock const lock{sitesMutex_}; sites_[siteIdx].nextRefresh = clock_type::now() + sites_[siteIdx].refreshInterval; sites_[siteIdx].redirCount = 0; // the WorkSSL client ctor can throw if SSL init fails @@ -512,7 +512,7 @@ ValidatorSite::processRedirect( throw std::runtime_error{"missing location"}; } - if (sites_[siteIdx].redirCount == kMAX_REDIRECTS) + if (sites_[siteIdx].redirCount == kMaxRedirects) { JLOG(j_.warn()) << "Exceeded max redirects for validator list at " << sites_[siteIdx].loadedResource->uri; @@ -545,7 +545,7 @@ ValidatorSite::onSiteFetch( detail::response_type const& res, std::size_t siteIdx) { - std::scoped_lock lockSites{sites_mutex_}; + std::scoped_lock lockSites{sitesMutex_}; { if (endpoint != endpoint_type{}) sites_[siteIdx].lastRequestEndpoint = endpoint; @@ -558,7 +558,7 @@ ValidatorSite::onSiteFetch( .disposition = ListDisposition::Invalid, .message = errMsg}); if (retry) - sites_[siteIdx].nextRefresh = clock_type::now() + kERROR_RETRY_INTERVAL; + sites_[siteIdx].nextRefresh = clock_type::now() + kErrorRetryInterval; // See if there's a copy saved locally from last time we // saw the list. @@ -617,7 +617,7 @@ ValidatorSite::onSiteFetch( sites_[siteIdx].activeResource.reset(); } - std::scoped_lock const lockState{state_mutex_}; + std::scoped_lock const lockState{stateMutex_}; fetching_ = false; if (!stopping_) setTimer(lockSites, lockState); @@ -630,7 +630,7 @@ ValidatorSite::onTextFetch( std::string const& res, std::size_t siteIdx) { - std::scoped_lock const lockSites{sites_mutex_}; + std::scoped_lock const lockSites{sitesMutex_}; { try { @@ -657,7 +657,7 @@ ValidatorSite::onTextFetch( sites_[siteIdx].activeResource.reset(); } - std::scoped_lock const lockState{state_mutex_}; + std::scoped_lock const lockState{stateMutex_}; fetching_ = false; if (!stopping_) setTimer(lockSites, lockState); @@ -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_}; + std::scoped_lock const lock{sitesMutex_}; 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/misc/detail/WorkSSL.cpp b/src/xrpld/app/misc/detail/WorkSSL.cpp index 0a8d53b1a2..e1b864e81f 100644 --- a/src/xrpld/app/misc/detail/WorkSSL.cpp +++ b/src/xrpld/app/misc/detail/WorkSSL.cpp @@ -30,9 +30,9 @@ WorkSSL::WorkSSL( callback_type cb) : WorkBase(host, path, port, ios, lastEndpoint, lastStatus, cb) , context_( - config.SSL_VERIFY_DIR, - config.SSL_VERIFY_FILE, - config.SSL_VERIFY, + config.sslVerifyDir, + config.sslVerifyFile, + config.sslVerify, j, boost::asio::ssl::context::tlsv12_client) , stream_(socket_, context_.context()) diff --git a/src/xrpld/app/rdb/backend/detail/Node.cpp b/src/xrpld/app/rdb/backend/detail/Node.cpp index 8530fb2e65..1fd3136420 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 @@ -75,7 +75,7 @@ namespace xrpl::detail { static std::string toString(TableType type) { - static_assert(kTABLE_TYPE_COUNT == 3, "Need to modify switch statement if enum is modified"); + static_assert(kTableTypeCount == 3, "Need to modify switch statement if enum is modified"); switch (type) { @@ -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 } @@ -102,7 +102,7 @@ makeLedgerDBs( { // ledger database auto lgr{std::make_unique( - setup, kLGR_DB_NAME, setup.lgrPragma, kLGR_DB_INIT, checkpointerSetup, j)}; + setup, kLgrDbName, setup.lgrPragma, kLgrDbInit, checkpointerSetup, j)}; lgr->getSession() << boost::str( boost::format("PRAGMA cache_size=-%d;") % kilobytes(config.getValueFor(SizedItem::LgrDbCache))); @@ -111,7 +111,7 @@ makeLedgerDBs( { // transaction database auto tx{std::make_unique( - setup, kTX_DB_NAME, setup.txPragma, kTX_DB_INIT, checkpointerSetup, j)}; + setup, kTxDbName, setup.txPragma, kTxDbInit, checkpointerSetup, j)}; tx->getSession() << boost::str( boost::format("PRAGMA cache_size=-%d;") % kilobytes(config.getValueFor(SizedItem::TxnDbCache))); @@ -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 @@ -274,16 +274,15 @@ saveValidatedLedger( } { - static boost::format kDELETE_LEDGER("DELETE FROM Ledgers WHERE LedgerSeq = %u;"); - static boost::format kDELETE_TRANS1("DELETE FROM Transactions WHERE LedgerSeq = %u;"); - static boost::format kDELETE_TRANS2( - "DELETE FROM AccountTransactions WHERE LedgerSeq = %u;"); - static boost::format kDELETE_ACCT_TRANS( + static boost::format kDeleteLedger("DELETE FROM Ledgers WHERE LedgerSeq = %u;"); + static boost::format kDeleteTranS1("DELETE FROM Transactions WHERE LedgerSeq = %u;"); + static boost::format kDeleteTranS2("DELETE FROM AccountTransactions WHERE LedgerSeq = %u;"); + static boost::format kDeleteAcctTrans( "DELETE FROM AccountTransactions WHERE TransID = '%s';"); { auto db = ldgDB.checkoutDb(); - *db << boost::str(kDELETE_LEDGER % seq); + *db << boost::str(kDeleteLedger % seq); } if (app.config().useTxTables()) @@ -300,8 +299,8 @@ saveValidatedLedger( soci::transaction tr(*db); - *db << boost::str(kDELETE_TRANS1 % seq); - *db << boost::str(kDELETE_TRANS2 % seq); + *db << boost::str(kDeleteTranS1 % seq); + *db << boost::str(kDeleteTranS2 % seq); std::string const ledgerSeq(std::to_string(seq)); @@ -312,7 +311,7 @@ saveValidatedLedger( std::string const txnId(to_string(transactionID)); std::string const txnSeq(std::to_string(acceptedLedgerTx->getTxnSeq())); - *db << boost::str(kDELETE_ACCT_TRANS % transactionID); + *db << boost::str(kDeleteAcctTrans % transactionID); auto const& accts = acceptedLedgerTx->getAffected(); @@ -358,7 +357,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 @@ -378,7 +377,7 @@ saveValidatedLedger( } { - static std::string const kADD_LEDGER( + static std::string const kAddLedger( R"sql(INSERT OR REPLACE INTO Ledgers (LedgerHash,LedgerSeq,PrevHash,TotalCoins,ClosingTime,PrevClosingTime, CloseTimeRes,CloseFlags,AccountSetHash,TransSetHash) @@ -401,7 +400,7 @@ saveValidatedLedger( auto const accountHash = to_string(ledger->header().accountHash); auto const txHash = to_string(ledger->header().txHash); - *db << kADD_LEDGER, soci::use(hash), soci::use(seq), soci::use(parentHash), + *db << kAddLedger, soci::use(hash), soci::use(seq), soci::use(parentHash), soci::use(drops), soci::use(closeTime), soci::use(parentCloseTime), soci::use(closeTimeResolution), soci::use(closeFlags), soci::use(accountHash), soci::use(txHash); @@ -697,8 +696,8 @@ transactionsSQL( bool count, beast::Journal j) { - constexpr std::uint32_t kNONBINARY_PAGE_LENGTH = 200; - constexpr std::uint32_t kBINARY_PAGE_LENGTH = 500; + static constexpr std::uint32_t kNonbinaryPageLength = 200; + static constexpr std::uint32_t kBinaryPageLength = 500; std::uint32_t numberOfResults = 0; @@ -708,12 +707,12 @@ transactionsSQL( } else if (options.limit == UINT32_MAX) { - numberOfResults = binary ? kBINARY_PAGE_LENGTH : kNONBINARY_PAGE_LENGTH; + numberOfResults = binary ? kBinaryPageLength : kNonbinaryPageLength; } else if (!options.bUnlimited) { numberOfResults = - std::min(binary ? kBINARY_PAGE_LENGTH : kNONBINARY_PAGE_LENGTH, options.limit); + std::min(binary ? kBinaryPageLength : kNonbinaryPageLength, options.limit); } else { @@ -1048,7 +1047,7 @@ accountTxPage( std::optional newmarker; - static std::string const kPREFIX( + static std::string const kPrefix( R"(SELECT AccountTransactions.LedgerSeq,AccountTransactions.TxnSeq, Status,RawTxn,TxnMeta FROM AccountTransactions INNER JOIN Transactions @@ -1065,7 +1064,7 @@ accountTxPage( if (findLedger == 0) { sql = boost::str( - boost::format(kPREFIX + (R"(AccountTransactions.LedgerSeq BETWEEN %u AND %u + boost::format(kPrefix + (R"(AccountTransactions.LedgerSeq BETWEEN %u AND %u ORDER BY AccountTransactions.LedgerSeq %s, AccountTransactions.TxnSeq %s LIMIT %u;)")) % @@ -1303,7 +1302,7 @@ dbHasSpace(soci::session& session, Config const& config, beast::Journal j) if (config.useTxTables()) { DatabaseCon::Setup const dbSetup = setupDatabaseCon(config); - boost::filesystem::path const dbPath = dbSetup.dataDir / kTX_DB_NAME; + boost::filesystem::path const dbPath = dbSetup.dataDir / kTxDbName; boost::system::error_code ec; std::optional dbSize = boost::filesystem::file_size(dbPath, ec); if (ec) @@ -1312,23 +1311,23 @@ dbHasSpace(soci::session& session, Config const& config, beast::Journal j) dbSize.reset(); } - static auto const kPAGE_SIZE = [&] { + static auto const kPageSize = [&] { std::uint32_t ps = 0; session << "PRAGMA page_size;", soci::into(ps); return ps; }(); - static auto const kMAX_PAGES = [&] { + static auto const kMaxPages = [&] { std::uint32_t mp = 0; session << "PRAGMA max_page_count;", soci::into(mp); return mp; }(); std::uint32_t pageCount = 0; session << "PRAGMA page_count;", soci::into(pageCount); - std::uint32_t const freePages = kMAX_PAGES - pageCount; - std::uint64_t const freeSpace = safeCast(freePages) * kPAGE_SIZE; + std::uint32_t const freePages = kMaxPages - pageCount; + std::uint64_t const freeSpace = safeCast(freePages) * kPageSize; JLOG(j.info()) << "Transaction DB pathname: " << dbPath.string() << "; file size: " << dbSize.value_or(-1) << " bytes" - << "; SQLite page size: " << kPAGE_SIZE << " bytes" + << "; SQLite page size: " << kPageSize << " bytes" << "; Free pages: " << freePages << "; Free space: " << freeSpace << " bytes; " << "Note that this does not take into account available disk " diff --git a/src/xrpld/app/rdb/backend/detail/Node.h b/src/xrpld/app/rdb/backend/detail/Node.h index f5beb230b1..8267bb1a82 100644 --- a/src/xrpld/app/rdb/backend/detail/Node.h +++ b/src/xrpld/app/rdb/backend/detail/Node.h @@ -9,7 +9,7 @@ namespace xrpl::detail { /* Need to change TableTypeCount if TableType is modified. */ enum class TableType { Ledgers, Transactions, AccountTransactions }; -constexpr int kTABLE_TYPE_COUNT = 3; +constexpr int kTableTypeCount = 3; struct DatabasePairValid { diff --git a/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp b/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp index a50d17bf2b..fd1298516f 100644 --- a/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp +++ b/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp @@ -420,7 +420,7 @@ SQLiteDatabase::oldestAccountTxPage(AccountTxPageOptions const& options) if (!useTxTables_) return {}; - static std::uint32_t const kPAGE_LENGTH(200); + static std::uint32_t const kPageLength(200); auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1); AccountTxs ret; @@ -436,7 +436,7 @@ SQLiteDatabase::oldestAccountTxPage(AccountTxPageOptions const& options) { auto db = checkoutTransaction(); auto newmarker = - detail::oldestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPAGE_LENGTH) + detail::oldestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPageLength) .first; return {ret, newmarker}; } @@ -450,7 +450,7 @@ SQLiteDatabase::newestAccountTxPage(AccountTxPageOptions const& options) if (!useTxTables_) return {}; - static std::uint32_t const kPAGE_LENGTH(200); + static std::uint32_t const kPageLength(200); auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1); AccountTxs ret; @@ -466,7 +466,7 @@ SQLiteDatabase::newestAccountTxPage(AccountTxPageOptions const& options) { auto db = checkoutTransaction(); auto newmarker = - detail::newestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPAGE_LENGTH) + detail::newestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPageLength) .first; return {ret, newmarker}; } @@ -480,7 +480,7 @@ SQLiteDatabase::oldestAccountTxPageB(AccountTxPageOptions const& options) if (!useTxTables_) return {}; - static std::uint32_t const kPAGE_LENGTH(500); + static std::uint32_t const kPageLength(500); auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1); MetaTxsList ret; @@ -494,7 +494,7 @@ SQLiteDatabase::oldestAccountTxPageB(AccountTxPageOptions const& options) { auto db = checkoutTransaction(); auto newmarker = - detail::oldestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPAGE_LENGTH) + detail::oldestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPageLength) .first; return {ret, newmarker}; } @@ -508,7 +508,7 @@ SQLiteDatabase::newestAccountTxPageB(AccountTxPageOptions const& options) if (!useTxTables_) return {}; - static std::uint32_t const kPAGE_LENGTH(500); + static std::uint32_t const kPageLength(500); auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1); MetaTxsList ret; @@ -522,7 +522,7 @@ SQLiteDatabase::newestAccountTxPageB(AccountTxPageOptions const& options) { auto db = checkoutTransaction(); auto newmarker = - detail::newestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPAGE_LENGTH) + detail::newestAccountTxPage(*db, onUnsavedLedger, onTransaction, options, kPageLength) .first; return {ret, newmarker}; } @@ -641,10 +641,10 @@ SQLiteDatabase::SQLiteDatabase(ServiceRegistry& registry, Config const& config, setup, DatabaseCon::CheckpointerSetup{.jobQueue = &jobQueue, .registry = registry_})) { - std::string_view constexpr kERROR = "Failed to create ledger databases"; + static constexpr std::string_view kError = "Failed to create ledger databases"; - JLOG(j_.fatal()) << kERROR; - Throw(kERROR.data()); + JLOG(j_.fatal()) << kError; + Throw(kError.data()); } } 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.cpp b/src/xrpld/consensus/Consensus.cpp index 5498f7cf79..d529ab2e44 100644 --- a/src/xrpld/consensus/Consensus.cpp +++ b/src/xrpld/consensus/Consensus.cpp @@ -35,7 +35,7 @@ shouldCloseLedger( << ", timeSincePrevClose: " << timeSincePrevClose.count() << "ms" << ", openTime: " << openTime.count() << "ms" << ", idleInterval: " << idleInterval.count() << "ms" - << ", ledgerMIN_CLOSE: " << parms.ledgerMIN_CLOSE.count() << "ms" + << ", ledgerMIN_CLOSE: " << parms.ledgerMinClose.count() << "ms" << ". "; using namespace std::chrono_literals; if ((prevRoundTime < -1s) || (prevRoundTime > 10min) || (timeSincePrevClose > 10min)) @@ -67,7 +67,7 @@ shouldCloseLedger( } // Preserve minimum ledger open time - if (openTime < parms.ledgerMIN_CLOSE) + if (openTime < parms.ledgerMinClose) { JLOG(j.debug()) << "Must wait minimum time before closing"; CLOG(clog) << "not closing because under ledgerMIN_CLOSE. "; @@ -175,12 +175,12 @@ checkConsensus( << " agree=" << currentAgree << " validated=" << currentFinished << " time=" << currentAgreeTime.count() << "/" << previousAgreeTime.count() << " proposing? " << proposing - << " minimum duration to reach consensus: " << parms.ledgerMIN_CONSENSUS.count() + << " minimum duration to reach consensus: " << parms.ledgerMinConsensus.count() << "ms" - << " max consensus time " << parms.ledgerMAX_CONSENSUS.count() << "ms" - << " minimum consensus percentage: " << parms.minCONSENSUS_PCT << ". "; + << " max consensus time " << parms.ledgerMaxConsensus.count() << "ms" + << " minimum consensus percentage: " << parms.minConsensusPct << ". "; - if (currentAgreeTime <= parms.ledgerMIN_CONSENSUS) + if (currentAgreeTime <= parms.ledgerMinConsensus) { CLOG(clog) << "Not reached. "; return ConsensusState::No; @@ -190,7 +190,7 @@ checkConsensus( { // Less than 3/4 of the last ledger's proposers are present; don't // rush: we may need more time. - if (currentAgreeTime < (previousAgreeTime + parms.ledgerMIN_CONSENSUS)) + if (currentAgreeTime < (previousAgreeTime + parms.ledgerMinConsensus)) { JLOG(j.trace()) << "too fast, not enough proposers"; CLOG(clog) << "Too fast, not enough proposers. Not reached. "; @@ -204,8 +204,8 @@ checkConsensus( currentAgree, currentProposers, proposing, - parms.minCONSENSUS_PCT, - currentAgreeTime > parms.ledgerMAX_CONSENSUS, + parms.minConsensusPct, + currentAgreeTime > parms.ledgerMaxConsensus, stalled, clog)) { @@ -221,8 +221,8 @@ checkConsensus( currentFinished, currentProposers, false, - parms.minCONSENSUS_PCT, - currentAgreeTime > parms.ledgerMAX_CONSENSUS, + parms.minConsensusPct, + currentAgreeTime > parms.ledgerMaxConsensus, false, clog)) { @@ -232,9 +232,9 @@ checkConsensus( } std::chrono::milliseconds const maxAgreeTime = - previousAgreeTime * parms.ledgerABANDON_CONSENSUS_FACTOR; + previousAgreeTime * parms.ledgerAbandonConsensusFactor; if (currentAgreeTime > - std::clamp(maxAgreeTime, parms.ledgerMAX_CONSENSUS, parms.ledgerABANDON_CONSENSUS)) + std::clamp(maxAgreeTime, parms.ledgerMaxConsensus, parms.ledgerAbandonConsensus)) { JLOG(j.warn()) << "consensus taken too long"; CLOG(clog) << "Consensus taken too long. "; diff --git a/src/xrpld/consensus/Consensus.h b/src/xrpld/consensus/Consensus.h index e5c06bd1c8..131db30ce0 100644 --- a/src/xrpld/consensus/Consensus.h +++ b/src/xrpld/consensus/Consensus.h @@ -549,7 +549,7 @@ private: // How long has this round been open ConsensusTimer openTime_; - NetClock::duration closeResolution_ = kLEDGER_DEFAULT_TIME_RESOLUTION; + NetClock::duration closeResolution_ = kLedgerDefaultTimeResolution; ConsensusParms::AvalancheState closeTimeAvalancheState_ = ConsensusParms::AvalancheState::Init; @@ -625,7 +625,7 @@ Consensus::startRound( if (firstRound_) { // take our initial view of closeTime_ from the seed ledger - prevRoundTime_ = adaptor_.parms().ledgerIDLE_INTERVAL; + prevRoundTime_ = adaptor_.parms().ledgerIdleInterval; prevCloseTime_ = prevLedger.closeTime(); firstRound_ = false; } @@ -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)); @@ -1169,9 +1169,9 @@ Consensus::phaseOpen(std::unique_ptr const& clog) } auto const idleInterval = std::max( - adaptor_.parms().ledgerIDLE_INTERVAL, 2 * previousLedger_.closeTimeResolution()); + adaptor_.parms().ledgerIdleInterval, 2 * previousLedger_.closeTimeResolution()); CLOG(clog) << "idle interval set to " << idleInterval.count() << "ms based on " - << "ledgerIDLE_INTERVAL: " << adaptor_.parms().ledgerIDLE_INTERVAL.count() + << "ledgerIDLE_INTERVAL: " << adaptor_.parms().ledgerIdleInterval.count() << ", previous ledger close time resolution: " << previousLedger_.closeTimeResolution().count() << "ms. "; @@ -1218,7 +1218,7 @@ Consensus::shouldPause(std::unique_ptr const& clog) << "roundTime: " << result_->roundTime.read().count() << ", " // NOLINTEND(bugprone-unchecked-optional-access) - << "max consensus time: " << parms.ledgerMAX_CONSENSUS.count() << ", " + << "max consensus time: " << parms.ledgerMaxConsensus.count() << ", " << "validators: " << totalValidators << ", " << "laggards: " << laggards << ", " << "offline: " << offline << ", " @@ -1227,7 +1227,7 @@ Consensus::shouldPause(std::unique_ptr const& clog) if ((ahead == 0u) || (laggards == 0u) || (totalValidators == 0u) || !adaptor_.validator() || !adaptor_.haveValidated() || // NOLINTNEXTLINE(bugprone-unchecked-optional-access) result_ set as shouldPause called - result_->roundTime.read() > parms.ledgerMAX_CONSENSUS) + result_->roundTime.read() > parms.ledgerMaxConsensus) { j_.debug() << "not pausing (early)" << vars.str(); CLOG(clog) << "Not pausing (early). "; @@ -1249,7 +1249,7 @@ Consensus::shouldPause(std::unique_ptr const& clog) * 3: >=95% * 4: =100% */ - constexpr static std::size_t kMAX_PAUSE_PHASE = 4; + static constexpr std::size_t kMaxPausePhase = 4; /** * No particular threshold guarantees consensus. Lower thresholds @@ -1270,7 +1270,7 @@ Consensus::shouldPause(std::unique_ptr const& clog) * else out of the scope of this delay mechanism is wrong with the * network. */ - std::size_t const phase = (ahead - 1) % (kMAX_PAUSE_PHASE + 1); + std::size_t const phase = (ahead - 1) % (kMaxPausePhase + 1); // validators that remain after the laggards() function are considered // offline, and should be considered as laggards for purposes of @@ -1282,7 +1282,7 @@ Consensus::shouldPause(std::unique_ptr const& clog) if (laggards + offline > totalValidators - quorum) willPause = true; break; - case kMAX_PAUSE_PHASE: + case kMaxPausePhase: // No tolerance. willPause = true; break; @@ -1297,7 +1297,7 @@ Consensus::shouldPause(std::unique_ptr const& clog) float const nonLaggards = totalValidators - (laggards + offline); float const quorumRatio = static_cast(quorum) / totalValidators; float const allowedDissent = 1.0f - quorumRatio; - float const phaseFactor = static_cast(phase) / kMAX_PAUSE_PHASE; + float const phaseFactor = static_cast(phase) / kMaxPausePhase; if (nonLaggards / totalValidators < quorumRatio + (allowedDissent * phaseFactor)) { @@ -1337,17 +1337,17 @@ Consensus::phaseEstablish(std::unique_ptr const& clo result_->proposers = currPeerPositions_.size(); convergePercent_ = result_->roundTime.read() * 100 / - std::max(prevRoundTime_, parms.avMIN_CONSENSUS_TIME); + std::max(prevRoundTime_, parms.avMinConsensusTime); CLOG(clog) << "convergePercent_ " << convergePercent_ << " is based on round duration so far: " << result_->roundTime.read().count() << "ms, " << "previous round duration: " << prevRoundTime_.count() << "ms, " - << "avMIN_CONSENSUS_TIME: " << parms.avMIN_CONSENSUS_TIME.count() << "ms. "; + << "avMIN_CONSENSUS_TIME: " << parms.avMinConsensusTime.count() << "ms. "; // Give everyone a chance to take an initial position - if (result_->roundTime.read() < parms.ledgerMIN_CONSENSUS) + if (result_->roundTime.read() < parms.ledgerMinConsensus) { - CLOG(clog) << "ledgerMIN_CONSENSUS not reached: " << parms.ledgerMIN_CONSENSUS.count() + CLOG(clog) << "ledgerMIN_CONSENSUS not reached: " << parms.ledgerMinConsensus.count() << "ms. "; return; } @@ -1542,7 +1542,7 @@ Consensus::updateOurPositions(std::unique_ptr const& int threshVote = participantsNeeded(participants, neededWeight); // Threshold to declare consensus - int const threshConsensus = participantsNeeded(participants, parms.avCT_CONSENSUS_PCT); + int const threshConsensus = participantsNeeded(participants, parms.avCtConsensusPct); std::stringstream ss; ss << "Proposers:" << currPeerPositions_.size() << " nw:" << neededWeight @@ -1696,9 +1696,9 @@ Consensus::haveConsensus(std::unique_ptr const& clog // Consensus has taken far too long. Drop out of the round. if (result_->state == ConsensusState::Expired) { - static auto const kMINIMUM_COUNTER = parms.avalancheCutoffs.size() * parms.avMIN_ROUNDS; + static auto const kMinimumCounter = parms.avalancheCutoffs.size() * parms.avMinRounds; std::stringstream ss; - if (establishCounter_ < kMINIMUM_COUNTER) + if (establishCounter_ < kMinimumCounter) { // If each round of phaseEstablish takes a very long time, we may // "expire" before we've given consensus enough time at each @@ -1708,7 +1708,7 @@ Consensus::haveConsensus(std::unique_ptr const& clog // amount of time. ss << "Consensus time has expired in round " << establishCounter_ - << "; continue until round " << kMINIMUM_COUNTER << ". " + << "; continue until round " << kMinimumCounter << ". " << json::Compact{getJson(false)}; JLOG(j_.error()) << ss.str(); CLOG(clog) << ss.str() << ". "; diff --git a/src/xrpld/consensus/ConsensusParms.h b/src/xrpld/consensus/ConsensusParms.h index 88a6318b3c..e6dd7f046e 100644 --- a/src/xrpld/consensus/ConsensusParms.h +++ b/src/xrpld/consensus/ConsensusParms.h @@ -28,7 +28,7 @@ struct ConsensusParms This is a safety to protect against very old validations and the time it takes to adjust the close time accuracy window. */ - std::chrono::seconds const validationVALID_WALL = std::chrono::minutes{5}; + std::chrono::seconds const validationValidWall = std::chrono::minutes{5}; /** Duration a validation remains current after first observed. @@ -36,14 +36,14 @@ struct ConsensusParms first saw it. This provides faster recovery in very rare cases where the number of validations produced by the network is lower than normal */ - std::chrono::seconds const validationVALID_LOCAL = std::chrono::minutes{3}; + std::chrono::seconds const validationValidLocal = std::chrono::minutes{3}; /** Duration pre-close in which validations are acceptable. The number of seconds before a close time that we consider a validation acceptable. This protects against extreme clock errors */ - std::chrono::seconds const validationVALID_EARLY = std::chrono::minutes{3}; + std::chrono::seconds const validationValidEarly = std::chrono::minutes{3}; //! How long we consider a proposal fresh std::chrono::seconds const proposeFRESHNESS = std::chrono::seconds{20}; @@ -56,13 +56,13 @@ struct ConsensusParms // millisecond resolution. //! The percentage threshold above which we can declare consensus. - std::size_t const minCONSENSUS_PCT = 80; + std::size_t const minConsensusPct = 80; //! The duration a ledger may remain idle before closing - std::chrono::milliseconds const ledgerIDLE_INTERVAL = std::chrono::seconds{15}; + std::chrono::milliseconds const ledgerIdleInterval = std::chrono::seconds{15}; //! The number of seconds we wait minimum to ensure participation - std::chrono::milliseconds const ledgerMIN_CONSENSUS = std::chrono::milliseconds{1950}; + std::chrono::milliseconds const ledgerMinConsensus = std::chrono::milliseconds{1950}; /** The maximum amount of time to spend pausing for laggards. * @@ -70,16 +70,16 @@ struct ConsensusParms * validators don't appear to be offline that are merely waiting for * laggards. */ - std::chrono::milliseconds const ledgerMAX_CONSENSUS = std::chrono::seconds{15}; + std::chrono::milliseconds const ledgerMaxConsensus = std::chrono::seconds{15}; //! Minimum number of seconds to wait to ensure others have computed the LCL - std::chrono::milliseconds const ledgerMIN_CLOSE = std::chrono::seconds{2}; + std::chrono::milliseconds const ledgerMinClose = std::chrono::seconds{2}; //! How often we check state or change positions std::chrono::milliseconds const ledgerGRANULARITY = std::chrono::seconds{1}; //! How long to wait before completely abandoning consensus - std::size_t const ledgerABANDON_CONSENSUS_FACTOR = 10; + std::size_t const ledgerAbandonConsensusFactor = 10; /** * Maximum amount of time to give a consensus round @@ -87,7 +87,7 @@ struct ConsensusParms * Does not include the time to build the LCL, so there is no reason for a * round to go this long, regardless of how big the ledger is. */ - std::chrono::milliseconds const ledgerABANDON_CONSENSUS = std::chrono::seconds{120}; + std::chrono::milliseconds const ledgerAbandonConsensus = std::chrono::seconds{120}; /** The minimum amount of time to consider the previous round to have taken. @@ -99,7 +99,7 @@ struct ConsensusParms twice the interval between proposals (0.7s) divided by the interval between mid and late consensus ([85-50]/100). */ - std::chrono::milliseconds const avMIN_CONSENSUS_TIME = std::chrono::seconds{5}; + std::chrono::milliseconds const avMinConsensusTime = std::chrono::seconds{5}; //------------------------------------------------------------------------------ // Avalanche tuning @@ -136,16 +136,16 @@ struct ConsensusParms }; //! Percentage of nodes required to reach agreement on ledger close time - std::size_t const avCT_CONSENSUS_PCT = 75; + std::size_t const avCtConsensusPct = 75; //! Number of rounds before certain actions can happen. // (Moving to the next avalanche level, considering that votes are stalled // without consensus.) - std::size_t const avMIN_ROUNDS = 2; + std::size_t const avMinRounds = 2; //! Number of rounds before a stuck vote is considered unlikely to change //! because voting stalled - std::size_t const avSTALLED_ROUNDS = 4; + std::size_t const avStalledRounds = 4; }; inline std::pair> diff --git a/src/xrpld/consensus/ConsensusProposal.h b/src/xrpld/consensus/ConsensusProposal.h index ebfe61711a..d16679bfb5 100644 --- a/src/xrpld/consensus/ConsensusProposal.h +++ b/src/xrpld/consensus/ConsensusProposal.h @@ -26,7 +26,7 @@ namespace xrpl { As consensus proceeds, peers may change their position on the transaction, or choose to abstain. Each successive proposal includes a strictly monotonically increasing number (or, if a peer is choosing to abstain, - the special value `kSEQ_LEAVE`). + the special value `kSeqLeave`). Refer to @ref Consensus for requirements of the template arguments. @@ -42,10 +42,10 @@ public: using NodeID = NodeId; //< Sequence value when a peer initially joins consensus - static std::uint32_t const kSEQ_JOIN = 0; + static std::uint32_t const kSeqJoin = 0; //< Sequence number when a peer wants to bow out and leave consensus - static std::uint32_t const kSEQ_LEAVE = 0xffffffff; + static std::uint32_t const kSeqLeave = 0xffffffff; /** Constructor @@ -95,7 +95,7 @@ public: /** Get the sequence number of this proposal - Starting with an initial sequence number of `kSEQ_JOIN`, successive + Starting with an initial sequence number of `kSeqJoin`, successive proposals from a peer will increase the sequence number. @return the sequence number @@ -126,14 +126,14 @@ public: bool isInitial() const { - return proposeSeq_ == kSEQ_JOIN; + return proposeSeq_ == kSeqJoin; } //! Get whether this node left the consensus process bool isBowOut() const { - return proposeSeq_ == kSEQ_LEAVE; + return proposeSeq_ == kSeqLeave; } //! Get whether this position is stale relative to the provided cutoff @@ -160,7 +160,7 @@ public: position_ = newPosition; closeTime_ = newCloseTime; time_ = now; - if (proposeSeq_ != kSEQ_LEAVE) + if (proposeSeq_ != kSeqLeave) ++proposeSeq_; } @@ -175,7 +175,7 @@ public: { signingHash_.reset(); time_ = now; - proposeSeq_ = kSEQ_LEAVE; + proposeSeq_ = kSeqLeave; } std::string @@ -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..1c85a3537d 100644 --- a/src/xrpld/consensus/DisputedTx.h +++ b/src/xrpld/consensus/DisputedTx.h @@ -79,20 +79,20 @@ public: // enough, so there's room for change. Check the times in case the state // machine is altered to allow states to loop. if (nextCutoff.consensusTime > currentCutoff.consensusTime || - avalancheCounter_ < p.avMIN_ROUNDS) + avalancheCounter_ < p.avMinRounds) return false; // We've haven't had this vote for minimum rounds yet. Things could // change. - if (proposing && currentVoteCounter_ < p.avMIN_ROUNDS) + if (proposing && currentVoteCounter_ < p.avMinRounds) return false; // If we or any peers have changed a vote in several rounds, then // things could still change. But if _either_ has not changed in that // long, we're unlikely to change our vote any time soon. (This prevents // a malicious peer from flip-flopping a vote to prevent consensus.) - if (peersUnchanged < p.avSTALLED_ROUNDS && - (proposing && currentVoteCounter_ < p.avSTALLED_ROUNDS)) + if (peersUnchanged < p.avStalledRounds && + (proposing && currentVoteCounter_ < p.avStalledRounds)) return false; // Does this transaction have more than 80% agreement @@ -108,7 +108,7 @@ public: int const weight = support / total; // Returns true if the tx has more than minCONSENSUS_PCT (80) percent // agreement. Either voting for _or_ voting against the tx. - bool const stalled = weight > p.minCONSENSUS_PCT || weight < (100 - p.minCONSENSUS_PCT); + bool const stalled = weight > p.minConsensusPct || weight < (100 - p.minConsensusPct); if (stalled) { @@ -276,7 +276,7 @@ DisputedTx::updateVote(int percentTime, bool proposing, ConsensusPar // Proposing or not, we need to keep track of which state we've reached so // we can determine if the vote has stalled. auto const [requiredPct, newState] = - getNeededWeight(p, avalancheState_, percentTime, ++avalancheCounter_, p.avMIN_ROUNDS); + getNeededWeight(p, avalancheState_, percentTime, ++avalancheCounter_, p.avMinRounds); if (newState) { avalancheState_ = *newState; @@ -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/consensus/Validations.h b/src/xrpld/consensus/Validations.h index 825d0f6076..7be578060e 100644 --- a/src/xrpld/consensus/Validations.h +++ b/src/xrpld/consensus/Validations.h @@ -33,7 +33,7 @@ struct ValidationParms This is a safety to protect against very old validations and the time it takes to adjust the close time accuracy window. */ - std::chrono::seconds validationCURRENT_WALL = std::chrono::minutes{5}; + std::chrono::seconds validationCurrentWall = std::chrono::minutes{5}; /** Duration a validation remains current after first observed. @@ -41,14 +41,14 @@ struct ValidationParms first saw it. This provides faster recovery in very rare cases where the number of validations produced by the network is lower than normal */ - std::chrono::seconds validationCURRENT_LOCAL = std::chrono::minutes{3}; + std::chrono::seconds validationCurrentLocal = std::chrono::minutes{3}; /** Duration pre-close in which validations are acceptable. The number of seconds before a close time that we consider a validation acceptable. This protects against extreme clock errors */ - std::chrono::seconds validationCURRENT_EARLY = std::chrono::minutes{3}; + std::chrono::seconds validationCurrentEarly = std::chrono::minutes{3}; /** Duration a set of validations for a given ledger hash remain valid @@ -56,7 +56,7 @@ struct ValidationParms hash can expire. This keeps validations for recent ledgers available for a reasonable interval. */ - std::chrono::seconds validationSET_EXPIRES = std::chrono::minutes{10}; + std::chrono::seconds validationSetExpires = std::chrono::minutes{10}; /** How long we consider a validation fresh. * @@ -98,7 +98,7 @@ public: bool operator()(time_point now, Seq s, ValidationParms const& p) { - if (now > (when_ + p.validationSET_EXPIRES)) + if (now > (when_ + p.validationSetExpires)) seq_ = Seq{0}; if (s <= seq_) return false; @@ -139,9 +139,9 @@ isCurrent( // promoted from unsigned 32 bit to signed 64 bit prior // to computation. - return (signTime > (now - p.validationCURRENT_EARLY)) && - (signTime < (now + p.validationCURRENT_WALL)) && - ((seenTime == NetClock::time_point{}) || (seenTime < (now + p.validationCURRENT_LOCAL))); + return (signTime > (now - p.validationCurrentEarly)) && + (signTime < (now + p.validationCurrentWall)) && + ((seenTime == NetClock::time_point{}) || (seenTime < (now + p.validationCurrentLocal))); } /** Status of validation we received */ @@ -610,7 +610,7 @@ public: auto const diff = std::max(seqit->second.signTime(), val.signTime()) - std::min(seqit->second.signTime(), val.signTime()); - if (diff > parms_.validationCURRENT_WALL && + if (diff > parms_.validationCurrentWall && val.signTime() > seqit->second.signTime()) seqit->second = val; } @@ -702,12 +702,12 @@ public: { // We only need to refresh the keep range when it's just about // to expire. Track the next time we need to refresh. - static std::chrono::steady_clock::time_point kREFRESH_TIME; - if (auto const now = byLedger_.clock().now(); kREFRESH_TIME <= now) + static std::chrono::steady_clock::time_point kRefreshTime; + if (auto const now = byLedger_.clock().now(); kRefreshTime <= now) { // The next refresh time is shortly before the expiration // time from now. - kREFRESH_TIME = now + parms_.validationSET_EXPIRES - parms_.validationFRESHNESS; + kRefreshTime = now + parms_.validationSetExpires - parms_.validationFRESHNESS; for (auto i = byLedger_.begin(); i != byLedger_.end(); ++i) { @@ -732,8 +732,8 @@ public: } } - beast::expire(byLedger_, parms_.validationSET_EXPIRES); - beast::expire(bySequence_, parms_.validationSET_EXPIRES); + beast::expire(byLedger_, parms_.validationSetExpires); + beast::expire(bySequence_, parms_.validationSetExpires); } JLOG(j.debug()) << "Validations sets sweep lock duration " << std::chrono::duration_cast( diff --git a/src/xrpld/core/Config.h b/src/xrpld/core/Config.h index 10fbadaae7..a18b68a508 100644 --- a/src/xrpld/core/Config.h +++ b/src/xrpld/core/Config.h @@ -48,13 +48,13 @@ A default-constructed Setup contains recommended values. struct FeeSetup { /** The cost of a reference transaction in drops. */ - XRPAmount reference_fee{10}; + XRPAmount referenceFee{10}; /** The account reserve requirement in drops. */ - XRPAmount account_reserve{10 * kDROPS_PER_XRP}; + XRPAmount accountReserve{10 * kDropsPerXrp}; /** The per-owned item reserve requirement in drops. */ - XRPAmount owner_reserve{2 * kDROPS_PER_XRP}; + XRPAmount ownerReserve{2 * kDropsPerXrp}; /* (Remember to update the example cfg files when changing any of these * values.) */ @@ -63,7 +63,7 @@ struct FeeSetup [[nodiscard]] Fees toFees() const { - return Fees{reference_fee, account_reserve, owner_reserve}; + return Fees{referenceFee, accountReserve, ownerReserve}; } }; @@ -76,30 +76,30 @@ class Config : public BasicConfig { public: // Settings related to the configuration file location and directories - static char const* const kCONFIG_FILE_NAME; - static char const* const kCONFIG_LEGACY_NAME; - static char const* const kDATABASE_DIR_NAME; - static char const* const kVALIDATORS_FILE_NAME; + static char const* const kConfigFileName; + static char const* const kConfigLegacyName; + static char const* const kDatabaseDirName; + static char const* const kValidatorsFileName; /** Returns the full path and filename of the debug log file. */ [[nodiscard]] boost::filesystem::path getDebugLogFile() const; private: - boost::filesystem::path CONFIG_FILE_; + boost::filesystem::path configFile_; public: - boost::filesystem::path CONFIG_DIR; + boost::filesystem::path configDir; private: - boost::filesystem::path DEBUG_LOGFILE_; + boost::filesystem::path debugLogfile_; void load(); beast::Journal const j_; - bool QUIET_ = false; // Minimize logging verbosity. - bool SILENT_ = false; // No output to console after startup. + bool quiet_ = false; // Minimize logging verbosity. + bool silent_ = false; // No output to console after startup. /** Operate in stand-alone mode. In stand alone mode: @@ -109,9 +109,9 @@ private: - If no ledger is loaded, the default ledger with the root account is created. */ - bool RUN_STANDALONE_ = false; + bool runStandalone_ = false; - bool USE_TX_TABLES_ = true; + bool useTxTables_ = true; /** Determines if the server will sign a tx, given an account's secret seed. @@ -126,45 +126,45 @@ private: public: bool doImport = false; - bool ELB_SUPPORT = false; + bool elbSupport = false; // Entries from [ips] config stanza - std::vector IPS; + std::vector ips; // Entries from [ips_fixed] config stanza - std::vector IPS_FIXED; + std::vector ipsFixed; - StartUpType START_UP = StartUpType::Normal; + StartUpType startUp = StartUpType::Normal; - bool START_VALID = false; + bool startValid = false; - std::string START_LEDGER; + std::string startLedger; - std::optional TRAP_TX_HASH; + std::optional trapTxHash; // Network parameters - uint32_t NETWORK_ID = 0; + uint32_t networkId = 0; // Note: The following parameters do not relate to the UNL or trust at all // Minimum number of nodes to consider the network present - std::size_t NETWORK_QUORUM = 1; + std::size_t networkQuorum = 1; // Peer networking parameters // 1 = relay, 0 = do not relay (but process), -1 = drop completely (do NOT // process) - int RELAY_UNTRUSTED_VALIDATIONS = 1; - int RELAY_UNTRUSTED_PROPOSALS = 0; + int relayUntrustedValidations = 1; + int relayUntrustedProposals = 0; // True to ask peers not to relay current IP. - bool PEER_PRIVATE = false; + bool peerPrivate = false; // peers_max is a legacy configuration, which is going to be replaced // with individual inbound peers peers_in_max and outbound peers // peers_out_max configuration. for now we support both the legacy and // the new configuration. if peers_max is configured then peers_in_max and // peers_out_max are ignored. - std::size_t PEERS_MAX = 0; - std::size_t PEERS_OUT_MAX = 0; - std::size_t PEERS_IN_MAX = 0; + std::size_t peersMax = 0; + std::size_t peersOutMax = 0; + std::size_t peersInMax = 0; // Path searching: these were reasonable default values at some point but // further research is needed to decide if they still are @@ -178,110 +178,110 @@ public: // Servers operating as validators disable path finding by // default by setting the `PATH_SEARCH_MAX` option to 0 // unless it is explicitly set in the configuration file. - int PATH_SEARCH_OLD = 2; - int PATH_SEARCH = 2; - int PATH_SEARCH_FAST = 2; - int PATH_SEARCH_MAX = 3; + int pathSearchOld = 2; + int pathSearch = 2; + int pathSearchFast = 2; + int pathSearchMax = 3; // Validation - std::optional VALIDATION_QUORUM; // validations to consider ledger authoritative + std::optional validationQuorum; // validations to consider ledger authoritative - FeeSetup FEES; + FeeSetup fees; // Node storage configuration - std::uint32_t LEDGER_HISTORY = 256; - std::uint32_t FETCH_DEPTH = 1000000000; + std::uint32_t ledgerHistory = 256; + std::uint32_t fetchDepth = 1000000000; // Tunable that adjusts various parameters, typically associated // with hardware parameters (RAM size and CPU cores). The default // is 'tiny'. - std::size_t NODE_SIZE = 0; + std::size_t nodeSize = 0; - bool SSL_VERIFY = true; - std::string SSL_VERIFY_FILE; - std::string SSL_VERIFY_DIR; + bool sslVerify = true; + std::string sslVerifyFile; + std::string sslVerifyDir; // Compression - bool COMPRESSION = false; + bool compression = false; // Enable the experimental Ledger Replay functionality - bool LEDGER_REPLAY = false; + bool ledgerReplay = false; // Work queue limits - int MAX_TRANSACTIONS = 250; - static constexpr int kMAX_JOB_QUEUE_TX = 1000; - static constexpr int kMIN_JOB_QUEUE_TX = 100; + int maxTransactions = 250; + static constexpr int kMaxJobQueueTx = 1000; + static constexpr int kMinJobQueueTx = 100; // Amendment majority time - std::chrono::seconds AMENDMENT_MAJORITY_TIME = kDEFAULT_AMENDMENT_MAJORITY_TIME; + std::chrono::seconds amendmentMajorityTime = kDefaultAmendmentMajorityTime; // Thread pool configuration (0 = choose for me) - int WORKERS = 0; // jobqueue thread count. default: upto 6 - int IO_WORKERS = 0; // io svc thread count. default: 2 - int PREFETCH_WORKERS = 0; // prefetch thread count. default: 4 + int workers = 0; // jobqueue thread count. default: upto 6 + int ioWorkers = 0; // io svc thread count. default: 2 + int prefetchWorkers = 0; // prefetch thread count. default: 4 // Can only be set in code, specifically unit tests - bool FORCE_MULTI_THREAD = false; + bool forceMultiThread = false; // Normally the sweep timer is automatically deduced based on the node // size, but we allow admins to explicitly set it in the config. - std::optional SWEEP_INTERVAL; + std::optional sweepInterval; // Reduce-relay - Experimental parameters to control p2p routing algorithms // Enable base squelching of duplicate validation/proposal messages - bool VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = false; + bool vpReduceRelayBaseSquelchEnable = false; ///////////////////// !!TEMPORARY CODE BLOCK!! //////////////////////// // Temporary squelching config for the peers selected as a source of // // validator messages. The config must be removed once squelching is // // made the default routing algorithm // - std::size_t VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS = 5; + std::size_t vpReduceRelaySquelchMaxSelectedPeers = 5; ///////////////// END OF TEMPORARY CODE BLOCK ///////////////////// // Transaction reduce-relay feature - bool TX_REDUCE_RELAY_ENABLE = false; + bool txReduceRelayEnable = false; // If tx reduce-relay feature is disabled // and this flag is enabled then some // tx-related metrics is collected. It // is ignored if tx reduce-relay feature is // enabled. It is used in debugging to compare // metrics with the feature disabled/enabled. - bool TX_REDUCE_RELAY_METRICS = false; + bool txReduceRelayMetrics = false; // Minimum peers a server should have before // selecting random peers - std::size_t TX_REDUCE_RELAY_MIN_PEERS = 20; + std::size_t txReduceRelayMinPeers = 20; // Percentage of peers with the tx reduce-relay feature enabled // to relay to out of total active peers - std::size_t TX_RELAY_PERCENTAGE = 25; + std::size_t txRelayPercentage = 25; // These override the command line client settings - std::optional rpc_ip; + std::optional rpcIp; std::unordered_set> features; - std::string SERVER_DOMAIN; + std::string serverDomain; // How long can a peer remain in the "unknown" state - std::chrono::seconds MAX_UNKNOWN_TIME{600}; + std::chrono::seconds maxUnknownTime{600}; // How long can a peer remain in the "diverged" state - std::chrono::seconds MAX_DIVERGED_TIME{300}; + std::chrono::seconds maxDivergedTime{300}; // Enable the beta API version - bool BETA_RPC_API = false; + bool betaRpcApi = false; // First, attempt to load the latest ledger directly from disk. - bool FAST_LOAD = false; + bool fastLoad = false; // When starting xrpld with existing database it do not know it has those // ledgers locally until the server naturally tries to backfill. This makes // is difficult to test some functionality (in particular performance // testing sidechains). With this variable the user is able to force xrpld // to consider the ledger range to be present. It should be used for testing // only. - std::optional> FORCED_LEDGER_RANGE_PRESENT; + std::optional> forcedLedgerRangePresent; - std::optional VALIDATOR_LIST_THRESHOLD; + std::optional validatorListThreshold; public: Config(); @@ -305,23 +305,23 @@ public: [[nodiscard]] bool quiet() const { - return QUIET_; + return quiet_; } [[nodiscard]] bool silent() const { - return SILENT_; + return silent_; } [[nodiscard]] bool standalone() const { - return RUN_STANDALONE_; + return runStandalone_; } [[nodiscard]] bool useTxTables() const { - return USE_TX_TABLES_; + return useTxTables_; } [[nodiscard]] bool diff --git a/src/xrpld/core/TimeKeeper.h b/src/xrpld/core/TimeKeeper.h index a21f5aa6e8..8eb13e75c0 100644 --- a/src/xrpld/core/TimeKeeper.h +++ b/src/xrpld/core/TimeKeeper.h @@ -18,7 +18,7 @@ private: adjust(std::chrono::system_clock::time_point when) { return time_point( - std::chrono::duration_cast(when.time_since_epoch() - kEPOCH_OFFSET)); + std::chrono::duration_cast(when.time_since_epoch() - kEpochOffset)); } public: diff --git a/src/xrpld/core/detail/Config.cpp b/src/xrpld/core/detail/Config.cpp index 11ee43e9cc..6eedc43edd 100644 --- a/src/xrpld/core/detail/Config.cpp +++ b/src/xrpld/core/detail/Config.cpp @@ -114,7 +114,7 @@ namespace xrpl { // clang-format off // The configurable node sizes are "tiny", "small", "medium", "large", "huge" inline constexpr std::array>, 13> -kSIZED_ITEMS +kSizedItems {{ // FIXME: We should document each of these items, explaining exactly // what they control and whether there exists an explicit @@ -143,7 +143,7 @@ static_assert( []() constexpr -> bool { std::underlying_type_t idx = 0; - for (auto const& i : kSIZED_ITEMS) + for (auto const& i : kSizedItems) { if (static_cast>(i.first) != idx) return false; @@ -248,10 +248,10 @@ getSingleSection( // //------------------------------------------------------------------------------ -char const* const Config::kCONFIG_FILE_NAME = "xrpld.cfg"; -char const* const Config::kCONFIG_LEGACY_NAME = "rippled.cfg"; -char const* const Config::kDATABASE_DIR_NAME = "db"; -char const* const Config::kVALIDATORS_FILE_NAME = "validators.txt"; +char const* const Config::kConfigFileName = "xrpld.cfg"; +char const* const Config::kConfigLegacyName = "rippled.cfg"; +char const* const Config::kDatabaseDirName = "db"; +char const* const Config::kValidatorsFileName = "validators.txt"; [[nodiscard]] static std::string getEnvVar(char const* name) @@ -272,11 +272,11 @@ Config::Config() void Config::setupControl(bool bQuiet, bool bSilent, bool bStandalone) { - XRPL_ASSERT(NODE_SIZE == 0, "xrpl::Config::setupControl : node size not set"); + XRPL_ASSERT(nodeSize == 0, "xrpl::Config::setupControl : node size not set"); - QUIET_ = bQuiet || bSilent; - SILENT_ = bSilent; - RUN_STANDALONE_ = bStandalone; + quiet_ = bQuiet || bSilent; + silent_ = bSilent; + runStandalone_ = bStandalone; // We try to autodetect the appropriate node size by checking available // RAM and CPU resources. We default to "tiny" for standalone mode. @@ -284,7 +284,7 @@ Config::setupControl(bool bQuiet, bool bSilent, bool bStandalone) { // First, check against 'minimum' RAM requirements per node size: auto const& threshold = - kSIZED_ITEMS[std::underlying_type_t(SizedItem::RamSizeGb)]; + kSizedItems[std::underlying_type_t(SizedItem::RamSizeGb)]; auto ns = std::ranges::find_if(threshold.second, [this](std::size_t limit) { return (limit == 0) || (ramSize_ < limit); @@ -293,15 +293,15 @@ Config::setupControl(bool bQuiet, bool bSilent, bool bStandalone) XRPL_ASSERT(ns != threshold.second.end(), "xrpl::Config::setupControl : valid node size"); if (ns != threshold.second.end()) - NODE_SIZE = std::distance(threshold.second.begin(), ns); + nodeSize = std::distance(threshold.second.begin(), ns); // Adjust the size based on the number of hardware threads of // execution available to us: if (auto const hc = std::thread::hardware_concurrency(); hc != 0) - NODE_SIZE = std::min(hc / 2, NODE_SIZE); + nodeSize = std::min(hc / 2, nodeSize); } - XRPL_ASSERT(NODE_SIZE <= 4, "xrpl::Config::setupControl : node size is set"); + XRPL_ASSERT(nodeSize <= 4, "xrpl::Config::setupControl : node size is set"); } void @@ -319,10 +319,10 @@ Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStand if (!strConf.empty()) { // --conf= : everything is relative that file. - CONFIG_FILE_ = strConf; - CONFIG_DIR = boost::filesystem::absolute(CONFIG_FILE_); - CONFIG_DIR.remove_filename(); - dataDir = CONFIG_DIR / kDATABASE_DIR_NAME; + configFile_ = strConf; + configDir = boost::filesystem::absolute(configFile_); + configDir.remove_filename(); + dataDir = configDir / kDatabaseDirName; } else { @@ -331,13 +331,13 @@ Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStand // Check if either of the config files exist in the current working // directory, in which case the databases will be stored in a // subdirectory. - CONFIG_DIR = boost::filesystem::current_path(); - dataDir = CONFIG_DIR / kDATABASE_DIR_NAME; - CONFIG_FILE_ = CONFIG_DIR / kCONFIG_FILE_NAME; - if (boost::filesystem::exists(CONFIG_FILE_)) + configDir = boost::filesystem::current_path(); + dataDir = configDir / kDatabaseDirName; + configFile_ = configDir / kConfigFileName; + if (boost::filesystem::exists(configFile_)) break; - CONFIG_FILE_ = CONFIG_DIR / kCONFIG_LEGACY_NAME; - if (boost::filesystem::exists(CONFIG_FILE_)) + configFile_ = configDir / kConfigLegacyName; + if (boost::filesystem::exists(configFile_)) break; // Check if the home directory is set, and optionally the XDG config @@ -362,22 +362,22 @@ Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStand // Check if either of the config files exist in the XDG config // dir. dataDir = strXdgDataHome + "/" + systemName(); - CONFIG_DIR = strXdgConfigHome + "/" + systemName(); - CONFIG_FILE_ = CONFIG_DIR / kCONFIG_FILE_NAME; - if (boost::filesystem::exists(CONFIG_FILE_)) + configDir = strXdgConfigHome + "/" + systemName(); + configFile_ = configDir / kConfigFileName; + if (boost::filesystem::exists(configFile_)) break; - CONFIG_FILE_ = CONFIG_DIR / kCONFIG_LEGACY_NAME; - if (boost::filesystem::exists(CONFIG_FILE_)) + configFile_ = configDir / kConfigLegacyName; + if (boost::filesystem::exists(configFile_)) break; } // As a last resort, check the system config directory. - dataDir = "/var/opt/" + systemName(); - CONFIG_DIR = "/etc/opt/" + systemName(); - CONFIG_FILE_ = CONFIG_DIR / kCONFIG_FILE_NAME; - if (boost::filesystem::exists(CONFIG_FILE_)) + dataDir = "/var/lib/" + systemName(); + configDir = "/etc/" + systemName(); + configFile_ = configDir / kConfigFileName; + if (boost::filesystem::exists(configFile_)) break; - CONFIG_FILE_ = CONFIG_DIR / kCONFIG_LEGACY_NAME; + configFile_ = configDir / kConfigLegacyName; } while (false); } @@ -390,7 +390,7 @@ Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStand { dataDir = boost::filesystem::path(dbPath); } - else if (RUN_STANDALONE_) + else if (runStandalone_) { dataDir.clear(); } @@ -407,17 +407,16 @@ Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStand legacy("database_path", boost::filesystem::absolute(dataDir).string()); } - HTTPClient::initializeSSLContext( - this->SSL_VERIFY_DIR, this->SSL_VERIFY_FILE, this->SSL_VERIFY, j_); + HTTPClient::initializeSSLContext(this->sslVerifyDir, this->sslVerifyFile, this->sslVerify, j_); - if (RUN_STANDALONE_) - LEDGER_HISTORY = 0; + if (runStandalone_) + ledgerHistory = 0; Section const ledgerTxTablesSection = section("ledger_tx_tables"); - getIfExists(ledgerTxTablesSection, "use_tx_tables", USE_TX_TABLES_); + getIfExists(ledgerTxTablesSection, "use_tx_tables", useTxTables_); Section const& nodeDbSection{section(ConfigSection::nodeDatabase())}; - getIfExists(nodeDbSection, "fast_load", FAST_LOAD); + getIfExists(nodeDbSection, "fast_load", fastLoad); } // 0 ports are allowed for unit tests, but still not allowed to be present in @@ -454,16 +453,16 @@ Config::load() // NOTE: this writes to cerr because we want cout to be reserved // for the writing of the json response (so that stdout can be part of a // pipeline, for instance) - if (!QUIET_) - std::cerr << "Loading: " << CONFIG_FILE_ << "\n"; + if (!quiet_) + std::cerr << "Loading: " << configFile_ << "\n"; boost::system::error_code ec; - auto const fileContents = getFileContents(ec, CONFIG_FILE_); + auto const fileContents = getFileContents(ec, configFile_); if (ec) { - std::cerr << "Failed to read '" << CONFIG_FILE_ << "'." << ec.value() << ": " - << ec.message() << std::endl; + std::cerr << "Failed to read '" << configFile_ << "'." << ec.value() << ": " << ec.message() + << std::endl; return; } @@ -479,10 +478,10 @@ Config::loadFromString(std::string const& fileContents) build(secConfig); if (auto s = getIniFileSection(secConfig, SECTION_IPS)) - IPS = *s; + ips = *s; if (auto s = getIniFileSection(secConfig, SECTION_IPS_FIXED)) - IPS_FIXED = *s; + ipsFixed = *s; // if the user has specified ip:port then replace : with a space. { @@ -502,8 +501,8 @@ Config::loadFromString(std::string const& fileContents) } }; - replaceColons(IPS_FIXED); - replaceColons(IPS); + replaceColons(ipsFixed); + replaceColons(ips); } { @@ -521,47 +520,47 @@ Config::loadFromString(std::string const& fileContents) { if (strTemp == "main") { - NETWORK_ID = 0; + networkId = 0; } else if (strTemp == "testnet") { - NETWORK_ID = 1; + networkId = 1; } else if (strTemp == "devnet") { - NETWORK_ID = 2; + networkId = 2; } else { - NETWORK_ID = beast::lexicalCastThrow(strTemp); + networkId = beast::lexicalCastThrow(strTemp); } } if (getSingleSection(secConfig, SECTION_PEER_PRIVATE, strTemp, j_)) - PEER_PRIVATE = beast::lexicalCastThrow(strTemp); + peerPrivate = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_PEERS_MAX, strTemp, j_)) { - PEERS_MAX = beast::lexicalCastThrow(strTemp); + peersMax = beast::lexicalCastThrow(strTemp); } else { - std::optional peersInMax{}; + std::optional peersInMaxOpt{}; if (getSingleSection(secConfig, SECTION_PEERS_IN_MAX, strTemp, j_)) { - peersInMax = beast::lexicalCastThrow(strTemp); - if (*peersInMax > 1000) + peersInMaxOpt = beast::lexicalCastThrow(strTemp); + if (*peersInMaxOpt > 1000) { Throw("Invalid value specified in [" SECTION_PEERS_IN_MAX "] section; the value must be less or equal than 1000"); } } - std::optional peersOutMax{}; + std::optional peersOutMaxOpt{}; if (getSingleSection(secConfig, SECTION_PEERS_OUT_MAX, strTemp, j_)) { - peersOutMax = beast::lexicalCastThrow(strTemp); - if (*peersOutMax < 10 || *peersOutMax > 1000) + peersOutMaxOpt = beast::lexicalCastThrow(strTemp); + if (*peersOutMaxOpt < 10 || *peersOutMaxOpt > 1000) { Throw("Invalid value specified in [" SECTION_PEERS_OUT_MAX "] section; the value must be in range 10-1000"); @@ -569,17 +568,17 @@ Config::loadFromString(std::string const& fileContents) } // if one section is configured then the other must be configured too - if ((peersInMax && !peersOutMax) || (peersOutMax && !peersInMax)) + if ((peersInMaxOpt && !peersOutMaxOpt) || (peersOutMaxOpt && !peersInMaxOpt)) { Throw("Both sections [" SECTION_PEERS_IN_MAX "]" "and [" SECTION_PEERS_OUT_MAX "] must be configured"); } - if (peersInMax && peersOutMax) + if (peersInMaxOpt && peersOutMaxOpt) { - PEERS_IN_MAX = *peersInMax; - PEERS_OUT_MAX = *peersOutMax; + peersInMax = *peersInMaxOpt; + peersOutMax = *peersOutMaxOpt; } } @@ -587,27 +586,27 @@ Config::loadFromString(std::string const& fileContents) { if (boost::iequals(strTemp, "tiny")) { - NODE_SIZE = 0; + nodeSize = 0; } else if (boost::iequals(strTemp, "small")) { - NODE_SIZE = 1; + nodeSize = 1; } else if (boost::iequals(strTemp, "medium")) { - NODE_SIZE = 2; + nodeSize = 2; } else if (boost::iequals(strTemp, "large")) { - NODE_SIZE = 3; + nodeSize = 3; } else if (boost::iequals(strTemp, "huge")) { - NODE_SIZE = 4; + nodeSize = 4; } else { - NODE_SIZE = std::min(4, beast::lexicalCastThrow(strTemp)); + nodeSize = std::min(4, beast::lexicalCastThrow(strTemp)); } } @@ -615,27 +614,27 @@ Config::loadFromString(std::string const& fileContents) signingEnabled_ = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_ELB_SUPPORT, strTemp, j_)) - ELB_SUPPORT = beast::lexicalCastThrow(strTemp); + elbSupport = beast::lexicalCastThrow(strTemp); - getSingleSection(secConfig, SECTION_SSL_VERIFY_FILE, SSL_VERIFY_FILE, j_); - getSingleSection(secConfig, SECTION_SSL_VERIFY_DIR, SSL_VERIFY_DIR, j_); + getSingleSection(secConfig, SECTION_SSL_VERIFY_FILE, sslVerifyFile, j_); + getSingleSection(secConfig, SECTION_SSL_VERIFY_DIR, sslVerifyDir, j_); if (getSingleSection(secConfig, SECTION_SSL_VERIFY, strTemp, j_)) - SSL_VERIFY = beast::lexicalCastThrow(strTemp); + sslVerify = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_RELAY_VALIDATIONS, strTemp, j_)) { if (boost::iequals(strTemp, "all")) { - RELAY_UNTRUSTED_VALIDATIONS = 1; + relayUntrustedValidations = 1; } else if (boost::iequals(strTemp, "trusted")) { - RELAY_UNTRUSTED_VALIDATIONS = 0; + relayUntrustedValidations = 0; } else if (boost::iequals(strTemp, "drop_untrusted")) { - RELAY_UNTRUSTED_VALIDATIONS = -1; + relayUntrustedValidations = -1; } else { @@ -648,15 +647,15 @@ Config::loadFromString(std::string const& fileContents) { if (boost::iequals(strTemp, "all")) { - RELAY_UNTRUSTED_PROPOSALS = 1; + relayUntrustedProposals = 1; } else if (boost::iequals(strTemp, "trusted")) { - RELAY_UNTRUSTED_PROPOSALS = 0; + relayUntrustedProposals = 0; } else if (boost::iequals(strTemp, "drop_untrusted")) { - RELAY_UNTRUSTED_PROPOSALS = -1; + relayUntrustedProposals = -1; } else { @@ -672,28 +671,28 @@ Config::loadFromString(std::string const& fileContents) } if (getSingleSection(secConfig, SECTION_NETWORK_QUORUM, strTemp, j_)) - NETWORK_QUORUM = beast::lexicalCastThrow(strTemp); + networkQuorum = beast::lexicalCastThrow(strTemp); - FEES = setupFeeVote(section("voting")); + fees = setupFeeVote(section("voting")); /* [fee_default] is documented in the example config files as useful for * things like offline transaction signing. Until that's completely * deprecated, allow it to override the [voting] section. */ if (getSingleSection(secConfig, SECTION_FEE_DEFAULT, strTemp, j_)) - FEES.reference_fee = beast::lexicalCastThrow(strTemp); + fees.referenceFee = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_LEDGER_HISTORY, strTemp, j_)) { if (boost::iequals(strTemp, "full")) { - LEDGER_HISTORY = std::numeric_limits::max(); + ledgerHistory = std::numeric_limits::max(); } else if (boost::iequals(strTemp, "none")) { - LEDGER_HISTORY = 0; + ledgerHistory = 0; } else { - LEDGER_HISTORY = beast::lexicalCastThrow(strTemp); + ledgerHistory = beast::lexicalCastThrow(strTemp); } } @@ -701,42 +700,42 @@ Config::loadFromString(std::string const& fileContents) { if (boost::iequals(strTemp, "none")) { - FETCH_DEPTH = 0; + fetchDepth = 0; } else if (boost::iequals(strTemp, "full")) { - FETCH_DEPTH = std::numeric_limits::max(); + fetchDepth = std::numeric_limits::max(); } else { - FETCH_DEPTH = beast::lexicalCastThrow(strTemp); + fetchDepth = beast::lexicalCastThrow(strTemp); } - FETCH_DEPTH = std::max(FETCH_DEPTH, 10); + fetchDepth = std::max(fetchDepth, 10); } // By default, validators don't have pathfinding enabled, unless it is // explicitly requested by the server's admin. if (exists(SECTION_VALIDATION_SEED) || exists(SECTION_VALIDATOR_TOKEN)) - PATH_SEARCH_MAX = 0; + pathSearchMax = 0; if (getSingleSection(secConfig, SECTION_PATH_SEARCH_OLD, strTemp, j_)) - PATH_SEARCH_OLD = beast::lexicalCastThrow(strTemp); + pathSearchOld = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_PATH_SEARCH, strTemp, j_)) - PATH_SEARCH = beast::lexicalCastThrow(strTemp); + pathSearch = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_PATH_SEARCH_FAST, strTemp, j_)) - PATH_SEARCH_FAST = beast::lexicalCastThrow(strTemp); + pathSearchFast = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_PATH_SEARCH_MAX, strTemp, j_)) - PATH_SEARCH_MAX = beast::lexicalCastThrow(strTemp); + pathSearchMax = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_DEBUG_LOGFILE, strTemp, j_)) - DEBUG_LOGFILE_ = strTemp; + debugLogfile_ = strTemp; if (getSingleSection(secConfig, SECTION_SWEEP_INTERVAL, strTemp, j_)) { - SWEEP_INTERVAL = beast::lexicalCastThrow(strTemp); + sweepInterval = beast::lexicalCastThrow(strTemp); - if (SWEEP_INTERVAL < 10 || SWEEP_INTERVAL > 600) + if (sweepInterval < 10 || sweepInterval > 600) { Throw("Invalid " SECTION_SWEEP_INTERVAL ": must be between 10 and 600 inclusive"); @@ -745,9 +744,9 @@ Config::loadFromString(std::string const& fileContents) if (getSingleSection(secConfig, SECTION_WORKERS, strTemp, j_)) { - WORKERS = beast::lexicalCastThrow(strTemp); + workers = beast::lexicalCastThrow(strTemp); - if (WORKERS < 1 || WORKERS > 1024) + if (workers < 1 || workers > 1024) { Throw("Invalid " SECTION_WORKERS ": must be between 1 and 1024 inclusive."); @@ -756,9 +755,9 @@ Config::loadFromString(std::string const& fileContents) if (getSingleSection(secConfig, SECTION_IO_WORKERS, strTemp, j_)) { - IO_WORKERS = beast::lexicalCastThrow(strTemp); + ioWorkers = beast::lexicalCastThrow(strTemp); - if (IO_WORKERS < 1 || IO_WORKERS > 1024) + if (ioWorkers < 1 || ioWorkers > 1024) { Throw("Invalid " SECTION_IO_WORKERS ": must be between 1 and 1024 inclusive."); @@ -767,9 +766,9 @@ Config::loadFromString(std::string const& fileContents) if (getSingleSection(secConfig, SECTION_PREFETCH_WORKERS, strTemp, j_)) { - PREFETCH_WORKERS = beast::lexicalCastThrow(strTemp); + prefetchWorkers = beast::lexicalCastThrow(strTemp); - if (PREFETCH_WORKERS < 1 || PREFETCH_WORKERS > 1024) + if (prefetchWorkers < 1 || prefetchWorkers > 1024) { Throw("Invalid " SECTION_PREFETCH_WORKERS ": must be between 1 and 1024 inclusive."); @@ -777,10 +776,10 @@ Config::loadFromString(std::string const& fileContents) } if (getSingleSection(secConfig, SECTION_COMPRESSION, strTemp, j_)) - COMPRESSION = beast::lexicalCastThrow(strTemp); + compression = beast::lexicalCastThrow(strTemp); if (getSingleSection(secConfig, SECTION_LEDGER_REPLAY, strTemp, j_)) - LEDGER_REPLAY = beast::lexicalCastThrow(strTemp); + ledgerReplay = beast::lexicalCastThrow(strTemp); if (exists(SECTION_REDUCE_RELAY)) { @@ -803,15 +802,15 @@ Config::loadFromString(std::string const& fileContents) if (sec.exists("vp_base_squelch_enable")) { - VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = sec.valueOr("vp_base_squelch_enable", false); + vpReduceRelayBaseSquelchEnable = sec.valueOr("vp_base_squelch_enable", false); } else if (sec.exists("vp_enable")) { - VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = sec.valueOr("vp_enable", false); + vpReduceRelayBaseSquelchEnable = sec.valueOr("vp_enable", false); } else { - VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE = false; + vpReduceRelayBaseSquelchEnable = false; } ///////////////// !!END OF TEMPORARY CODE BLOCK!! ///////////////////// @@ -819,9 +818,8 @@ Config::loadFromString(std::string const& fileContents) // Temporary squelching config for the peers selected as a source of // // validator messages. The config must be removed once squelching is // // made the default routing algorithm. // - VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS = - sec.valueOr("vp_base_squelch_max_selected_peers", 5); - if (VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS < 3) + vpReduceRelaySquelchMaxSelectedPeers = sec.valueOr("vp_base_squelch_max_selected_peers", 5); + if (vpReduceRelaySquelchMaxSelectedPeers < 3) { Throw("Invalid " SECTION_REDUCE_RELAY " vp_base_squelch_max_selected_peers must be " @@ -829,11 +827,11 @@ Config::loadFromString(std::string const& fileContents) } ///////////////// !!END OF TEMPORARY CODE BLOCK!! ///////////////////// - TX_REDUCE_RELAY_ENABLE = sec.valueOr("tx_enable", false); - TX_REDUCE_RELAY_METRICS = sec.valueOr("tx_metrics", false); - TX_REDUCE_RELAY_MIN_PEERS = sec.valueOr("tx_min_peers", 20); - TX_RELAY_PERCENTAGE = sec.valueOr("tx_relay_percentage", 25); - if (TX_RELAY_PERCENTAGE < 10 || TX_RELAY_PERCENTAGE > 100 || TX_REDUCE_RELAY_MIN_PEERS < 10) + txReduceRelayEnable = sec.valueOr("tx_enable", false); + txReduceRelayMetrics = sec.valueOr("tx_metrics", false); + txReduceRelayMinPeers = sec.valueOr("tx_min_peers", 20); + txRelayPercentage = sec.valueOr("tx_relay_percentage", 25); + if (txRelayPercentage < 10 || txRelayPercentage > 100 || txReduceRelayMinPeers < 10) { Throw("Invalid " SECTION_REDUCE_RELAY ", tx_min_peers must be greater than or equal to 10" @@ -844,8 +842,8 @@ Config::loadFromString(std::string const& fileContents) if (getSingleSection(secConfig, SECTION_MAX_TRANSACTIONS, strTemp, j_)) { - MAX_TRANSACTIONS = - std::clamp(beast::lexicalCastThrow(strTemp), kMIN_JOB_QUEUE_TX, kMAX_JOB_QUEUE_TX); + maxTransactions = + std::clamp(beast::lexicalCastThrow(strTemp), kMinJobQueueTx, kMaxJobQueueTx); } if (getSingleSection(secConfig, SECTION_SERVER_DOMAIN, strTemp, j_)) @@ -857,7 +855,7 @@ Config::loadFromString(std::string const& fileContents) ": the domain name does not appear to meet the requirements."); } - SERVER_DOMAIN = strTemp; + serverDomain = strTemp; } if (exists(SECTION_OVERLAY)) @@ -869,7 +867,7 @@ Config::loadFromString(std::string const& fileContents) try { if (auto val = sec.get("max_unknown_time")) - MAX_UNKNOWN_TIME = seconds{beast::lexicalCastThrow(*val)}; + maxUnknownTime = seconds{beast::lexicalCastThrow(*val)}; } catch (...) { @@ -877,7 +875,7 @@ Config::loadFromString(std::string const& fileContents) ": must be of the form '' representing seconds."); } - if (MAX_UNKNOWN_TIME < seconds{300} || MAX_UNKNOWN_TIME > seconds{1800}) + if (maxUnknownTime < seconds{300} || maxUnknownTime > seconds{1800}) { Throw( "Invalid value 'max_unknown_time' in " SECTION_OVERLAY @@ -887,7 +885,7 @@ Config::loadFromString(std::string const& fileContents) try { if (auto val = sec.get("max_diverged_time")) - MAX_DIVERGED_TIME = seconds{beast::lexicalCastThrow(*val)}; + maxDivergedTime = seconds{beast::lexicalCastThrow(*val)}; } catch (...) { @@ -895,7 +893,7 @@ Config::loadFromString(std::string const& fileContents) ": must be of the form '' representing seconds."); } - if (MAX_DIVERGED_TIME < seconds{60} || MAX_DIVERGED_TIME > seconds{900}) + if (maxDivergedTime < seconds{60} || maxDivergedTime > seconds{900}) { Throw("Invalid value 'max_diverged_time' in " SECTION_OVERLAY ": the time must be between 60 and 900 seconds, inclusive."); @@ -917,22 +915,22 @@ Config::loadFromString(std::string const& fileContents) if (boost::iequals(match[2], "minutes")) { - AMENDMENT_MAJORITY_TIME = minutes(duration); + amendmentMajorityTime = minutes(duration); } else if (boost::iequals(match[2], "hours")) { - AMENDMENT_MAJORITY_TIME = hours(duration); + amendmentMajorityTime = hours(duration); } else if (boost::iequals(match[2], "days")) { - AMENDMENT_MAJORITY_TIME = days(duration); + amendmentMajorityTime = days(duration); } else if (boost::iequals(match[2], "weeks")) { - AMENDMENT_MAJORITY_TIME = weeks(duration); + amendmentMajorityTime = weeks(duration); } - if (AMENDMENT_MAJORITY_TIME < minutes(15)) + if (amendmentMajorityTime < minutes(15)) { Throw("Invalid " SECTION_AMENDMENT_MAJORITY_TIME ", the minimum amount of time an amendment must hold a " @@ -941,10 +939,10 @@ Config::loadFromString(std::string const& fileContents) } if (getSingleSection(secConfig, SECTION_BETA_RPC_API, strTemp, j_)) - BETA_RPC_API = beast::lexicalCastThrow(strTemp); + betaRpcApi = beast::lexicalCastThrow(strTemp); // Do not load trusted validator configuration for standalone mode - if (!RUN_STANDALONE_) + if (!runStandalone_) { // If a file was explicitly specified, then throw if the // path is malformed or if the file does not exist or is @@ -966,8 +964,8 @@ Config::loadFromString(std::string const& fileContents) "]"); } - if (!validatorsFile.is_absolute() && !CONFIG_DIR.empty()) - validatorsFile = CONFIG_DIR / validatorsFile; + if (!validatorsFile.is_absolute() && !configDir.empty()) + validatorsFile = configDir / validatorsFile; if (!boost::filesystem::exists(validatorsFile)) { @@ -986,9 +984,9 @@ Config::loadFromString(std::string const& fileContents) validatorsFile.string()); } } - else if (!CONFIG_DIR.empty()) + else if (!configDir.empty()) { - validatorsFile = CONFIG_DIR / kVALIDATORS_FILE_NAME; + validatorsFile = configDir / kValidatorsFileName; if (!validatorsFile.empty()) { @@ -1061,7 +1059,7 @@ Config::loadFromString(std::string const& fileContents) } } - VALIDATOR_LIST_THRESHOLD = [&]() -> std::optional { + validatorListThreshold = [&]() -> std::optional { auto const& listThreshold = section(SECTION_VALIDATOR_LIST_THRESHOLD); if (listThreshold.lines().empty()) { @@ -1119,14 +1117,14 @@ Config::loadFromString(std::string const& fileContents) // This doesn't properly belong here, but check to make sure that the // value specified for network_quorum is achievable: { - auto pm = PEERS_MAX; + auto pm = peersMax; // FIXME this apparently magic value is actually defined as a constant // elsewhere (see defaultMaxPeers) but we handle this check here. if (pm == 0) pm = 21; - if (NETWORK_QUORUM > pm) + if (networkQuorum > pm) { Throw( "The minimum number of required peers (network_quorum) exceeds " @@ -1138,13 +1136,13 @@ Config::loadFromString(std::string const& fileContents) boost::filesystem::path Config::getDebugLogFile() const { - auto logFile = DEBUG_LOGFILE_; + auto logFile = debugLogfile_; if (!logFile.empty() && !logFile.is_absolute()) { // Unless an absolute path for the log file is specified, the // path is relative to the config file directory. - logFile = boost::filesystem::absolute(logFile, CONFIG_DIR); + logFile = boost::filesystem::absolute(logFile, configDir); } if (!logFile.empty()) @@ -1173,9 +1171,9 @@ int Config::getValueFor(SizedItem item, std::optional node) const { auto const index = static_cast>(item); - XRPL_ASSERT(index < kSIZED_ITEMS.size(), "xrpl::Config::getValueFor : valid index input"); + XRPL_ASSERT(index < kSizedItems.size(), "xrpl::Config::getValueFor : valid index input"); XRPL_ASSERT(!node || *node <= 4, "xrpl::Config::getValueFor : unset or valid node"); - return kSIZED_ITEMS.at(index).second.at(node.value_or(NODE_SIZE)); + return kSizedItems.at(index).second.at(node.value_or(nodeSize)); } FeeSetup @@ -1186,14 +1184,14 @@ setupFeeVote(Section const& section) std::uint64_t temp = 0; if (set(temp, "reference_fee", section) && temp <= std::numeric_limits::max()) - setup.reference_fee = temp; + setup.referenceFee = temp; } { std::uint32_t temp = 0; if (set(temp, "account_reserve", section)) - setup.account_reserve = temp; + setup.accountReserve = temp; if (set(temp, "owner_reserve", section)) - setup.owner_reserve = temp; + setup.ownerReserve = temp; } return setup; } @@ -1203,7 +1201,7 @@ setupDatabaseCon(Config const& c, std::optional j) { DatabaseCon::Setup setup; - setup.startUp = c.START_UP; + setup.startUp = c.startUp; setup.standAlone = c.standalone(); setup.dataDir = c.legacy("database_path"); if (!setup.standAlone && setup.dataDir.empty()) @@ -1257,7 +1255,7 @@ setupDatabaseCon(Config const& c, std::optional j) boost::iequals(journalMode, "wal")) { result->emplace_back( - boost::str(boost::format(kCOMMON_DB_PRAGMA_JOURNAL) % journalMode)); + boost::str(boost::format(kCommonDbPragmaJournal) % journalMode)); } else { @@ -1278,8 +1276,7 @@ setupDatabaseCon(Config const& c, std::optional j) if (higherRisk || boost::iequals(synchronous, "normal") || boost::iequals(synchronous, "full") || boost::iequals(synchronous, "extra")) { - result->emplace_back( - boost::str(boost::format(kCOMMON_DB_PRAGMA_SYNC) % synchronous)); + result->emplace_back(boost::str(boost::format(kCommonDbPragmaSync) % synchronous)); } else { @@ -1300,7 +1297,7 @@ setupDatabaseCon(Config const& c, std::optional j) if (higherRisk || boost::iequals(tempStore, "default") || boost::iequals(tempStore, "file")) { - result->emplace_back(boost::str(boost::format(kCOMMON_DB_PRAGMA_TEMP) % tempStore)); + result->emplace_back(boost::str(boost::format(kCommonDbPragmaTemp) % tempStore)); } else { @@ -1308,7 +1305,7 @@ setupDatabaseCon(Config const& c, std::optional j) } } - if (showRiskWarning && j && c.LEDGER_HISTORY > kSQLITE_TUNING_CUTOFF) + if (showRiskWarning && j && c.ledgerHistory > kSqliteTuningCutoff) { JLOG(j->warn()) << "reducing the data integrity guarantees from the " "default [sqlite] behavior is not recommended for " diff --git a/src/xrpld/overlay/Compression.h b/src/xrpld/overlay/Compression.h index 91417913e3..fb58bd128a 100644 --- a/src/xrpld/overlay/Compression.h +++ b/src/xrpld/overlay/Compression.h @@ -5,8 +5,8 @@ namespace xrpl::compression { -std::size_t constexpr kHEADER_BYTES = 6; -std::size_t constexpr kHEADER_BYTES_COMPRESSED = 10; +constexpr std::size_t kHeaderBytes = 6; +constexpr std::size_t kHeaderBytesCompressed = 10; // All values other than 'none' must have the high bit. The low order four bits // must be 0. diff --git a/src/xrpld/overlay/Message.h b/src/xrpld/overlay/Message.h index 7c2701d443..cd21ca40c6 100644 --- a/src/xrpld/overlay/Message.h +++ b/src/xrpld/overlay/Message.h @@ -11,7 +11,7 @@ namespace xrpl { -constexpr std::size_t kMAXIMUM_MESSAGE_SIZE = megabytes(64); +constexpr std::size_t kMaximumMessageSize = megabytes(64); // VFALCO NOTE If we forward declare Message and write out shared_ptr // instead of using the in-class type alias, we can remove the @@ -80,7 +80,7 @@ private: std::vector buffer_; std::vector bufferCompressed_; std::size_t category_; - std::once_flag once_flag_; + std::once_flag onceFlag_; std::optional validatorKey_; /** Set the payload header 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/ReduceRelayCommon.h b/src/xrpld/overlay/ReduceRelayCommon.h index 4105003315..2389c21f0e 100644 --- a/src/xrpld/overlay/ReduceRelayCommon.h +++ b/src/xrpld/overlay/ReduceRelayCommon.h @@ -13,27 +13,27 @@ namespace xrpl::reduce_relay { // where max_squelch is // min(max(MAX_UNSQUELCH_EXPIRE_DEFAULT, SQUELCH_PER_PEER * number_of_peers), // MAX_UNSQUELCH_EXPIRE_PEERS) -static constexpr auto kMIN_UNSQUELCH_EXPIRE = std::chrono::seconds{300}; -static constexpr auto kMAX_UNSQUELCH_EXPIRE_DEFAULT = std::chrono::seconds{600}; -static constexpr auto kSQUELCH_PER_PEER = std::chrono::seconds(10); -static constexpr auto kMAX_UNSQUELCH_EXPIRE_PEERS = std::chrono::seconds{3600}; +static constexpr auto kMinUnsquelchExpire = std::chrono::seconds{300}; +static constexpr auto kMaxUnsquelchExpireDefault = std::chrono::seconds{600}; +static constexpr auto kSquelchPerPeer = std::chrono::seconds(10); +static constexpr auto kMaxUnsquelchExpirePeers = std::chrono::seconds{3600}; // No message received threshold before identifying a peer as idled -static constexpr auto kIDLED = std::chrono::seconds{8}; +static constexpr auto kIdled = std::chrono::seconds{8}; // Message count threshold to start selecting peers as the source // of messages from the validator. We add peers who reach -// kMIN_MESSAGE_THRESHOLD to considered pool once kMAX_SELECTED_PEERS -// reach kMAX_MESSAGE_THRESHOLD. -static constexpr uint16_t kMIN_MESSAGE_THRESHOLD = 19; -static constexpr uint16_t kMAX_MESSAGE_THRESHOLD = 20; +// kMinMessageThreshold to considered pool once kMaxSelectedPeers +// reach kMaxMessageThreshold. +static constexpr uint16_t kMinMessageThreshold = 19; +static constexpr uint16_t kMaxMessageThreshold = 20; // Max selected peers to choose as the source of messages from validator -static constexpr uint16_t kMAX_SELECTED_PEERS = 5; +static constexpr uint16_t kMaxSelectedPeers = 5; // Wait before reduce-relay feature is enabled on boot up to let // the server establish peer connections -static constexpr auto kWAIT_ON_BOOTUP = std::chrono::minutes{10}; +static constexpr auto kWaitOnBootup = std::chrono::minutes{10}; // Maximum size of the aggregated transaction hashes per peer. // Once we get to high tps throughput, this cap will prevent // TMTransactions from exceeding the current protocol message // size limit of 64MB. -static constexpr std::size_t kMAX_TX_QUEUE_SIZE = 10000; +static constexpr std::size_t kMaxTxQueueSize = 10000; } // namespace xrpl::reduce_relay diff --git a/src/xrpld/overlay/Slot.h b/src/xrpld/overlay/Slot.h index 26be3946c1..0600265500 100644 --- a/src/xrpld/overlay/Slot.h +++ b/src/xrpld/overlay/Slot.h @@ -104,10 +104,10 @@ private: /** Update peer info. If the message is from a new * peer or from a previously expired squelched peer then switch * the peer's and slot's state to Counting. If time of last - * selection round is > 2 * kMAX_UNSQUELCH_EXPIRE_DEFAULT then switch the + * selection round is > 2 * kMaxUnsquelchExpireDefault then switch the * slot's state to Counting. If the number of messages for the peer is > - * kMIN_MESSAGE_THRESHOLD then add peer to considered peers pool. If the - * number of considered peers who reached kMAX_MESSAGE_THRESHOLD is + * kMinMessageThreshold then add peer to considered peers pool. If the + * number of considered peers who reached kMaxMessageThreshold is * maxSelectedPeers_ then randomly select maxSelectedPeers_ from * considered peers, and call squelch handler for each peer, which is not * selected and not already in Squelched state. Set the state for those @@ -181,9 +181,9 @@ private: void deleteIdlePeer(PublicKey const& validator); - /** Get random squelch duration between kMIN_UNSQUELCH_EXPIRE and - * min(max(kMAX_UNSQUELCH_EXPIRE_DEFAULT, kSQUELCH_PER_PEER * npeers), - * kMAX_UNSQUELCH_EXPIRE_PEERS) + /** Get random squelch duration between kMinUnsquelchExpire and + * min(max(kMaxUnsquelchExpireDefault, kSquelchPerPeer * npeers), + * kMaxUnsquelchExpirePeers) * @param npeers number of peers that can be squelched in the Slot */ std::chrono::seconds @@ -210,10 +210,10 @@ private: std::unordered_map peers_; // peer's data // pool of peers considered as the source of messages - // from validator - peers that reached kMIN_MESSAGE_THRESHOLD + // from validator - peers that reached kMinMessageThreshold std::unordered_set considered_; - // number of peers that reached kMAX_MESSAGE_THRESHOLD + // number of peers that reached kMaxMessageThreshold std::uint16_t reachedThreshold_{0}; // last time peers were selected, used to age the slot @@ -239,7 +239,7 @@ Slot::deleteIdlePeer(PublicKey const& validator) auto& peer = it->second; auto id = it->first; ++it; - if (now - peer.lastMessage > kIDLED) + if (now - peer.lastMessage > kIdled) { JLOG(journal_.trace()) << "deleteIdlePeer: " << Slice(validator) << " " << id << " idled " @@ -297,12 +297,12 @@ Slot::update( if (state_ != SlotState::Counting || peer.state == PeerState::Squelched) return; - if (++peer.count > kMIN_MESSAGE_THRESHOLD) + if (++peer.count > kMinMessageThreshold) considered_.insert(id); - if (peer.count == (kMAX_MESSAGE_THRESHOLD + 1)) + if (peer.count == (kMaxMessageThreshold + 1)) ++reachedThreshold_; - if (now - lastSelected_ > 2 * kMAX_UNSQUELCH_EXPIRE_DEFAULT) + if (now - lastSelected_ > 2 * kMaxUnsquelchExpireDefault) { JLOG(journal_.trace()) << "update: resetting due to inactivity " << Slice(validator) << " " << id << " " << duration_cast(now - lastSelected_).count(); @@ -333,7 +333,7 @@ Slot::update( << "update: peer not found " << Slice(validator) << " " << id; continue; } - if (now - itPeers->second.lastMessage < kIDLED) + if (now - itPeers->second.lastMessage < kIdled) selected.insert(id); } @@ -389,13 +389,13 @@ std::chrono::seconds Slot::getSquelchDuration(std::size_t npeers) { using namespace std::chrono; - auto m = std::max(kMAX_UNSQUELCH_EXPIRE_DEFAULT, seconds{kSQUELCH_PER_PEER * npeers}); - if (m > kMAX_UNSQUELCH_EXPIRE_PEERS) + auto m = std::max(kMaxUnsquelchExpireDefault, seconds{kSquelchPerPeer * npeers}); + if (m > kMaxUnsquelchExpirePeers) { - m = kMAX_UNSQUELCH_EXPIRE_PEERS; + m = kMaxUnsquelchExpirePeers; JLOG(journal_.warn()) << "getSquelchDuration: unexpected squelch duration " << npeers; } - return seconds{xrpl::randInt(kMIN_UNSQUELCH_EXPIRE / 1s, m / 1s)}; + return seconds{xrpl::randInt(kMinUnsquelchExpire / 1s, m / 1s)}; } template @@ -428,7 +428,7 @@ Slot::deletePeer(PublicKey const& validator, id_t id, bool erase) } else if (considered_.contains(id)) { - if (it->second.count > kMAX_MESSAGE_THRESHOLD) + if (it->second.count > kMaxMessageThreshold) --reachedThreshold_; considered_.erase(id); } @@ -544,8 +544,8 @@ public: : handler_(handler) , logs_(registry.getLogs()) , journal_(registry.getJournal("Slots")) - , baseSquelchEnabled_(config.VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE) - , maxSelectedPeers_(config.VP_REDUCE_RELAY_SQUELCH_MAX_SELECTED_PEERS) + , baseSquelchEnabled_(config.vpReduceRelayBaseSquelchEnable) + , maxSelectedPeers_(config.vpReduceRelaySquelchMaxSelectedPeers) { } ~Slots() = default; @@ -557,14 +557,14 @@ public: return baseSquelchEnabled_ && reduceRelayReady(); } - /** Check if reduce_relay::kWAIT_ON_BOOTUP time passed since startup */ + /** Check if reduce_relay::kWaitOnBootup time passed since startup */ bool reduceRelayReady() { if (!reduceRelayReady_) { reduceRelayReady_ = reduce_relay::epoch(ClockType::now()) > - reduce_relay::kWAIT_ON_BOOTUP; + reduce_relay::kWaitOnBootup; } return reduceRelayReady_; @@ -708,7 +708,7 @@ template bool Slots::addPeerMessage(uint256 const& key, id_t id) { - beast::expire(peersWithMessage, reduce_relay::kIDLED); + beast::expire(peersWithMessage, reduce_relay::kIdled); if (key.isNonZero()) { @@ -782,7 +782,7 @@ Slots::deleteIdlePeers() for (auto it = slots_.begin(); it != slots_.end();) { it->second.deleteIdlePeer(it->first); - if (now - it->second.getLastSelected() > kMAX_UNSQUELCH_EXPIRE_DEFAULT) + if (now - it->second.getLastSelected() > kMaxUnsquelchExpireDefault) { JLOG(journal_.trace()) << "deleteIdlePeers: deleting idle slot " << Slice(it->first); it = slots_.erase(it); diff --git a/src/xrpld/overlay/Squelch.h b/src/xrpld/overlay/Squelch.h index 21a1b228a1..b509f293c2 100644 --- a/src/xrpld/overlay/Squelch.h +++ b/src/xrpld/overlay/Squelch.h @@ -56,7 +56,7 @@ Squelch::addSquelch( PublicKey const& validator, std::chrono::seconds const& squelchDuration) { - if (squelchDuration >= kMIN_UNSQUELCH_EXPIRE && squelchDuration <= kMAX_UNSQUELCH_EXPIRE_PEERS) + if (squelchDuration >= kMinUnsquelchExpire && squelchDuration <= kMaxUnsquelchExpirePeers) { squelched_[validator] = ClockType::now() + squelchDuration; return true; diff --git a/src/xrpld/overlay/detail/ConnectAttempt.cpp b/src/xrpld/overlay/detail/ConnectAttempt.cpp index c83478ce1e..295f4f5497 100644 --- a/src/xrpld/overlay/detail/ConnectAttempt.cpp +++ b/src/xrpld/overlay/detail/ConnectAttempt.cpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -28,19 +29,17 @@ #include #include #include -#include #include #include #include #include #include -#include #include #include #include #include -#include +#include #include #include @@ -52,7 +51,7 @@ ConnectAttempt::ConnectAttempt( endpoint_type remoteEndpoint, Resource::Consumer usage, shared_context const& context, - std::uint32_t id, + Peer::id_t id, std::shared_ptr const& slot, beast::Journal journal, OverlayImpl& overlay) @@ -65,7 +64,6 @@ ConnectAttempt::ConnectAttempt( , usage_(usage) , strand_(boost::asio::make_strand(ioContext)) , timer_(ioContext) - , stepTimer_(ioContext) , streamPtr_( std::make_unique( socket_type(std::forward(ioContext)), @@ -78,10 +76,9 @@ ConnectAttempt::ConnectAttempt( ConnectAttempt::~ConnectAttempt() { - // slot_ will be null if we successfully connected - // and transferred ownership to a PeerImp if (slot_ != nullptr) overlay_.peerFinder().onClosed(slot_); + JLOG(journal_.trace()) << "~ConnectAttempt"; } void @@ -92,30 +89,17 @@ ConnectAttempt::stop() boost::asio::post(strand_, std::bind(&ConnectAttempt::stop, shared_from_this())); return; } - - if (!socket_.is_open()) - return; - - JLOG(journal_.debug()) << "stop: Stop"; - - shutdown(); + if (socket_.is_open()) + { + JLOG(journal_.debug()) << "Stop"; + } + close(); } void ConnectAttempt::run() { - if (!strand_.running_in_this_thread()) - { - boost::asio::post(strand_, std::bind(&ConnectAttempt::run, shared_from_this())); - return; - } - - JLOG(journal_.debug()) << "run: connecting to " << remoteEndpoint_; - - ioPending_ = true; - - // Allow up to connectTimeout_ seconds to establish remote peer connection - setTimer(ConnectionStep::TcpConnect); + setTimer(); stream_.next_layer().async_connect( remoteEndpoint_, @@ -126,73 +110,6 @@ ConnectAttempt::run() //------------------------------------------------------------------------------ -void -ConnectAttempt::shutdown() -{ - XRPL_ASSERT( - strand_.running_in_this_thread(), "xrpl::ConnectAttempt::shutdown: strand in this thread"); - - if (!socket_.is_open()) - return; - - shutdown_ = true; - boost::beast::get_lowest_layer(stream_).cancel(); - - tryAsyncShutdown(); -} - -void -ConnectAttempt::tryAsyncShutdown() -{ - XRPL_ASSERT( - strand_.running_in_this_thread(), - "xrpl::ConnectAttempt::tryAsyncShutdown : strand in this thread"); - - if (!shutdown_ || currentStep_ == ConnectionStep::ShutdownStarted) - return; - - if (ioPending_) - return; - - // gracefully shutdown the SSL socket, performing a shutdown handshake - if (currentStep_ != ConnectionStep::TcpConnect && currentStep_ != ConnectionStep::TlsHandshake) - { - setTimer(ConnectionStep::ShutdownStarted); - stream_.async_shutdown(bind_executor( - strand_, - std::bind(&ConnectAttempt::onShutdown, shared_from_this(), std::placeholders::_1))); - return; - } - - close(); -} - -void -ConnectAttempt::onShutdown(error_code ec) -{ - cancelTimer(); - - if (ec) - { - // - eof: the stream was cleanly closed - // - operation_aborted: an expired timer (slow shutdown) - // - stream_truncated: the tcp connection closed (no handshake) it could - // occur if a peer does not perform a graceful disconnect - // - broken_pipe: the peer is gone - // - application data after close notify: benign SSL shutdown condition - bool const shouldLog = - (ec != boost::asio::error::eof && ec != boost::asio::error::operation_aborted && - ec.message().find("application data after close notify") == std::string::npos); - - if (shouldLog) - { - JLOG(journal_.debug()) << "onShutdown: " << ec.message(); - } - } - - close(); -} - void ConnectAttempt::close() { @@ -201,93 +118,50 @@ ConnectAttempt::close() if (!socket_.is_open()) return; - cancelTimer(); + try + { + timer_.cancel(); + socket_.close(); + } + catch (boost::system::system_error const&) // NOLINT(bugprone-empty-catch) + { + // ignored + } - error_code ec; - socket_.close(ec); // NOLINT(bugprone-unused-return-value) + JLOG(journal_.debug()) << "Closed"; } void ConnectAttempt::fail(std::string const& reason) { JLOG(journal_.debug()) << reason; - shutdown(); + close(); } void ConnectAttempt::fail(std::string const& name, error_code ec) { JLOG(journal_.debug()) << name << ": " << ec.message(); - shutdown(); + close(); } void -ConnectAttempt::setTimer(ConnectionStep step) +ConnectAttempt::setTimer() { - currentStep_ = step; - - // Set global timer (only if not already set) - if (timer_.expiry() == std::chrono::steady_clock::time_point{}) - { - try - { - timer_.expires_after(kCONNECT_TIMEOUT); - timer_.async_wait( - boost::asio::bind_executor( - strand_, - std::bind( - &ConnectAttempt::onTimer, shared_from_this(), std::placeholders::_1))); - } - catch (std::exception const& ex) - { - JLOG(journal_.error()) << "setTimer (global): " << ex.what(); - close(); - return; - } - } - - // Set step-specific timer try { - std::chrono::seconds stepTimeout; - switch (step) - { - case ConnectionStep::TcpConnect: - stepTimeout = StepTimeouts::kTCP_CONNECT; - break; - case ConnectionStep::TlsHandshake: - stepTimeout = StepTimeouts::kTLS_HANDSHAKE; - break; - case ConnectionStep::HttpWrite: - stepTimeout = StepTimeouts::kHTTP_WRITE; - break; - case ConnectionStep::HttpRead: - stepTimeout = StepTimeouts::kHTTP_READ; - break; - case ConnectionStep::ShutdownStarted: - stepTimeout = StepTimeouts::kTLS_SHUTDOWN; - break; - case ConnectionStep::Complete: - case ConnectionStep::Init: - return; // No timer needed for init or complete step - } - - // call to expires_after cancels previous timer - stepTimer_.expires_after(stepTimeout); - stepTimer_.async_wait( - boost::asio::bind_executor( - strand_, - std::bind(&ConnectAttempt::onTimer, shared_from_this(), std::placeholders::_1))); - - JLOG(journal_.trace()) << "setTimer: " << stepToString(step) - << " timeout=" << stepTimeout.count() << "s"; + timer_.expires_after(std::chrono::seconds(15)); } - catch (std::exception const& ex) + catch (boost::system::system_error const& e) { - JLOG(journal_.error()) << "setTimer (step " << stepToString(step) << "): " << ex.what(); - close(); + JLOG(journal_.error()) << "setTimer: " << e.code(); return; } + + timer_.async_wait( + boost::asio::bind_executor( + strand_, + std::bind(&ConnectAttempt::onTimer, shared_from_this(), std::placeholders::_1))); } void @@ -296,7 +170,6 @@ ConnectAttempt::cancelTimer() try { timer_.cancel(); - stepTimer_.cancel(); } catch (boost::system::system_error const&) // NOLINT(bugprone-empty-catch) { @@ -321,40 +194,18 @@ ConnectAttempt::onTimer(error_code ec) close(); return; } - - // Determine which timer expired by checking their expiry times - auto const now = std::chrono::steady_clock::now(); - bool const globalExpired = (timer_.expiry() <= now); - bool const stepExpired = (stepTimer_.expiry() <= now); - - if (globalExpired) - { - JLOG(journal_.debug()) << "onTimer: Global timeout; step: " << stepToString(currentStep_); - } - else if (stepExpired) - { - JLOG(journal_.debug()) << "onTimer: Step timeout; step: " << stepToString(currentStep_); - } - else - { - JLOG(journal_.warn()) << "onTimer: Unexpected timer callback"; - } - - close(); + fail("Timeout"); } void ConnectAttempt::onConnect(error_code ec) { - ioPending_ = false; + cancelTimer(); if (ec) { if (ec == boost::asio::error::operation_aborted) - { - tryAsyncShutdown(); return; - } fail("onConnect", ec); return; @@ -371,15 +222,7 @@ ConnectAttempt::onConnect(error_code ec) return; } - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - - ioPending_ = true; - - setTimer(ConnectionStep::TlsHandshake); + setTimer(); stream_.set_verify_mode(boost::asio::ssl::verify_none); stream_.async_handshake( @@ -392,15 +235,14 @@ ConnectAttempt::onConnect(error_code ec) void ConnectAttempt::onHandshake(error_code ec) { - ioPending_ = false; + cancelTimer(); + if (!socket_.is_open()) + return; if (ec) { if (ec == boost::asio::error::operation_aborted) - { - tryAsyncShutdown(); return; - } fail("onHandshake", ec); return; @@ -413,29 +255,26 @@ ConnectAttempt::onHandshake(error_code ec) return; } - setTimer(ConnectionStep::HttpWrite); - - // check if we connected to ourselves if (!overlay_.peerFinder().onConnected( slot_, beast::IPAddressConversion::fromAsio(localEndpoint))) { - fail("Self connection"); + fail("Duplicate connection"); return; } auto const sharedValue = makeSharedValue(*streamPtr_, journal_); if (!sharedValue) { - shutdown(); - return; // makeSharedValue logs + close(); // makeSharedValue logs + return; } req_ = makeRequest( !overlay_.peerFinder().config().peerPrivate, - app_.config().COMPRESSION, - app_.config().LEDGER_REPLAY, - app_.config().TX_REDUCE_RELAY_ENABLE, - app_.config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE); + app_.config().compression, + app_.config().ledgerReplay, + app_.config().txReduceRelayEnable, + app_.config().vpReduceRelayBaseSquelchEnable); buildHandshake( req_, @@ -445,14 +284,7 @@ ConnectAttempt::onHandshake(error_code ec) remoteEndpoint_.address(), app_); - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - - ioPending_ = true; - + setTimer(); boost::beast::http::async_write( stream_, req_, @@ -464,30 +296,20 @@ ConnectAttempt::onHandshake(error_code ec) void ConnectAttempt::onWrite(error_code ec) { - ioPending_ = false; + cancelTimer(); + + if (!socket_.is_open()) + return; if (ec) { if (ec == boost::asio::error::operation_aborted) - { - tryAsyncShutdown(); return; - } fail("onWrite", ec); return; } - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - - ioPending_ = true; - - setTimer(ConnectionStep::HttpRead); - boost::beast::http::async_read( stream_, readBuf_, @@ -501,21 +323,24 @@ void ConnectAttempt::onRead(error_code ec) { cancelTimer(); - ioPending_ = false; - currentStep_ = ConnectionStep::Complete; + + if (!socket_.is_open()) + return; if (ec) { + if (ec == boost::asio::error::operation_aborted) + return; + if (ec == boost::asio::error::eof) { JLOG(journal_.debug()) << "EOF"; - shutdown(); - return; - } - - if (ec == boost::asio::error::operation_aborted) - { - tryAsyncShutdown(); + setTimer(); + stream_.async_shutdown( + boost::asio::bind_executor( + strand_, + std::bind( + &ConnectAttempt::onShutdown, shared_from_this(), std::placeholders::_1))); return; } @@ -523,13 +348,25 @@ ConnectAttempt::onRead(error_code ec) return; } - if (shutdown_) + processResponse(); +} + +void +ConnectAttempt::onShutdown(error_code ec) +{ + cancelTimer(); + if (!ec) { - tryAsyncShutdown(); + close(); return; } - processResponse(); + if (ec != boost::asio::error::eof) + { + fail("onShutdown", ec); + return; + } + close(); } //-------------------------------------------------------------------------- @@ -537,71 +374,47 @@ ConnectAttempt::onRead(error_code ec) void ConnectAttempt::processResponse() { - if (!OverlayImpl::isPeerUpgrade(response_)) + if (response_.result() == boost::beast::http::status::service_unavailable) { - // A peer may respond with service_unavailable and a list of alternative - // peers to connect to, a differing status code is unexpected - if (response_.result() != boost::beast::http::status::service_unavailable) - { - JLOG(journal_.warn()) << "Unable to upgrade to peer protocol: " << response_.result() - << " (" << response_.reason() << ")"; - shutdown(); - return; - } - - // Parse response body to determine if this is a redirect or other - // service unavailable - std::string responseBody; - responseBody.reserve(boost::asio::buffer_size(response_.body().data())); + json::Value json; + json::Reader r; + std::string s; + s.reserve(boost::asio::buffer_size(response_.body().data())); for (auto const buffer : response_.body().data()) { - responseBody.append( - static_cast(buffer.data()), boost::asio::buffer_size(buffer)); + s.append(static_cast(buffer.data()), boost::asio::buffer_size(buffer)); } - - json::Value json; - json::Reader reader; - auto const isValidJson = reader.parse(responseBody, json); - - // Check if this is a redirect response (contains peer-ips field) - auto const isRedirect = isValidJson && json.isObject() && json.isMember("peer-ips"); - - if (!isRedirect) + auto const success = r.parse(s, json); + if (success) { - JLOG(journal_.warn()) << "processResponse: " << remoteEndpoint_ - << " failed to upgrade to peer protocol: " << response_.result() - << " (" << response_.reason() << ")"; - - shutdown(); - return; + if (json.isObject() && json.isMember("peer-ips")) + { + json::Value const& ips = json["peer-ips"]; + if (ips.isArray()) + { + std::vector eps; + eps.reserve(ips.size()); + for (auto const& v : ips) + { + if (v.isString()) + { + error_code ec; + auto const ep = parseEndpoint(v.asString(), ec); + if (!ec) + eps.push_back(ep); + } + } + overlay_.peerFinder().onRedirects(remoteEndpoint_, eps); + } + } } + } - json::Value const& peerIps = json["peer-ips"]; - if (!peerIps.isArray()) - { - fail("processResponse: invalid peer-ips format"); - return; - } - - // Extract and validate peer endpoints - std::vector redirectEndpoints; - redirectEndpoints.reserve(peerIps.size()); - - for (auto const& ipValue : peerIps) - { - if (!ipValue.isString()) - continue; - - error_code ec; - auto const endpoint = parseEndpoint(ipValue.asString(), ec); - if (!ec) - redirectEndpoints.push_back(endpoint); - } - - // Notify PeerFinder about the redirect redirectEndpoints may be empty - overlay_.peerFinder().onRedirects(remoteEndpoint_, redirectEndpoints); - - fail("processResponse: failed to connect to peer: redirected"); + if (!OverlayImpl::isPeerUpgrade(response_)) + { + JLOG(journal_.info()) << "Unable to upgrade to peer protocol: " << response_.result() + << " (" << response_.reason() << ")"; + close(); return; } @@ -625,8 +438,8 @@ ConnectAttempt::processResponse() auto const sharedValue = makeSharedValue(*streamPtr_, journal_); if (!sharedValue) { - shutdown(); - return; // makeSharedValue logs + close(); // makeSharedValue logs + return; } try @@ -641,30 +454,21 @@ ConnectAttempt::processResponse() usage_.setPublicKey(publicKey); - JLOG(journal_.debug()) << "Protocol: " << to_string(*negotiatedProtocol); JLOG(journal_.info()) << "Public Key: " << toBase58(TokenType::NodePublic, publicKey); + JLOG(journal_.debug()) << "Protocol: " << to_string(*negotiatedProtocol); + auto const member = app_.getCluster().member(publicKey); if (member) { JLOG(journal_.info()) << "Cluster name: " << *member; } - auto const result = overlay_.peerFinder().activate(slot_, publicKey, member.has_value()); + auto const result = + overlay_.peerFinder().activate(slot_, publicKey, static_cast(member)); if (result != PeerFinder::Result::Success) { - std::stringstream ss; - ss << "Outbound Connect Attempt " << remoteEndpoint_ << " " << to_string(result); - fail(ss.str()); - return; - } - - if (!socket_.is_open()) - return; - - if (shutdown_) - { - tryAsyncShutdown(); + fail("Outbound " + std::string(to_string(result))); return; } diff --git a/src/xrpld/overlay/detail/ConnectAttempt.h b/src/xrpld/overlay/detail/ConnectAttempt.h index 70ce7912ba..aba224d5c7 100644 --- a/src/xrpld/overlay/detail/ConnectAttempt.h +++ b/src/xrpld/overlay/detail/ConnectAttempt.h @@ -1,42 +1,13 @@ #pragma once +#include #include -#include +#include namespace xrpl { -/** - * @class ConnectAttempt - * @brief Manages outbound peer connection attempts with comprehensive timeout - * handling - * - * The ConnectAttempt class handles the complete lifecycle of establishing an - * outbound connection to a peer in the XRPL network. It implements a - * sophisticated dual-timer system that provides both global timeout protection - * and per-step timeout diagnostics. - * - * The connection establishment follows these steps: - * 1. **TCP Connect**: Establish basic network connection - * 2. **TLS Handshake**: Negotiate SSL/TLS encryption - * 3. **HTTP Write**: Send peer handshake request - * 4. **HTTP Read**: Receive and validate peer response - * 5. **Complete**: Connection successfully established - * - * Uses a hybrid timeout approach: - * - **Global Timer**: Hard limit (20s) for entire connection process - * - **Step Timers**: Individual timeouts for each connection phase - * - * - All errors result in connection termination - * - * All operations are serialized using boost::asio::strand to ensure thread - * safety. The class is designed to be used exclusively within the ASIO event - * loop. - * - * @note This class should not be used directly. It is managed by OverlayImpl - * as part of the peer discovery and connection management system. - * - */ +/** Manages an outbound connection attempt. */ class ConnectAttempt : public OverlayImpl::Child, public std::enable_shared_from_this { @@ -45,95 +16,29 @@ private: using endpoint_type = boost::asio::ip::tcp::endpoint; using request_type = boost::beast::http::request; using response_type = boost::beast::http::response; + using socket_type = boost::asio::ip::tcp::socket; using middle_type = boost::beast::tcp_stream; using stream_type = boost::beast::ssl_stream; using shared_context = std::shared_ptr; - /** - * @enum ConnectionStep - * @brief Represents the current phase of the connection establishment - * process - * - * Used for tracking progress and providing detailed timeout diagnostics. - * Each step has its own timeout value defined in StepTimeouts. - */ - enum class ConnectionStep { - Init, // Initial state, nothing started - TcpConnect, // Establishing TCP connection to remote peer - TlsHandshake, // Performing SSL/TLS handshake - HttpWrite, // Sending HTTP upgrade request - HttpRead, // Reading HTTP upgrade response - Complete, // Connection successfully established - ShutdownStarted // Connection shutdown has started - }; - - // A timeout for connection process, greater than all step timeouts - static constexpr std::chrono::seconds kCONNECT_TIMEOUT{25}; - - /** - * @struct StepTimeouts - * @brief Defines timeout values for each connection step - * - * These timeouts are designed to detect slow individual phases while - * allowing the global timeout to enforce the overall time limit. - */ - struct StepTimeouts - { - // TCP connection timeout - static constexpr std::chrono::seconds kTCP_CONNECT{8}; - // SSL handshake timeout - static constexpr std::chrono::seconds kTLS_HANDSHAKE{8}; - // HTTP write timeout - static constexpr std::chrono::seconds kHTTP_WRITE{3}; - // HTTP read timeout - static constexpr std::chrono::seconds kHTTP_READ{3}; - // SSL shutdown timeout - static constexpr std::chrono::seconds kTLS_SHUTDOWN{2}; - }; - - // Core application and networking components Application& app_; - Peer::id_t const id_; + std::uint32_t const id_; beast::WrappedSink sink_; beast::Journal const journal_; endpoint_type remoteEndpoint_; Resource::Consumer usage_; - boost::asio::strand strand_; boost::asio::basic_waitable_timer timer_; - boost::asio::basic_waitable_timer stepTimer_; - - std::unique_ptr streamPtr_; // SSL stream (owned) + std::unique_ptr streamPtr_; socket_type& socket_; stream_type& stream_; boost::beast::multi_buffer readBuf_; - response_type response_; std::shared_ptr slot_; request_type req_; - bool shutdown_ = false; // Shutdown has been initiated - bool ioPending_ = false; // Async I/O operation in progress - ConnectionStep currentStep_ = ConnectionStep::Init; - public: - /** - * @brief Construct a new ConnectAttempt object - * - * @param app Application context providing configuration and services - * @param ioContext ASIO I/O context for async operations - * @param remoteEndpoint Target peer endpoint to connect to - * @param usage Resource usage tracker for rate limiting - * @param context Shared SSL context for encryption - * @param id Unique peer identifier for this connection attempt - * @param slot PeerFinder slot representing this connection - * @param journal Logging interface for diagnostics - * @param overlay Parent overlay manager - * - * @note The constructor only initializes the object. Call run() to begin - * the actual connection attempt. - */ ConnectAttempt( Application& app, boost::asio::io_context& ioContext, @@ -147,111 +52,38 @@ public: ~ConnectAttempt() override; - /** - * @brief Stop the connection attempt - * - * This method is thread-safe and can be called from any thread. - */ void stop() override; - /** - * @brief Begin the connection attempt - * - * This method is thread-safe and posts to the strand if needed. - */ void run(); private: - /** - * @brief Set timers for the specified connection step - * - * @param step The connection step to set timers for - * - * Sets both the step-specific timer and the global timer (if not already - * set). - */ void - setTimer(ConnectionStep step); - - /** - * @brief Cancel both global and step timers - * - * Used during cleanup and when connection completes successfully. - * Exceptions from timer cancellation are safely ignored. - */ + close(); + void + fail(std::string const& reason); + void + fail(std::string const& name, error_code ec); + void + setTimer(); void cancelTimer(); - - /** - * @brief Handle timer expiration events - * - * @param ec Error code from timer operation - * - * Determines which timer expired (global vs step) and logs appropriate - * diagnostic information before terminating the connection. - */ void onTimer(error_code ec); - - // Connection phase handlers void - onConnect(error_code ec); // TCP connection completion handler + onConnect(error_code ec); void - onHandshake(error_code ec); // TLS handshake completion handler + onHandshake(error_code ec); void - onWrite(error_code ec); // HTTP write completion handler + onWrite(error_code ec); void - onRead(error_code ec); // HTTP read completion handler - - // Error and cleanup handlers + onRead(error_code ec); void - fail(std::string const& reason); // Fail with custom reason - void - fail(std::string const& name, error_code ec); // Fail with system error - void - shutdown(); // Initiate graceful shutdown - void - tryAsyncShutdown(); // Attempt async SSL shutdown - void - onShutdown(error_code ec); // SSL shutdown completion handler - void - close(); // Force close socket - - /** - * @brief Process the HTTP upgrade response from peer - * - * Validates the peer's response, extracts protocol information, - * verifies handshake, and either creates a PeerImp or handles - * redirect responses. - */ + onShutdown(error_code ec); void processResponse(); - static std::string - stepToString(ConnectionStep step) - { - switch (step) - { - case ConnectionStep::Init: - return "Init"; - case ConnectionStep::TcpConnect: - return "TcpConnect"; - case ConnectionStep::TlsHandshake: - return "TlsHandshake"; - case ConnectionStep::HttpWrite: - return "HttpWrite"; - case ConnectionStep::HttpRead: - return "HttpRead"; - case ConnectionStep::Complete: - return "Complete"; - case ConnectionStep::ShutdownStarted: - return "ShutdownStarted"; - } - return "Unknown"; - }; - template static boost::asio::ip::tcp::endpoint parseEndpoint(std::string const& s, boost::system::error_code& ec) diff --git a/src/xrpld/overlay/detail/Handshake.cpp b/src/xrpld/overlay/detail/Handshake.cpp index af0585f8ad..39fd93f1d4 100644 --- a/src/xrpld/overlay/detail/Handshake.cpp +++ b/src/xrpld/overlay/detail/Handshake.cpp @@ -88,13 +88,13 @@ makeFeaturesRequestHeader( { std::stringstream str; if (comprEnabled) - str << kFEATURE_COMPR << "=lz4" << kDELIM_FEATURE; + str << kFeatureCompr << "=lz4" << kDelimFeature; if (ledgerReplayEnabled) - str << kFEATURE_LEDGER_REPLAY << "=1" << kDELIM_FEATURE; + str << kFeatureLedgerReplay << "=1" << kDelimFeature; if (txReduceRelayEnabled) - str << kFEATURE_TXRR << "=1" << kDELIM_FEATURE; + str << kFeatureTxrr << "=1" << kDelimFeature; if (vpReduceRelayEnabled) - str << kFEATURE_VPRR << "=1" << kDELIM_FEATURE; + str << kFeatureVprr << "=1" << kDelimFeature; return str.str(); } @@ -107,14 +107,14 @@ makeFeaturesResponseHeader( bool vpReduceRelayEnabled) { std::stringstream str; - if (comprEnabled && isFeatureValue(headers, kFEATURE_COMPR, "lz4")) - str << kFEATURE_COMPR << "=lz4" << kDELIM_FEATURE; - if (ledgerReplayEnabled && featureEnabled(headers, kFEATURE_LEDGER_REPLAY)) - str << kFEATURE_LEDGER_REPLAY << "=1" << kDELIM_FEATURE; - if (txReduceRelayEnabled && featureEnabled(headers, kFEATURE_TXRR)) - str << kFEATURE_TXRR << "=1" << kDELIM_FEATURE; - if (vpReduceRelayEnabled && featureEnabled(headers, kFEATURE_VPRR)) - str << kFEATURE_VPRR << "=1" << kDELIM_FEATURE; + if (comprEnabled && isFeatureValue(headers, kFeatureCompr, "lz4")) + str << kFeatureCompr << "=lz4" << kDelimFeature; + if (ledgerReplayEnabled && featureEnabled(headers, kFeatureLedgerReplay)) + str << kFeatureLedgerReplay << "=1" << kDelimFeature; + if (txReduceRelayEnabled && featureEnabled(headers, kFeatureTxrr)) + str << kFeatureTxrr << "=1" << kDelimFeature; + if (vpReduceRelayEnabled && featureEnabled(headers, kFeatureVprr)) + str << kFeatureVprr << "=1" << kDelimFeature; return str.str(); } @@ -132,20 +132,20 @@ 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; + static constexpr std::size_t kSslMinimumFinishedLength = 12; unsigned char buf[1024]; size_t const len = get(ssl, buf, sizeof(buf)); - if (len < kSSL_MINIMUM_FINISHED_LENGTH) + if (len < kSslMinimumFinishedLength) return std::nullopt; sha512_hasher const h; - BaseUint<512> cookie; + BaseUInt<512> cookie; SHA512(buf, len, cookie.data()); return cookie; } @@ -171,7 +171,7 @@ makeSharedValue(stream_type& ssl, beast::Journal journal) // Both messages hash to the same value and the cookie // is 0. Don't allow this. - if (result == beast::kZERO) + if (result == beast::kZero) { JLOG(journal.error()) << "Cookie generation: identical finished messages"; return std::nullopt; @@ -209,8 +209,8 @@ buildHandshake( h.insert("Instance-Cookie", std::to_string(app.instanceID())); - if (!app.config().SERVER_DOMAIN.empty()) - h.insert("Server-Domain", app.config().SERVER_DOMAIN); + if (!app.config().serverDomain.empty()) + h.insert("Server-Domain", app.config().serverDomain); if (beast::IP::isPublic(remoteIp)) h.insert("Remote-IP", remoteIp.to_string()); @@ -408,10 +408,10 @@ makeResponse( "X-Protocol-Ctl", makeFeaturesResponseHeader( req, - app.config().COMPRESSION, - app.config().LEDGER_REPLAY, - app.config().TX_REDUCE_RELAY_ENABLE, - app.config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE)); + app.config().compression, + app.config().ledgerReplay, + app.config().txReduceRelayEnable, + app.config().vpReduceRelayBaseSquelchEnable)); buildHandshake(resp, sharedValue, networkID, publicIp, remoteIp, app); diff --git a/src/xrpld/overlay/detail/Handshake.h b/src/xrpld/overlay/detail/Handshake.h index 77a346477f..3cbaa118da 100644 --- a/src/xrpld/overlay/detail/Handshake.h +++ b/src/xrpld/overlay/detail/Handshake.h @@ -115,15 +115,15 @@ makeResponse( // value: \S+ // compression feature -static constexpr char kFEATURE_COMPR[] = "compr"; +static constexpr char kFeatureCompr[] = "compr"; // validation/proposal reduce-relay base squelch feature -static constexpr char kFEATURE_VPRR[] = "vprr"; +static constexpr char kFeatureVprr[] = "vprr"; // transaction reduce-relay feature -static constexpr char kFEATURE_TXRR[] = "txrr"; +static constexpr char kFeatureTxrr[] = "txrr"; // ledger replay -static constexpr char kFEATURE_LEDGER_REPLAY[] = "ledgerreplay"; -static constexpr char kDELIM_FEATURE[] = ";"; -static constexpr char kDELIM_VALUE[] = ","; +static constexpr char kFeatureLedgerReplay[] = "ledgerreplay"; +static constexpr char kDelimFeature[] = ";"; +static constexpr char kDelimValue[] = ","; /** Get feature's header value @param headers request/response header diff --git a/src/xrpld/overlay/detail/Message.cpp b/src/xrpld/overlay/detail/Message.cpp index 30f4c281ed..120b34c78c 100644 --- a/src/xrpld/overlay/detail/Message.cpp +++ b/src/xrpld/overlay/detail/Message.cpp @@ -31,12 +31,12 @@ Message::Message( XRPL_ASSERT(messageBytes, "xrpl::Message::Message : non-empty message input"); - buffer_.resize(kHEADER_BYTES + messageBytes); + buffer_.resize(kHeaderBytes + messageBytes); setHeader(buffer_.data(), messageBytes, type, Algorithm::None, 0); if (messageBytes != 0) - message.SerializeToArray(buffer_.data() + kHEADER_BYTES, messageBytes); + message.SerializeToArray(buffer_.data() + kHeaderBytes, messageBytes); XRPL_ASSERT( getBufferSize() == totalSize(message), @@ -58,14 +58,14 @@ Message::messageSize(::google::protobuf::Message const& message) std::size_t Message::totalSize(::google::protobuf::Message const& message) { - return messageSize(message) + compression::kHEADER_BYTES; + return messageSize(message) + compression::kHeaderBytes; } void Message::compress() { using namespace xrpl::compression; - auto const messageBytes = buffer_.size() - kHEADER_BYTES; + auto const messageBytes = buffer_.size() - kHeaderBytes; auto type = getType(buffer_.data()); @@ -104,19 +104,19 @@ Message::compress() if (compressible) { - auto payload = static_cast(buffer_.data() + kHEADER_BYTES); + auto payload = static_cast(buffer_.data() + kHeaderBytes); auto compressedSize = xrpl::compression::compress( payload, messageBytes, [&](std::size_t inSize) { // size of required compressed buffer - bufferCompressed_.resize(inSize + kHEADER_BYTES_COMPRESSED); - return (bufferCompressed_.data() + kHEADER_BYTES_COMPRESSED); + bufferCompressed_.resize(inSize + kHeaderBytesCompressed); + return (bufferCompressed_.data() + kHeaderBytesCompressed); }); - if (compressedSize < (messageBytes - (kHEADER_BYTES_COMPRESSED - kHEADER_BYTES))) + if (compressedSize < (messageBytes - (kHeaderBytesCompressed - kHeaderBytes))) { - bufferCompressed_.resize(kHEADER_BYTES_COMPRESSED + compressedSize); + bufferCompressed_.resize(kHeaderBytesCompressed + compressedSize); // NOLINTNEXTLINE(readability-suspicious-call-argument) setHeader(bufferCompressed_.data(), compressedSize, type, Algorithm::LZ4, messageBytes); } @@ -203,7 +203,7 @@ Message::getBuffer(Compressed tryCompressed) if (tryCompressed == Compressed::Off) return buffer_; - std::call_once(once_flag_, &Message::compress, this); + std::call_once(onceFlag_, &Message::compress, this); if (!bufferCompressed_.empty()) { diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp index e21d00a1e7..b31f54058a 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 kServerInfo = (1 << 1); +static constexpr auto kServerCounts = (1 << 2); +static constexpr auto kUNL = (1 << 3); } // namespace CrawlOptions //------------------------------------------------------------------------------ @@ -116,7 +112,7 @@ OverlayImpl::Child::~Child() //------------------------------------------------------------------------------ -OverlayImpl::Timer::Timer(OverlayImpl& overlay) : Child(overlay), timer(overlay_.io_context_) +OverlayImpl::Timer::Timer(OverlayImpl& overlay) : Child(overlay), timer(overlay_.ioContext_) { } @@ -154,10 +150,10 @@ OverlayImpl::Timer::onTimer(error_code ec) overlay_.peerFinder_->oncePerSecond(); overlay_.sendEndpoints(); overlay_.autoConnect(); - if (overlay_.app_.config().TX_REDUCE_RELAY_ENABLE) + if (overlay_.app_.config().txReduceRelayEnable) overlay_.sendTxQueue(); - if ((++overlay_.timer_count_ % Tuning::CheckIdlePeers) == 0) + if ((++overlay_.timerCount_ % Tuning::kCheckIdlePeers) == 0) overlay_.deleteIdlePeers(); asyncWait(); @@ -175,9 +171,9 @@ OverlayImpl::OverlayImpl( BasicConfig const& config, beast::insight::Collector::ptr const& collector) : app_(app) - , io_context_(ioContext) - , work_(std::in_place, boost::asio::make_work_guard(io_context_)) - , strand_(boost::asio::make_strand(io_context_)) + , ioContext_(ioContext) + , work_(std::in_place, boost::asio::make_work_guard(ioContext_)) + , strand_(boost::asio::make_strand(ioContext_)) , setup_(std::move(setup)) , journal_(app_.getJournal("Overlay")) , serverHandler_(serverHandler) @@ -190,7 +186,7 @@ OverlayImpl::OverlayImpl( config, collector)) , resolver_(resolver) - , next_id_(1) + , nextId_(1) , slots_(app, *this, app.config()) , stats_( std::bind(&OverlayImpl::collectMetrics, this), @@ -213,7 +209,7 @@ OverlayImpl::onHandoff( http_request_type&& request, endpoint_type remoteEndpoint) { - auto const id = next_id_++; + auto const id = nextId_++; auto peerJournal = app_.getJournal("Peer"); beast::WrappedSink sink(peerJournal.sink(), makePrefix(id)); beast::Journal const journal(sink); @@ -263,7 +259,7 @@ OverlayImpl::onHandoff( { handoff.moved = false; handoff.response = makeRedirectResponse(slot, request, remoteEndpoint.address()); - handoff.keep_alive = beast::rfc2616::isKeepAlive(request); + handoff.keepAlive = beast::rfc2616::isKeepAlive(request); return handoff; } } @@ -275,7 +271,7 @@ OverlayImpl::onHandoff( handoff.moved = false; handoff.response = makeErrorResponse( slot, request, remoteEndpoint.address(), "Unable to agree on a protocol version"); - handoff.keep_alive = false; + handoff.keepAlive = false; return handoff; } @@ -286,7 +282,7 @@ OverlayImpl::onHandoff( handoff.moved = false; handoff.response = makeErrorResponse(slot, request, remoteEndpoint.address(), "Incorrect security cookie"); - handoff.keep_alive = false; + handoff.keepAlive = false; return handoff; } @@ -315,7 +311,7 @@ OverlayImpl::onHandoff( << "Peer " << remoteEndpoint << " redirected, " << to_string(result); handoff.moved = false; handoff.response = makeRedirectResponse(slot, request, remoteEndpoint.address()); - handoff.keep_alive = false; + handoff.keepAlive = false; return handoff; } } @@ -355,7 +351,7 @@ OverlayImpl::onHandoff( peerFinder_->onClosed(slot); handoff.moved = false; handoff.response = makeErrorResponse(slot, request, remoteEndpoint.address(), e.what()); - handoff.keep_alive = false; + handoff.keepAlive = false; return handoff; } } @@ -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()); } @@ -448,11 +444,11 @@ OverlayImpl::connect(beast::IP::Endpoint const& remoteEndpoint) auto const p = std::make_shared( app_, - io_context_, + ioContext_, beast::IPAddressConversion::toAsioEndpoint(remoteEndpoint), usage, setup_.context, - next_id_++, + nextId_++, slot, app_.getJournal("Peer"), *this); @@ -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,14 +508,15 @@ OverlayImpl::start() app_.config(), serverHandler_.setup().overlay.port(), app_.getValidationPublicKey().has_value(), - setup_.ipLimit); + setup_.ipLimit, + setup_.verifyEndpoints); peerFinder_->setConfig(config); peerFinder_->start(); // Populate our boot cache: if there are no entries in [ips] then we use // the entries in [ips_fixed]. - auto bootstrapIps = app_.config().IPS.empty() ? app_.config().IPS_FIXED : app_.config().IPS; + auto bootstrapIps = app_.config().ips.empty() ? app_.config().ipsFixed : app_.config().ips; // If nothing is specified, default to several well-known high-capacity // servers to serve as bootstrap: @@ -547,7 +544,7 @@ OverlayImpl::start() { if (addr.port() == 0) { - ips.push_back(to_string(addr.atPort(kDEFAULT_PEER_PORT))); + ips.push_back(to_string(addr.atPort(kDefaultPeerPort))); } else { @@ -561,10 +558,10 @@ OverlayImpl::start() }); // Add the ips_fixed from the xrpld.cfg file - if (!app_.config().standalone() && !app_.config().IPS_FIXED.empty()) + if (!app_.config().standalone() && !app_.config().ipsFixed.empty()) { resolver_.resolve( - app_.config().IPS_FIXED, + app_.config().ipsFixed, [this](std::string const& name, std::vector const& addresses) { std::vector ips; ips.reserve(addresses.size()); @@ -573,7 +570,7 @@ OverlayImpl::start() { if (addr.port() == 0) { - ips.emplace_back(addr.address(), kDEFAULT_PEER_PORT); + ips.emplace_back(addr.address(), kDefaultPeerPort); } else { @@ -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::kServerInfo) != 0u) { msg.body()["server"] = getServerInfo(); } - if ((setup_.crawlOptions & CrawlOptions::ServerCounts) != 0u) + if ((setup_.crawlOptions & CrawlOptions::kServerCounts) != 0u) { msg.body()["counts"] = getServerCounts(); } - if ((setup_.crawlOptions & CrawlOptions::Unl) != 0u) + if ((setup_.crawlOptions & CrawlOptions::kUNL) != 0u) { msg.body()["unl"] = getUnlInfo(); } @@ -903,9 +900,9 @@ OverlayImpl::processValidatorList(http_request_type const& req, Handoff& handoff { // If the target is in the form "/vl/", // return the most recent validator list for that key. - constexpr std::string_view kPREFIX("/vl/"); + constexpr std::string_view kPrefix("/vl/"); - if (!req.target().starts_with(kPREFIX) || !setup_.vlEnabled) + if (!req.target().starts_with(kPrefix) || !setup_.vlEnabled) return false; std::uint32_t version = 1; @@ -920,14 +917,14 @@ 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); return true; }; - std::string_view key = req.target().substr(kPREFIX.size()); + std::string_view key = req.target().substr(kPrefix.size()); if (auto slash = key.find('/'); slash != std::string_view::npos) { @@ -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; @@ -1260,7 +1257,7 @@ OverlayImpl::relay( if (!relay) { - if (!app_.config().TX_REDUCE_RELAY_ENABLE) + if (!app_.config().txReduceRelayEnable) return; peers = getActivePeers(toSkip, total, disabled, enabledInSkip); @@ -1273,13 +1270,13 @@ OverlayImpl::relay( auto& txn = tx->get(); auto const sm = std::make_shared(txn, protocol::mtTRANSACTION); peers = getActivePeers(toSkip, total, disabled, enabledInSkip); - auto const minRelay = app_.config().TX_REDUCE_RELAY_MIN_PEERS + disabled; + auto const minRelay = app_.config().txReduceRelayMinPeers + disabled; - if (!app_.config().TX_REDUCE_RELAY_ENABLE || total <= minRelay) + if (!app_.config().txReduceRelayEnable || total <= minRelay) { for (auto const& p : peers) p->send(sm); - if (app_.config().TX_REDUCE_RELAY_ENABLE || app_.config().TX_REDUCE_RELAY_METRICS) + if (app_.config().txReduceRelayEnable || app_.config().txReduceRelayMetrics) txMetrics_.addMetrics(total, toSkip.size(), 0); return; } @@ -1287,8 +1284,8 @@ OverlayImpl::relay( // We have more peers than the minimum (disabled + minimum enabled), // relay to all disabled and some randomly selected enabled that // do not have the transaction. - auto const enabledTarget = app_.config().TX_REDUCE_RELAY_MIN_PEERS + - ((total - minRelay) * app_.config().TX_RELAY_PERCENTAGE / 100); + auto const enabledTarget = app_.config().txReduceRelayMinPeers + + ((total - minRelay) * app_.config().txRelayPercentage / 100); txMetrics_.addMetrics(enabledTarget, toSkip.size(), disabled); @@ -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::kServerInfo; } if (get(section, "counts", false)) { - setup.crawlOptions |= CrawlOptions::ServerCounts; + setup.crawlOptions |= CrawlOptions::kServerCounts; } if (get(section, "unl", true)) { - setup.crawlOptions |= CrawlOptions::Unl; + setup.crawlOptions |= CrawlOptions::kUNL; } } } diff --git a/src/xrpld/overlay/detail/OverlayImpl.h b/src/xrpld/overlay/detail/OverlayImpl.h index 65c93a5845..6fcc2df854 100644 --- a/src/xrpld/overlay/detail/OverlayImpl.h +++ b/src/xrpld/overlay/detail/OverlayImpl.h @@ -80,7 +80,7 @@ private: }; Application& app_; - boost::asio::io_context& io_context_; + boost::asio::io_context& ioContext_; std::optional> work_; boost::asio::strand strand_; mutable std::recursive_mutex mutex_; // VFALCO use std::mutex @@ -96,8 +96,8 @@ private: hash_map, std::weak_ptr> peers_; hash_map> ids_; Resolver& resolver_; - std::atomic next_id_; - int timer_count_{0}; + std::atomic nextId_; + int timerCount_{0}; std::atomic jqTransOverflow_{0}; std::atomic peerDisconnects_{0}; std::atomic peerDisconnectsCharges_{0}; diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp index fa65cb604a..325f8ba038 100644 --- a/src/xrpld/overlay/detail/PeerImp.cpp +++ b/src/xrpld/overlay/detail/PeerImp.cpp @@ -74,7 +74,7 @@ #include #include #include -#include +#include #include @@ -105,13 +105,10 @@ namespace xrpl { namespace { /** The threshold above which we treat a peer connection as high latency */ -std::chrono::milliseconds constexpr kPEER_HIGH_LATENCY{300}; +constexpr std::chrono::milliseconds kPeerHighLatency{300}; /** How often we PING the peer to check for latency and sendq probe */ -std::chrono::seconds constexpr kPEER_TIMER_INTERVAL{60}; - -/** The timeout for a shutdown timer */ -std::chrono::seconds constexpr kSHUTDOWN_TIMER_INTERVAL{5}; +constexpr std::chrono::seconds kPeerTimerInterval{60}; } // namespace @@ -153,27 +150,25 @@ PeerImp::PeerImp( , creationTime_(clock_type::now()) , squelch_(app_.getJournal("Squelch")) , usage_(consumer) - , fee_{.fee = Resource::kFEE_TRIVIAL_PEER, .context = ""} + , fee_{.fee = Resource::kFeeTrivialPeer, .context = ""} , slot_(slot) , request_(std::move(request)) , headers_(request_) , compressionEnabled_( - peerFeatureEnabled(headers_, kFEATURE_COMPR, "lz4", app_.config().COMPRESSION) + peerFeatureEnabled(headers_, kFeatureCompr, "lz4", app_.config().compression) ? Compressed::On : Compressed::Off) , txReduceRelayEnabled_( - peerFeatureEnabled(headers_, kFEATURE_TXRR, app_.config().TX_REDUCE_RELAY_ENABLE)) + peerFeatureEnabled(headers_, kFeatureTxrr, app_.config().txReduceRelayEnable)) , ledgerReplayEnabled_( - peerFeatureEnabled(headers_, kFEATURE_LEDGER_REPLAY, app_.config().LEDGER_REPLAY)) + peerFeatureEnabled(headers_, kFeatureLedgerReplay, app_.config().ledgerReplay)) , ledgerReplayMsgHandler_(app, app.getLedgerReplayer()) { - JLOG(journal_.info()) << "compression enabled " << (compressionEnabled_ == Compressed::On) - << " vp reduce-relay base squelch enabled " - << peerFeatureEnabled( - headers_, - kFEATURE_VPRR, - app_.config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE) - << " tx reduce-relay enabled " << txReduceRelayEnabled_; + JLOG(journal_.info()) + << "compression enabled " << (compressionEnabled_ == Compressed::On) + << " vp reduce-relay base squelch enabled " + << peerFeatureEnabled(headers_, kFeatureVprr, app_.config().vpReduceRelayBaseSquelchEnable) + << " tx reduce-relay enabled " << txReduceRelayEnabled_; } PeerImp::~PeerImp() @@ -193,7 +188,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 +207,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; }; @@ -272,13 +267,7 @@ PeerImp::stop() if (!socket_.is_open()) return; - // The rationale for using different severity levels is that - // outbound connections are under our control and may be logged - // at a higher level, but inbound connections are more numerous and - // uncontrolled so to prevent log flooding the severity is reduced. - JLOG(journal_.debug()) << "stop: Stop"; - - shutdown(); + close(); } //------------------------------------------------------------------------------ @@ -291,17 +280,13 @@ PeerImp::send(std::shared_ptr const& m) post(strand_, std::bind(&PeerImp::send, shared_from_this(), m)); return; } - + if (gracefulClose_) + return; + if (detaching_) + return; if (!socket_.is_open()) return; - // we are in progress of closing the connection - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - auto validator = m->getValidatorKey(); if (validator && !squelch_.expireSquelch(*validator)) { @@ -322,14 +307,14 @@ PeerImp::send(std::shared_ptr const& m) auto sendqSize = sendQueue_.size(); - if (sendqSize < Tuning::TargetSendQueue) + if (sendqSize < Tuning::kTargetSendQueue) { // 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::kSendQueueLogFreq) == 0) { std::string const n = name(); sink << n << " sendq: " << sendqSize; @@ -340,7 +325,6 @@ PeerImp::send(std::shared_ptr const& m) if (sendqSize != 0) return; - writePending_ = true; boost::asio::async_write( stream_, boost::asio::buffer(sendQueue_.front()->getBuffer(compressionEnabled_)), @@ -382,7 +366,7 @@ PeerImp::addTxQueue(uint256 const& hash) return; } - if (txQueue_.size() == reduce_relay::kMAX_TX_QUEUE_SIZE) + if (txQueue_.size() == reduce_relay::kMaxTxQueueSize) { JLOG(pJournal_.warn()) << "addTxQueue exceeds the cap"; sendTxQueue(); @@ -445,7 +429,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(); @@ -515,7 +499,7 @@ PeerImp::json() lastStatus = lastStatus_; } - if (closedLedgerHash != beast::kZERO) + if (closedLedgerHash != beast::kZero) ret[jss::ledger] = to_string(closedLedgerHash); if (lastStatus.has_newstatus()) @@ -547,7 +531,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()); @@ -623,16 +607,20 @@ PeerImp::hasRange(std::uint32_t uMin, std::uint32_t uMax) //------------------------------------------------------------------------------ void -PeerImp::fail(std::string const& name, error_code ec) +PeerImp::close() { - XRPL_ASSERT(strand_.running_in_this_thread(), "xrpl::PeerImp::fail : strand in this thread"); - + XRPL_ASSERT(strand_.running_in_this_thread(), "xrpl::PeerImp::close : strand in this thread"); if (!socket_.is_open()) return; - JLOG(journal_.warn()) << name << ": " << ec.message(); + detaching_ = true; // DEPRECATED - shutdown(); + cancelTimer(); + error_code ec; + socket_.close(ec); // NOLINT(bugprone-unused-return-value) + + overlay_.incPeerDisconnect(); + JLOG((inbound_ ? journal_.debug() : journal_.info())) << "close: Closed"; } void @@ -646,123 +634,71 @@ PeerImp::fail(std::string const& reason) (void (Peer::*)(std::string const&))&PeerImp::fail, shared_from_this(), reason)); return; } - - if (!socket_.is_open()) - 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) && socket_.is_open()) { std::string const n = name(); JLOG(journal_.warn()) << n << " failed: " << reason; } - - shutdown(); + close(); } void -PeerImp::tryAsyncShutdown() +PeerImp::fail(std::string const& name, error_code ec) { - XRPL_ASSERT( - strand_.running_in_this_thread(), - "xrpl::PeerImp::tryAsyncShutdown : strand in this thread"); - - if (!shutdown_ || shutdownStarted_) + XRPL_ASSERT(strand_.running_in_this_thread(), "xrpl::PeerImp::fail : strand in this thread"); + if (!socket_.is_open()) return; - if (readPending_ || writePending_) - return; - - shutdownStarted_ = true; - - setTimer(kSHUTDOWN_TIMER_INTERVAL); - - // gracefully shutdown the SSL socket, performing a shutdown handshake - stream_.async_shutdown(bind_executor( - strand_, std::bind(&PeerImp::onShutdown, shared_from_this(), std::placeholders::_1))); -} - -void -PeerImp::shutdown() -{ - XRPL_ASSERT(strand_.running_in_this_thread(), "xrpl::PeerImp::shutdown: strand in this thread"); - - if (!socket_.is_open() || shutdown_) - return; - - shutdown_ = true; - - boost::beast::get_lowest_layer(stream_).cancel(); - - tryAsyncShutdown(); -} - -void -PeerImp::onShutdown(error_code ec) -{ - cancelTimer(); - if (ec) - { - // - eof: the stream was cleanly closed - // - operation_aborted: an expired timer (slow shutdown) - // - stream_truncated: the tcp connection closed (no handshake) it could - // occur if a peer does not perform a graceful disconnect - // - broken_pipe: the peer is gone - bool const shouldLog = - (ec != boost::asio::error::eof && ec != boost::asio::error::operation_aborted && - ec.message().find("application data after close notify") == std::string::npos); - - if (shouldLog) - { - JLOG(journal_.debug()) << "onShutdown: " << ec.message(); - } - } + JLOG(journal_.warn()) << name << ": " << ec.message(); close(); } void -PeerImp::close() +PeerImp::gracefulClose() { - XRPL_ASSERT(strand_.running_in_this_thread(), "xrpl::PeerImp::close : strand in this thread"); - - if (!socket_.is_open()) + XRPL_ASSERT( + strand_.running_in_this_thread(), "xrpl::PeerImp::gracefulClose : strand in this thread"); + XRPL_ASSERT(socket_.is_open(), "xrpl::PeerImp::gracefulClose : socket is open"); + XRPL_ASSERT(!gracefulClose_, "xrpl::PeerImp::gracefulClose : socket is not closing"); + gracefulClose_ = true; + if (!sendQueue_.empty()) return; - - cancelTimer(); - - error_code ec; - socket_.close(ec); // NOLINT(bugprone-unused-return-value) - - overlay_.incPeerDisconnect(); - - // The rationale for using different severity levels is that - // outbound connections are under our control and may be logged - // at a higher level, but inbound connections are more numerous and - // uncontrolled so to prevent log flooding the severity is reduced. - JLOG((inbound_ ? journal_.debug() : journal_.info())) << "close: Closed"; + setTimer(); + stream_.async_shutdown(bind_executor( + strand_, std::bind(&PeerImp::onShutdown, shared_from_this(), std::placeholders::_1))); } -//------------------------------------------------------------------------------ - void -PeerImp::setTimer(std::chrono::seconds interval) +PeerImp::setTimer() { try { - timer_.expires_after(interval); + timer_.expires_after(kPeerTimerInterval); } - catch (std::exception const& ex) + catch (boost::system::system_error const& e) { - JLOG(journal_.error()) << "setTimer: " << ex.what(); - shutdown(); + JLOG(journal_.error()) << "setTimer: " << e.code(); return; } - timer_.async_wait(bind_executor( strand_, std::bind(&PeerImp::onTimer, shared_from_this(), std::placeholders::_1))); } +// convenience for ignoring the error code +void +PeerImp::cancelTimer() noexcept +{ + try + { + timer_.cancel(); + } + catch (boost::system::system_error const&) // NOLINT(bugprone-empty-catch) + { + // ignored + } +} + //------------------------------------------------------------------------------ std::string @@ -776,14 +712,11 @@ PeerImp::makePrefix(std::string const& fingerprint) void PeerImp::onTimer(error_code const& ec) { - XRPL_ASSERT(strand_.running_in_this_thread(), "xrpl::PeerImp::onTimer : strand in this thread"); - if (!socket_.is_open()) return; if (ec) { - // do not initiate shutdown, timers are frequently cancelled if (ec == boost::asio::error::operation_aborted) return; @@ -793,16 +726,7 @@ PeerImp::onTimer(error_code const& ec) return; } - // the timer expired before the shutdown completed - // force close the connection - if (shutdown_) - { - JLOG(journal_.debug()) << "onTimer: shutdown timer expired"; - close(); - return; - } - - if (largeSendq_++ >= Tuning::SendqIntervals) + if (largeSendq_++ >= Tuning::kSendqIntervals) { fail("Large send queue"); return; @@ -817,8 +741,8 @@ PeerImp::onTimer(error_code const& ec) duration = clock_type::now() - trackingTime_; } - if ((t == Tracking::Diverged && (duration > app_.config().MAX_DIVERGED_TIME)) || - (t == Tracking::Unknown && (duration > app_.config().MAX_UNKNOWN_TIME))) + if ((t == Tracking::Diverged && (duration > app_.config().maxDivergedTime)) || + (t == Tracking::Unknown && (duration > app_.config().maxUnknownTime))) { overlay_.peerFinder().onFailure(slot_); fail("Not useful"); @@ -842,20 +766,32 @@ PeerImp::onTimer(error_code const& ec) send(std::make_shared(message, protocol::mtPING)); - setTimer(kPEER_TIMER_INTERVAL); + setTimer(); } void -PeerImp::cancelTimer() noexcept +PeerImp::onShutdown(error_code ec) { - try + cancelTimer(); + + if (ec) { - timer_.cancel(); - } - catch (std::exception const& ex) - { - JLOG(journal_.error()) << "cancelTimer: " << ex.what(); + // - eof: the stream was cleanly closed + // - operation_aborted: an expired timer (slow shutdown) + // - stream_truncated: the tcp connection closed (no handshake) it could + // occur if a peer does not perform a graceful disconnect + // - broken_pipe: the peer is gone + bool const shouldLog = + (ec != boost::asio::error::eof && ec != boost::asio::error::operation_aborted && + ec.message().find("application data after close notify") == std::string::npos); + + if (shouldLog) + { + JLOG(journal_.debug()) << "onShutdown: " << ec.message(); + } } + + close(); } //------------------------------------------------------------------------------ @@ -864,15 +800,6 @@ PeerImp::doAccept() { XRPL_ASSERT(readBuffer_.size() == 0, "xrpl::PeerImp::doAccept : empty read buffer"); - JLOG(journal_.debug()) << "doAccept"; - - // a shutdown was initiated before the handshake, there is nothing to do - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - auto const sharedValue = makeSharedValue(*streamPtr_, journal_); // This shouldn't fail since we already computed @@ -883,7 +810,7 @@ PeerImp::doAccept() return; } - JLOG(journal_.debug()) << "Protocol: " << to_string(protocol_); + JLOG(journal_.info()) << "Protocol: " << to_string(protocol_); if (auto member = app_.getCluster().member(publicKey_)) { @@ -923,16 +850,15 @@ PeerImp::doAccept() error_code ec, std::size_t bytesTransferred) { if (!socket_.is_open()) return; - if (ec == boost::asio::error::operation_aborted) - { - tryAsyncShutdown(); - return; - } if (ec) { + if (ec == boost::asio::error::operation_aborted) + return; + fail("onWriteResponse", ec); return; } + if (writeBuffer->size() == bytesTransferred) { doProtocolStart(); @@ -963,13 +889,6 @@ PeerImp::domain() const void PeerImp::doProtocolStart() { - // a shutdown was initiated before the handshare, there is nothing to do - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - onReadMessage(error_code(), 0); // Send all the validator lists that have been loaded @@ -1001,45 +920,31 @@ PeerImp::doProtocolStart() if (auto m = overlay_.getManifestsMessage()) send(m); - setTimer(kPEER_TIMER_INTERVAL); + setTimer(); } // Called repeatedly with protocol message data void PeerImp::onReadMessage(error_code ec, std::size_t bytesTransferred) { - XRPL_ASSERT( - strand_.running_in_this_thread(), "xrpl::PeerImp::onReadMessage : strand in this thread"); - - readPending_ = false; - if (!socket_.is_open()) return; if (ec) { + if (ec == boost::asio::error::operation_aborted) + return; + if (ec == boost::asio::error::eof) { - JLOG(journal_.debug()) << "EOF"; - shutdown(); - return; - } - - if (ec == boost::asio::error::operation_aborted) - { - tryAsyncShutdown(); + JLOG(journal_.info()) << "EOF"; + gracefulClose(); return; } fail("onReadMessage", ec); return; } - // we started shutdown, no reason to process further data - if (shutdown_) - { - tryAsyncShutdown(); - return; - } if (auto stream = journal_.trace()) { @@ -1051,7 +956,7 @@ PeerImp::onReadMessage(error_code ec, std::size_t bytesTransferred) readBuffer_.commit(bytesTransferred); - auto hint = Tuning::kREAD_BUFFER_BYTES; + auto hint = Tuning::kReadBufferBytes; while (readBuffer_.size() > 0) { @@ -1064,37 +969,26 @@ PeerImp::onReadMessage(error_code ec, std::size_t bytesTransferred) 350ms, journal_); - if (!socket_.is_open()) - return; - - // the error_code is produced by invokeProtocolMessage - // it could be due to a bad message if (ec) { fail("onReadMessage", ec); return; } + if (!socket_.is_open()) + return; + + if (gracefulClose_) + return; + if (bytesConsumed == 0) break; - readBuffer_.consume(bytesConsumed); } - // check if a shutdown was initiated while processing messages - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - - readPending_ = true; - - XRPL_ASSERT(!shutdownStarted_, "xrpl::PeerImp::onReadMessage : shutdown started"); - // Timeout on writes only stream_.async_read_some( - readBuffer_.prepare(std::max(Tuning::kREAD_BUFFER_BYTES, hint)), + readBuffer_.prepare(std::max(Tuning::kReadBufferBytes, hint)), bind_executor( strand_, std::bind( @@ -1107,26 +1001,17 @@ PeerImp::onReadMessage(error_code ec, std::size_t bytesTransferred) void PeerImp::onWriteMessage(error_code ec, std::size_t bytesTransferred) { - XRPL_ASSERT( - strand_.running_in_this_thread(), "xrpl::PeerImp::onWriteMessage : strand in this thread"); - - writePending_ = false; - if (!socket_.is_open()) return; if (ec) { if (ec == boost::asio::error::operation_aborted) - { - tryAsyncShutdown(); return; - } fail("onWriteMessage", ec); return; } - if (auto stream = journal_.trace()) { stream << "onWriteMessage: " @@ -1137,18 +1022,8 @@ PeerImp::onWriteMessage(error_code ec, std::size_t bytesTransferred) XRPL_ASSERT(!sendQueue_.empty(), "xrpl::PeerImp::onWriteMessage : non-empty send buffer"); sendQueue_.pop(); - - if (shutdown_) - { - tryAsyncShutdown(); - return; - } - if (!sendQueue_.empty()) { - writePending_ = true; - XRPL_ASSERT(!shutdownStarted_, "xrpl::PeerImp::onWriteMessage : shutdown started"); - // Timeout on writes only boost::asio::async_write( stream_, @@ -1162,6 +1037,13 @@ PeerImp::onWriteMessage(error_code ec, std::size_t bytesTransferred) std::placeholders::_2))); return; } + + if (gracefulClose_) + { + stream_.async_shutdown(bind_executor( + strand_, std::bind(&PeerImp::onShutdown, shared_from_this(), std::placeholders::_1))); + return; + } } //------------------------------------------------------------------------------ @@ -1186,7 +1068,7 @@ PeerImp::onMessageBegin( { auto const name = protocolMessageName(type); loadEvent_ = app_.getJobQueue().makeLoadEvent(JtPeer, name); - fee_ = {.fee = Resource::kFEE_TRIVIAL_PEER, .context = name}; + fee_ = {.fee = Resource::kFeeTrivialPeer, .context = name}; auto const category = TrafficCount::categorize(*m, static_cast(type), true); @@ -1208,7 +1090,7 @@ PeerImp::onMessageBegin( // LEDGER_DATA category == TrafficCount::Category::GlTscShare || category == TrafficCount::Category::GlTscGet) && - (txReduceRelayEnabled() || app_.config().TX_REDUCE_RELAY_METRICS)) + (txReduceRelayEnabled() || app_.config().txReduceRelayMetrics)) { overlay_.addTxMetrics(static_cast(type), static_cast(size)); } @@ -1230,12 +1112,12 @@ PeerImp::onMessage(std::shared_ptr const& m) if (s == 0) { - fee_.update(Resource::kFEE_USELESS_DATA, "empty"); + fee_.update(Resource::kFeeUselessData, "empty"); return; } if (s > 100) - fee_.update(Resource::kFEE_MODERATE_BURDEN_PEER, "oversize"); + fee_.update(Resource::kFeeModerateBurdenPeer, "oversize"); app_.getJobQueue().addJob(JtManifest, "RcvManifests", [this, that = shared_from_this(), m]() { overlay_.onManifests(m, that); @@ -1248,7 +1130,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (m->type() == protocol::TMPing::ptPING) { // We have received a ping request, reply with a pong - fee_.update(Resource::kFEE_MODERATE_BURDEN_PEER, "ping request"); + fee_.update(Resource::kFeeModerateBurdenPeer, "ping request"); m->set_type(protocol::TMPing::ptPONG); send(std::make_shared(*m, protocol::mtPING)); return; @@ -1289,7 +1171,7 @@ PeerImp::onMessage(std::shared_ptr const& m) // VFALCO NOTE I think we should drop the peer immediately if (!cluster()) { - fee_.update(Resource::kFEE_USELESS_DATA, "unknown cluster"); + fee_.update(Resource::kFeeUselessData, "unknown cluster"); return; } @@ -1364,7 +1246,7 @@ PeerImp::onMessage(std::shared_ptr const& m) // implication for the protocol. if (m->endpoints_v2().size() >= 1024) { - fee_.update(Resource::kFEE_USELESS_DATA, "endpoints too large"); + fee_.update(Resource::kFeeUselessData, "endpoints too large"); return; } @@ -1401,7 +1283,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (malformed > 0) { fee_.update( - Resource::kFEE_INVALID_DATA * malformed, + Resource::kFeeInvalidData * malformed, std::to_string(malformed) + " malformed endpoints"); } @@ -1462,20 +1344,20 @@ PeerImp::handleTransaction( { JLOG(pJournal_.warn()) << "Ignoring Network relayed Tx containing " "tfInnerBatchTxn (handleTransaction)."; - fee_.update(Resource::kFEE_MODERATE_BURDEN_PEER, "inner batch txn"); + fee_.update(Resource::kFeeModerateBurdenPeer, "inner batch txn"); return; } // LCOV_EXCL_STOP HashRouterFlags flags = HashRouterFlags::UNDEFINED; - constexpr std::chrono::seconds kTX_INTERVAL = 10s; + static constexpr std::chrono::seconds kTxInterval = 10s; - if (!app_.getHashRouter().shouldProcess(txID, id_, flags, kTX_INTERVAL)) + if (!app_.getHashRouter().shouldProcess(txID, id_, flags, kTxInterval)) { // we have seen this transaction recently if (any(flags & HashRouterFlags::BAD)) { - fee_.update(Resource::kFEE_USELESS_DATA, "known bad"); + fee_.update(Resource::kFeeUselessData, "known bad"); JLOG(pJournal_.debug()) << "Ignoring known bad tx " << txID; } @@ -1518,7 +1400,7 @@ PeerImp::handleTransaction( { JLOG(pJournal_.trace()) << "No new transactions until synchronized"; } - else if (app_.getJobQueue().getJobCount(JtTransaction) > app_.config().MAX_TRANSACTIONS) + else if (app_.getJobQueue().getJobCount(JtTransaction) > app_.config().maxTransactions) { overlay_.incJqTransOverflow(); JLOG(pJournal_.info()) << "Transaction queue is full"; @@ -1549,7 +1431,7 @@ void PeerImp::onMessage(std::shared_ptr const& m) { auto badData = [&](std::string const& msg) { - fee_.update(Resource::kFEE_INVALID_DATA, "get_ledger " + msg); + fee_.update(Resource::kFeeInvalidData, "get_ledger " + msg); JLOG(pJournal_.warn()) << "TMGetLedger: " << msg; }; auto const itype{m->itype()}; @@ -1590,7 +1472,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 +1522,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::kMaxQueryDepth || itype == protocol::liBASE) { badData("Invalid query depth"); return; @@ -1661,11 +1543,11 @@ PeerImp::onMessage(std::shared_ptr const& m) JLOG(pJournal_.trace()) << "onMessage, TMProofPathRequest"; if (!ledgerReplayEnabled_) { - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "proof_path_request disabled"); + fee_.update(Resource::kFeeMalformedRequest, "proof_path_request disabled"); return; } - fee_.update(Resource::kFEE_MODERATE_BURDEN_PEER, "received a proof path request"); + fee_.update(Resource::kFeeModerateBurdenPeer, "received a proof path request"); std::weak_ptr const weak = shared_from_this(); app_.getJobQueue().addJob(JtReplayReq, "RcvProofPReq", [weak, m]() { if (auto peer = weak.lock()) @@ -1675,11 +1557,11 @@ PeerImp::onMessage(std::shared_ptr const& m) { if (reply.error() == protocol::TMReplyError::reBAD_REQUEST) { - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "proof_path_request"); + peer->charge(Resource::kFeeMalformedRequest, "proof_path_request"); } else { - peer->charge(Resource::kFEE_REQUEST_NO_REPLY, "proof_path_request"); + peer->charge(Resource::kFeeRequestNoReply, "proof_path_request"); } } else @@ -1695,13 +1577,13 @@ PeerImp::onMessage(std::shared_ptr const& m) { if (!ledgerReplayEnabled_) { - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "proof_path_response disabled"); + fee_.update(Resource::kFeeMalformedRequest, "proof_path_response disabled"); return; } if (!ledgerReplayMsgHandler_.processProofPathResponse(m)) { - fee_.update(Resource::kFEE_INVALID_DATA, "proof_path_response"); + fee_.update(Resource::kFeeInvalidData, "proof_path_response"); } } @@ -1711,11 +1593,11 @@ PeerImp::onMessage(std::shared_ptr const& m) JLOG(pJournal_.trace()) << "onMessage, TMReplayDeltaRequest"; if (!ledgerReplayEnabled_) { - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "replay_delta_request disabled"); + fee_.update(Resource::kFeeMalformedRequest, "replay_delta_request disabled"); return; } - fee_.fee = Resource::kFEE_MODERATE_BURDEN_PEER; + fee_.fee = Resource::kFeeModerateBurdenPeer; std::weak_ptr const weak = shared_from_this(); app_.getJobQueue().addJob(JtReplayReq, "RcvReplDReq", [weak, m]() { if (auto peer = weak.lock()) @@ -1725,11 +1607,11 @@ PeerImp::onMessage(std::shared_ptr const& m) { if (reply.error() == protocol::TMReplyError::reBAD_REQUEST) { - peer->charge(Resource::kFEE_MALFORMED_REQUEST, "replay_delta_request"); + peer->charge(Resource::kFeeMalformedRequest, "replay_delta_request"); } else { - peer->charge(Resource::kFEE_REQUEST_NO_REPLY, "replay_delta_request"); + peer->charge(Resource::kFeeRequestNoReply, "replay_delta_request"); } } else @@ -1745,13 +1627,13 @@ PeerImp::onMessage(std::shared_ptr const& m) { if (!ledgerReplayEnabled_) { - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "replay_delta_response disabled"); + fee_.update(Resource::kFeeMalformedRequest, "replay_delta_response disabled"); return; } if (!ledgerReplayMsgHandler_.processReplayDeltaResponse(m)) { - fee_.update(Resource::kFEE_INVALID_DATA, "replay_delta_response"); + fee_.update(Resource::kFeeInvalidData, "replay_delta_response"); } } @@ -1759,12 +1641,12 @@ void PeerImp::onMessage(std::shared_ptr const& m) { auto badData = [&](std::string const& msg) { - fee_.update(Resource::kFEE_INVALID_DATA, msg); + fee_.update(Resource::kFeeInvalidData, msg); JLOG(pJournal_.warn()) << "TMLedgerData: " << msg; }; // Verify ledger hash - if (!stringIsUint256Sized(m->ledgerhash())) + if (!stringIsUInt256Sized(m->ledgerhash())) { badData("Invalid ledger hash"); return; @@ -1810,7 +1692,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::kHardMaxReplyNodes) { badData("Invalid Ledger/TXset nodes " + std::to_string(m->nodes_size())); return; @@ -1831,7 +1713,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) @@ -1863,14 +1745,14 @@ PeerImp::onMessage(std::shared_ptr const& m) (publicKeyType(makeSlice(set.nodepubkey())) != KeyType::Secp256k1)) { JLOG(pJournal_.warn()) << "Proposal: malformed"; - fee_.update(Resource::kFEE_INVALID_SIGNATURE, " signature can't be longer than 72 bytes"); + fee_.update(Resource::kFeeInvalidSignature, " signature can't be longer than 72 bytes"); 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"); + fee_.update(Resource::kFeeMalformedRequest, "bad hashes"); return; } @@ -1889,12 +1771,12 @@ PeerImp::onMessage(std::shared_ptr const& m) overlay_.reportInboundTraffic( TrafficCount::Category::ProposalUntrusted, Message::messageSize(*m)); - if (app_.config().RELAY_UNTRUSTED_PROPOSALS == -1) + if (app_.config().relayUntrustedProposals == -1) 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()}}; @@ -1906,7 +1788,7 @@ PeerImp::onMessage(std::shared_ptr const& m) { // Count unique messages (Slots has it's own 'HashRouter'), which a peer // receives within IDLED seconds since the message has been relayed. - if (relayed && (stopwatch().now() - *relayed) < reduce_relay::kIDLED) + if (relayed && (stopwatch().now() - *relayed) < reduce_relay::kIdled) overlay_.updateSlotAndSquelch(suppression, publicKey, id_, protocol::mtPROPOSE_LEDGER); // report duplicate proposal messages @@ -2001,7 +1883,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 +1900,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 +1937,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 +2034,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::kConvergedLedgerLimit) { // 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::kDivergedLedgerLimit) && (tracking_.load() != Tracking::Diverged)) { // The peer's ledger sequence is way off the validation's std::scoped_lock const sl(recentLock_); @@ -2171,13 +2053,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"); + fee_.update(Resource::kFeeMalformedRequest, "bad hash"); return; } - uint256 const hash{m->hash()}; + uint256 const hash = uint256::fromRaw(m->hash()); if (m->status() == protocol::tsHAVE) { @@ -2185,7 +2067,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (std::ranges::find(recentTxSets_, hash) != recentTxSets_.end()) { - fee_.update(Resource::kFEE_USELESS_DATA, "duplicate (tsHAVE)"); + fee_.update(Resource::kFeeUselessData, "duplicate (tsHAVE)"); return; } @@ -2206,7 +2088,7 @@ PeerImp::onValidatorListMessage( { JLOG(pJournal_.warn()) << "Ignored malformed " << messageType; // This shouldn't ever happen with a well-behaved peer - fee_.update(Resource::kFEE_HEAVY_BURDEN_PEER, "no blobs"); + fee_.update(Resource::kFeeHeavyBurdenPeer, "no blobs"); return; } @@ -2220,7 +2102,7 @@ PeerImp::onValidatorListMessage( // Charging this fee here won't hurt the peer in the normal // course of operation (ie. refresh every 5 minutes), but // will add up if the peer is misbehaving. - fee_.update(Resource::kFEE_USELESS_DATA, "duplicate"); + fee_.update(Resource::kFeeUselessData, "duplicate"); return; } @@ -2310,28 +2192,27 @@ PeerImp::onValidatorListMessage( // Charging this fee here won't hurt the peer in the normal // course of operation (ie. refresh every 5 minutes), but // will add up if the peer is misbehaving. - fee_.update( - Resource::kFEE_USELESS_DATA, " duplicate (same_sequence or known_sequence)"); + fee_.update(Resource::kFeeUselessData, " duplicate (same_sequence or known_sequence)"); break; case ListDisposition::Stale: // There are very few good reasons for a peer to send an // old list, particularly more than once. - fee_.update(Resource::kFEE_INVALID_DATA, "expired"); + fee_.update(Resource::kFeeInvalidData, "expired"); break; case ListDisposition::Untrusted: // Charging this fee here won't hurt the peer in the normal // course of operation (ie. refresh every 5 minutes), but // will add up if the peer is misbehaving. - fee_.update(Resource::kFEE_USELESS_DATA, "untrusted"); + fee_.update(Resource::kFeeUselessData, "untrusted"); break; case ListDisposition::Invalid: // This shouldn't ever happen with a well-behaved peer - fee_.update(Resource::kFEE_INVALID_SIGNATURE, "invalid list disposition"); + fee_.update(Resource::kFeeInvalidSignature, "invalid list disposition"); break; case ListDisposition::UnsupportedVersion: // During a version transition, this may be legitimate. // If it happens frequently, that's probably bad. - fee_.update(Resource::kFEE_INVALID_DATA, "version"); + fee_.update(Resource::kFeeInvalidData, "version"); break; // LCOV_EXCL_START default: @@ -2399,7 +2280,7 @@ PeerImp::onMessage(std::shared_ptr const& m) JLOG(pJournal_.debug()) << "ValidatorList: received validator list from peer using " << "protocol version " << to_string(protocol_) << " which shouldn't support this feature."; - fee_.update(Resource::kFEE_USELESS_DATA, "unsupported peer"); + fee_.update(Resource::kFeeUselessData, "unsupported peer"); return; } onValidatorListMessage( @@ -2409,7 +2290,7 @@ PeerImp::onMessage(std::shared_ptr const& m) { JLOG(pJournal_.warn()) << "ValidatorList: Exception, " << e.what(); using namespace std::string_literals; - fee_.update(Resource::kFEE_INVALID_DATA, e.what()); + fee_.update(Resource::kFeeInvalidData, e.what()); } } @@ -2423,7 +2304,7 @@ PeerImp::onMessage(std::shared_ptr const& m JLOG(pJournal_.debug()) << "ValidatorListCollection: received validator list from peer " << "using protocol version " << to_string(protocol_) << " which shouldn't support this feature."; - fee_.update(Resource::kFEE_USELESS_DATA, "unsupported peer"); + fee_.update(Resource::kFeeUselessData, "unsupported peer"); return; } if (m->version() < 2) @@ -2432,7 +2313,7 @@ PeerImp::onMessage(std::shared_ptr const& m << "ValidatorListCollection: received invalid validator list " "version " << m->version() << " from peer using protocol version " << to_string(protocol_); - fee_.update(Resource::kFEE_INVALID_DATA, "wrong version"); + fee_.update(Resource::kFeeInvalidData, "wrong version"); return; } onValidatorListMessage( @@ -2442,7 +2323,7 @@ PeerImp::onMessage(std::shared_ptr const& m { JLOG(pJournal_.warn()) << "ValidatorListCollection: Exception, " << e.what(); using namespace std::string_literals; - fee_.update(Resource::kFEE_INVALID_DATA, e.what()); + fee_.update(Resource::kFeeInvalidData, e.what()); } } @@ -2452,7 +2333,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (m->validation().size() < 50) { JLOG(pJournal_.warn()) << "Validation: Too small"; - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "too small"); + fee_.update(Resource::kFeeMalformedRequest, "too small"); return; } @@ -2479,7 +2360,7 @@ PeerImp::onMessage(std::shared_ptr const& m) val->getSeenTime())) { JLOG(pJournal_.trace()) << "Validation: Not current"; - fee_.update(Resource::kFEE_USELESS_DATA, "not current"); + fee_.update(Resource::kFeeUselessData, "not current"); return; } @@ -2497,7 +2378,7 @@ PeerImp::onMessage(std::shared_ptr const& m) overlay_.reportInboundTraffic( TrafficCount::Category::ValidationUntrusted, Message::messageSize(*m)); - if (app_.config().RELAY_UNTRUSTED_VALIDATIONS == -1) + if (app_.config().relayUntrustedValidations == -1) return; } @@ -2510,7 +2391,7 @@ PeerImp::onMessage(std::shared_ptr const& m) // Count unique messages (Slots has it's own 'HashRouter'), which a // peer receives within IDLED seconds since the message has been // relayed. - if (relayed && (stopwatch().now() - *relayed) < reduce_relay::kIDLED) + if (relayed && (stopwatch().now() - *relayed) < reduce_relay::kIdled) { overlay_.updateSlotAndSquelch( key, val->getSignerPublic(), id_, protocol::mtVALIDATION); @@ -2548,7 +2429,7 @@ PeerImp::onMessage(std::shared_ptr const& m) { JLOG(pJournal_.warn()) << "Exception processing validation: " << e.what(); using namespace std::string_literals; - fee_.update(Resource::kFEE_MALFORMED_REQUEST, e.what()); + fee_.update(Resource::kFeeMalformedRequest, e.what()); } } @@ -2563,7 +2444,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (packet.query()) { // this is a query - if (sendQueue_.size() >= Tuning::DropSendQueue) + if (sendQueue_.size() >= Tuning::kDropSendQueue) { JLOG(pJournal_.debug()) << "GetObject: Large send queue"; return; @@ -2580,7 +2461,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (!txReduceRelayEnabled()) { JLOG(pJournal_.error()) << "TMGetObjectByHash: tx reduce-relay is disabled"; - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "disabled"); + fee_.update(Resource::kFeeMalformedRequest, "disabled"); return; } @@ -2600,24 +2481,24 @@ 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"); + fee_.update(Resource::kFeeMalformedRequest, "ledger hash"); return; } reply.set_ledgerhash(packet.ledgerhash()); } - fee_.update(Resource::kFEE_MODERATE_BURDEN_PEER, " received a get object by hash request"); + fee_.update(Resource::kFeeModerateBurdenPeer, " received a get object by hash request"); // This is a very minimal implementation 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,10 +2516,10 @@ 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::kHardMaxReplyNodes) { fee_.update( - Resource::kFEE_MODERATE_BURDEN_PEER, + Resource::kFeeModerateBurdenPeer, "Reply limit reached. Truncating reply."); break; } @@ -2661,7 +2542,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 +2568,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())); @@ -2710,7 +2591,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (!txReduceRelayEnabled()) { JLOG(pJournal_.error()) << "TMHaveTransactions: tx reduce-relay is disabled"; - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "disabled"); + fee_.update(Resource::kFeeMalformedRequest, "disabled"); return; } @@ -2732,14 +2613,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"); + fee_.update(Resource::kFeeMalformedRequest, "hash size"); return; } - uint256 hash(m->hashes(i)); + uint256 hash = uint256::fromRaw(m->hashes(i)); auto txn = app_.getMasterTransaction().fetchFromCache(hash); @@ -2773,7 +2654,7 @@ PeerImp::onMessage(std::shared_ptr const& m) if (!txReduceRelayEnabled()) { JLOG(pJournal_.error()) << "TMTransactions: tx reduce-relay is disabled"; - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "disabled"); + fee_.update(Resource::kFeeMalformedRequest, "disabled"); return; } @@ -2803,14 +2684,14 @@ PeerImp::onMessage(std::shared_ptr const& m) if (!m->has_validatorpubkey()) { - fee_.update(Resource::kFEE_INVALID_DATA, "squelch no pubkey"); + fee_.update(Resource::kFeeInvalidData, "squelch no pubkey"); return; } auto validator = m->validatorpubkey(); auto const slice{makeSlice(validator)}; if (!publicKeyType(slice)) { - fee_.update(Resource::kFEE_INVALID_DATA, "squelch bad pubkey"); + fee_.update(Resource::kFeeInvalidData, "squelch bad pubkey"); return; } PublicKey const key(slice); @@ -2829,7 +2710,7 @@ PeerImp::onMessage(std::shared_ptr const& m) } else if (!squelch_.addSquelch(key, std::chrono::seconds{duration})) { - fee_.update(Resource::kFEE_INVALID_DATA, "squelch duration"); + fee_.update(Resource::kFeeInvalidData, "squelch duration"); } JLOG(pJournal_.debug()) << "onMessage: TMSquelch " << slice << " " << id() << " " << duration; @@ -2864,16 +2745,16 @@ 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"); + fee_.update(Resource::kFeeMalformedRequest, "hash size"); return; } - fee_.fee = Resource::kFEE_HEAVY_BURDEN_PEER; + fee_.fee = Resource::kFeeHeavyBurdenPeer; - uint256 const hash{packet->ledgerhash()}; + uint256 const hash = uint256::fromRaw(packet->ledgerhash()); std::weak_ptr const weak = shared_from_this(); auto elapsed = UptimeClock::now(); @@ -2891,10 +2772,10 @@ PeerImp::doTransactions(std::shared_ptr const& pack JLOG(pJournal_.trace()) << "received TMGetObjectByHash requesting tx " << packet->objects_size(); - if (packet->objects_size() > reduce_relay::kMAX_TX_QUEUE_SIZE) + if (packet->objects_size() > reduce_relay::kMaxTxQueueSize) { JLOG(pJournal_.error()) << "doTransactions, invalid number of hashes"; - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "too big"); + fee_.update(Resource::kFeeMalformedRequest, "too big"); return; } @@ -2902,13 +2783,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"); + fee_.update(Resource::kFeeMalformedRequest, "hash size"); return; } - uint256 hash(obj.hash()); + uint256 hash = uint256::fromRaw(obj.hash()); auto txn = app_.getMasterTransaction().fetchFromCache(hash); @@ -2916,7 +2797,7 @@ PeerImp::doTransactions(std::shared_ptr const& pack { JLOG(pJournal_.error()) << "doTransactions, transaction not found " << Slice(hash.data(), hash.size()); - fee_.update(Resource::kFEE_MALFORMED_REQUEST, "tx not found"); + fee_.update(Resource::kFeeMalformedRequest, "tx not found"); return; } @@ -2967,7 +2848,7 @@ PeerImp::checkTransaction( { JLOG(pJournal_.warn()) << "Ignoring Network relayed Tx containing " "tfInnerBatchTxn (checkSignature)."; - charge(Resource::kFEE_MODERATE_BURDEN_PEER, "inner batch txn"); + charge(Resource::kFeeModerateBurdenPeer, "inner batch txn"); return; } // LCOV_EXCL_STOP @@ -2979,7 +2860,7 @@ PeerImp::checkTransaction( JLOG(pJournal_.info()) << "Marking transaction " << stx->getTransactionID() << "as BAD because it's expired"; app_.getHashRouter().setFlags(stx->getTransactionID(), HashRouterFlags::BAD); - charge(Resource::kFEE_USELESS_DATA, "expired tx"); + charge(Resource::kFeeUselessData, "expired tx"); return; } @@ -3010,7 +2891,7 @@ PeerImp::checkTransaction( if (!batch) { JLOG(pJournal_.debug()) << "Charging for pseudo-transaction tx " << tx->getID(); - charge(Resource::kFEE_USELESS_DATA, "pseudo tx"); + charge(Resource::kFeeUselessData, "pseudo tx"); } return; @@ -3032,7 +2913,7 @@ PeerImp::checkTransaction( // Probably not necessary to set HashRouterFlags::BAD, but // doesn't hurt. app_.getHashRouter().setFlags(stx->getTransactionID(), HashRouterFlags::BAD); - charge(Resource::kFEE_INVALID_SIGNATURE, "check transaction signature failure"); + charge(Resource::kFeeInvalidSignature, "check transaction signature failure"); return; } } @@ -3051,7 +2932,7 @@ PeerImp::checkTransaction( JLOG(pJournal_.debug()) << "Exception checking transaction: " << reason; } app_.getHashRouter().setFlags(stx->getTransactionID(), HashRouterFlags::BAD); - charge(Resource::kFEE_INVALID_SIGNATURE, "tx (impossible)"); + charge(Resource::kFeeInvalidSignature, "tx (impossible)"); return; } @@ -3063,7 +2944,7 @@ PeerImp::checkTransaction( JLOG(pJournal_.warn()) << "Exception in " << __func__ << ": " << ex.what(); app_.getHashRouter().setFlags(stx->getTransactionID(), HashRouterFlags::BAD); using namespace std::string_literals; - charge(Resource::kFEE_INVALID_DATA, "tx "s + ex.what()); + charge(Resource::kFeeInvalidData, "tx "s + ex.what()); } } @@ -3082,7 +2963,7 @@ PeerImp::checkPropose( { std::string const desc{"Proposal fails sig check"}; JLOG(pJournal_.warn()) << desc; - charge(Resource::kFEE_INVALID_SIGNATURE, desc); + charge(Resource::kFeeInvalidSignature, desc); return; } @@ -3094,7 +2975,7 @@ PeerImp::checkPropose( } else { - relay = app_.config().RELAY_UNTRUSTED_PROPOSALS == 1 || cluster(); + relay = app_.config().relayUntrustedProposals == 1 || cluster(); } if (relay) @@ -3126,7 +3007,7 @@ PeerImp::checkValidation( { std::string const desc{"Validation forwarded by peer is invalid"}; JLOG(pJournal_.debug()) << desc; - charge(Resource::kFEE_INVALID_SIGNATURE, desc); + charge(Resource::kFeeInvalidSignature, desc); return; } @@ -3151,7 +3032,7 @@ PeerImp::checkValidation( { JLOG(pJournal_.trace()) << "Exception processing validation: " << ex.what(); using namespace std::string_literals; - charge(Resource::kFEE_MALFORMED_REQUEST, "validation "s + ex.what()); + charge(Resource::kFeeMalformedRequest, "validation "s + ex.what()); } } @@ -3219,7 +3100,7 @@ PeerImp::sendLedgerBase( ledgerData.add_nodes()->set_nodedata(s.getDataPtr(), s.getLength()); auto const& stateMap{ledger->stateMap()}; - if (stateMap.getHash() != beast::kZERO) + if (stateMap.getHash() != beast::kZero) { // Return account state root node if possible Serializer root(768); @@ -3227,10 +3108,10 @@ PeerImp::sendLedgerBase( stateMap.serializeRoot(root); ledgerData.add_nodes()->set_nodedata(root.getDataPtr(), root.getLength()); - if (ledger->header().txHash != beast::kZERO) + if (ledger->header().txHash != beast::kZero) { auto const& txMap{ledger->txMap()}; - if (txMap.getHash() != beast::kZERO) + if (txMap.getHash() != beast::kZero) { // Return TX root node if possible root.erase(); @@ -3254,7 +3135,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) { @@ -3308,7 +3189,7 @@ PeerImp::getLedger(std::shared_ptr const& m) { // Do not resource charge a peer responding to a relay if (!m->has_requestcookie()) - charge(Resource::kFEE_MALFORMED_REQUEST, "get_ledger ledgerSeq"); + charge(Resource::kFeeMalformedRequest, "get_ledger ledgerSeq"); ledger.reset(); JLOG(pJournal_.warn()) << "getLedger: Invalid ledger sequence " << ledgerSeq; @@ -3333,7 +3214,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) { @@ -3365,7 +3246,7 @@ PeerImp::processLedgerRequest(std::shared_ptr const& m) { // Do not resource charge a peer responding to a relay if (!m->has_requestcookie()) - charge(Resource::kFEE_MODERATE_BURDEN_PEER, "received a get ledger request"); + charge(Resource::kFeeModerateBurdenPeer, "received a get ledger request"); std::shared_ptr ledger; std::shared_ptr sharedMap; @@ -3392,7 +3273,7 @@ PeerImp::processLedgerRequest(std::shared_ptr const& m) } else { - if (sendQueue_.size() >= Tuning::DropSendQueue) + if (sendQueue_.size() >= Tuning::kDropSendQueue) { JLOG(pJournal_.debug()) << "processLedgerRequest: Large send queue"; return; @@ -3454,13 +3335,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::kSoftMaxReplyNodes; ++i) { auto const shaMapNodeId{deserializeSHAMapNodeID(m->nodeids(i))}; data.clear(); - data.reserve(Tuning::SoftMaxReplyNodes); + data.reserve(Tuning::kSoftMaxReplyNodes); try { @@ -3472,7 +3353,7 @@ PeerImp::processLedgerRequest(std::shared_ptr const& m) for (auto const& d : data) { - if (ledgerData.nodes_size() >= Tuning::HardMaxReplyNodes) + if (ledgerData.nodes_size() >= Tuning::kHardMaxReplyNodes) break; protocol::TMLedgerNode* node{ledgerData.add_nodes()}; node->set_nodeid(d.first.getRawString()); @@ -3536,24 +3417,24 @@ PeerImp::getScore(bool haveItem) const { // Random component of score, used to break ties and avoid // overloading the "best" peer - static int const kSP_RANDOM_MAX = 9999; + static int const kSpRandomMax = 9999; // Score for being very likely to have the thing we are // look for; should be roughly spRandomMax - static int const kSP_HAVE_ITEM = 10000; + static int const kSpHaveItem = 10000; // Score reduction for each millisecond of latency; should // be roughly spRandomMax divided by the maximum reasonable // latency - static int const kSP_LATENCY = 30; + static int const kSpLatency = 30; // Penalty for unknown latency; should be roughly spRandomMax - static int const kSP_NO_LATENCY = 8000; + static int const kSpNoLatency = 8000; - int score = randInt(kSP_RANDOM_MAX); + int score = randInt(kSpRandomMax); if (haveItem) - score += kSP_HAVE_ITEM; + score += kSpHaveItem; std::optional latency; { @@ -3563,11 +3444,11 @@ PeerImp::getScore(bool haveItem) const if (latency) { - score -= latency->count() * kSP_LATENCY; + score -= latency->count() * kSpLatency; } else { - score -= kSP_NO_LATENCY; + score -= kSpNoLatency; } return score; @@ -3577,7 +3458,7 @@ bool PeerImp::isHighLatency() const { std::scoped_lock const sl(recentLock_); - return latency_ >= kPEER_HIGH_LATENCY; + return latency_ >= kPeerHighLatency; } void diff --git a/src/xrpld/overlay/detail/PeerImp.h b/src/xrpld/overlay/detail/PeerImp.h index 676057ad82..f5d87371be 100644 --- a/src/xrpld/overlay/detail/PeerImp.h +++ b/src/xrpld/overlay/detail/PeerImp.h @@ -30,68 +30,6 @@ namespace xrpl { struct ValidatorBlobInfo; class SHAMap; -/** - * @class PeerImp - * @brief This class manages established peer-to-peer connections, handles - message exchange, monitors connection health, and graceful shutdown. - * - - * The PeerImp shutdown mechanism is a multi-stage process - * designed to ensure graceful connection termination while handling ongoing - * I/O operations safely. The shutdown can be initiated from multiple points - * and follows a deterministic state machine. - * - * The shutdown process can be triggered from several entry points: - * - **External requests**: `stop()` method called by overlay management - * - **Error conditions**: `fail(error_code)` or `fail(string)` on protocol - * violations - * - **Timer expiration**: Various timeout scenarios (ping timeout, large send - * queue) - * - **Connection health**: Peer tracking divergence or unknown state timeouts - * - * The shutdown follows this progression: - * - * Normal Operation → shutdown() → tryAsyncShutdown() → onShutdown() → close() - * ↓ ↓ ↓ ↓ - * Set shutdown_ SSL graceful Timer cancel Socket close - * Cancel timer shutdown start & cleanup & metrics - * 5s safety timer Set shutdownStarted_ update - * - * Two primary flags coordinate the shutdown process: - * - `shutdown_`: Set when shutdown is requested - * - `shutdownStarted_`: Set when SSL shutdown begins - * - * The shutdown mechanism carefully coordinates with ongoing read/write - * operations: - * - * **Read Operations (`onReadMessage`)**: - * - Checks `shutdown_` flag after processing each message batch - * - If shutdown initiated during processing, calls `tryAsyncShutdown()` - * - * **Write Operations (`onWriteMessage`)**: - * - Checks `shutdown_` flag before queuing new writes - * - Calls `tryAsyncShutdown()` when shutdown flag detected - * - * Multiple timers require coordination during shutdown: - * 1. **Peer Timer**: Regular ping/pong timer cancelled immediately in - * `shutdown()` - * 2. **Shutdown Timer**: 5-second safety timer ensures shutdown completion - * 3. **Operation Cancellation**: All pending async operations are cancelled - * - * The shutdown implements fallback mechanisms: - * - **Graceful Path**: SSL shutdown → Socket close → Cleanup - * - **Forced Path**: If SSL shutdown fails or times out, proceeds to socket - * close - * - **Safety Timer**: 5-second timeout prevents hanging shutdowns - * - * All shutdown operations are serialized through the boost::asio::strand to - * ensure thread safety. The strand guarantees that shutdown state changes - * and I/O operation callbacks are executed sequentially. - * - * @note This class requires careful coordination between async operations, - * timer management, and shutdown procedures to ensure no resource leaks - * or hanging connections in high-throughput networking scenarios. - */ class PeerImp : public Peer, public std::enable_shared_from_this, public OverlayImpl::Child { public: @@ -121,8 +59,6 @@ private: socket_type& socket_; stream_type& stream_; boost::asio::strand strand_; - - // Multi-purpose timer for peer activity monitoring and shutdown safety waitable_timer timer_; // Updated at each stage of the connection process to reflect @@ -139,6 +75,7 @@ private: std::atomic tracking_; clock_type::time_point trackingTime_; + bool detaching_ = false; // Node public key of peer. PublicKey const publicKey_; std::string name_; @@ -190,7 +127,7 @@ private: struct ChargeWithContext { - Resource::Charge fee = Resource::kFEE_TRIVIAL_PEER; + Resource::Charge fee = Resource::kFeeTrivialPeer; std::string context{}; // NOLINT(readability-redundant-member-init) void @@ -216,19 +153,7 @@ private: http_response_type response_; boost::beast::http::fields const& headers_; std::queue> sendQueue_; - - // Primary shutdown flag set when shutdown is requested - bool shutdown_ = false; - - // SSL shutdown coordination flag - bool shutdownStarted_ = false; - - // Indicates a read operation is currently pending - bool readPending_ = false; - - // Indicates a write operation is currently pending - bool writePending_ = false; - + bool gracefulClose_ = false; int largeSendq_ = 0; std::unique_ptr loadEvent_; // The highest sequence of each PublisherList that has @@ -476,6 +401,9 @@ public: bool isHighLatency() const override; + void + fail(std::string const& reason); + bool compressionEnabled() const override { @@ -489,129 +417,32 @@ public: } private: - /** - * @brief Handles a failure associated with a specific error code. - * - * This function is called when an operation fails with an error code. It - * logs the warning message and gracefully shutdowns the connection. - * - * The function will do nothing if the connection is already closed or if a - * shutdown is already in progress. - * - * @param name The name of the operation that failed (e.g., "read", - * "write"). - * @param ec The error code associated with the failure. - * @note This function must be called from within the object's strand. - */ - void - fail(std::string const& name, error_code ec); - - /** - * @brief Handles a failure described by a reason string. - * - * This overload is used for logical errors or protocol violations not - * associated with a specific error code. It logs a warning with the - * given reason, then initiates a graceful shutdown. - * - * The function will do nothing if the connection is already closed or if a - * shutdown is already in progress. - * - * @param reason A descriptive string explaining the reason for the failure. - * @note This function must be called from within the object's strand. - */ - void - fail(std::string const& reason); - - /** @brief Initiates the peer disconnection sequence. - * - * This is the primary entry point to start closing a peer connection. It - * marks the peer for shutdown and cancels any outstanding asynchronous - * operations. This cancellation allows the graceful shutdown to proceed - * once the handlers for the cancelled operations have completed. - * - * @note This method must be called on the peer's strand. - */ - void - shutdown(); - - /** @brief Attempts to perform a graceful SSL shutdown if conditions are - * met. - * - * This helper function checks if the peer is in a state where a graceful - * SSL shutdown can be performed (i.e., shutdown has been requested and no - * I/O operations are currently in progress). - * - * @note This method must be called on the peer's strand. - */ - void - tryAsyncShutdown(); - - /** - * @brief Handles the completion of the asynchronous SSL shutdown. - * - * This function is the callback for the `async_shutdown` operation started - * in `shutdown()`. Its first action is to cancel the timer. It - * then inspects the error code to determine the outcome. - * - * Regardless of the result, this function proceeds to call `close()` to - * ensure the underlying socket is fully closed. - * - * @param ec The error code resulting from the `async_shutdown` operation. - */ - void - onShutdown(error_code ec); - - /** - * @brief Forcibly closes the underlying socket connection. - * - * This function provides the final, non-graceful shutdown of the peer - * connection. It ensures any pending timers are cancelled and then - * immediately closes the TCP socket, bypassing the SSL shutdown handshake. - * - * After closing, it notifies the overlay manager of the disconnection. - * - * @note This function must be called from within the object's strand. - */ void close(); - /** - * @brief Sets and starts the peer timer. - * - * This function starts timer, which is used to detect inactivity - * and prevent stalled connections. It sets the timer to expire after the - * predefined `peerTimerInterval`. - * - * @note This function will terminate the connection in case of any errors. - */ void - setTimer(std::chrono::seconds interval); + fail(std::string const& name, error_code ec); - /** - * @brief Handles the expiration of the peer activity timer. - * - * This callback is invoked when the timer set by `setTimer` expires. It - * watches the peer connection, checking for various timeout and health - * conditions. - * - * @param ec The error code associated with the timer's expiration. - * `operation_aborted` is expected if the timer was cancelled. - */ void - onTimer(error_code const& ec); + gracefulClose(); + + void + setTimer(); - /** - * @brief Cancels any pending wait on the peer activity timer. - * - * This function is called to stop the timer. It gracefully manages any - * errors that might occur during the cancellation process. - */ void cancelTimer() noexcept; static std::string makePrefix(std::string const& fingerprint); + // Called when the timer wait completes + void + onTimer(boost::system::error_code const& ec); + + // Called when SSL shutdown completes + void + onShutdown(error_code ec); + void doAccept(); @@ -834,30 +665,28 @@ PeerImp::PeerImp( , creationTime_(clock_type::now()) , squelch_(app_.getJournal("Squelch")) , usage_(usage) - , fee_{.fee = Resource::kFEE_TRIVIAL_PEER} + , fee_{.fee = Resource::kFeeTrivialPeer} , slot_(std::move(slot)) , response_(std::move(response)) , headers_(response_) , compressionEnabled_( - peerFeatureEnabled(headers_, kFEATURE_COMPR, "lz4", app_.config().COMPRESSION) + peerFeatureEnabled(headers_, kFeatureCompr, "lz4", app_.config().compression) ? Compressed::On : Compressed::Off) , txReduceRelayEnabled_( - peerFeatureEnabled(headers_, kFEATURE_TXRR, app_.config().TX_REDUCE_RELAY_ENABLE)) + peerFeatureEnabled(headers_, kFeatureTxrr, app_.config().txReduceRelayEnable)) , ledgerReplayEnabled_( - peerFeatureEnabled(headers_, kFEATURE_LEDGER_REPLAY, app_.config().LEDGER_REPLAY)) + peerFeatureEnabled(headers_, kFeatureLedgerReplay, app_.config().ledgerReplay)) , ledgerReplayMsgHandler_(app, app.getLedgerReplayer()) { readBuffer_.commit( boost::asio::buffer_copy(readBuffer_.prepare(boost::asio::buffer_size(buffers)), buffers)); - JLOG(journal_.info()) << "compression enabled " << (compressionEnabled_ == Compressed::On) - << " vp reduce-relay base squelch enabled " - << peerFeatureEnabled( - headers_, - kFEATURE_VPRR, - app_.config().VP_REDUCE_RELAY_BASE_SQUELCH_ENABLE) - << " tx reduce-relay enabled " << txReduceRelayEnabled_ << " on " - << remoteAddress_ << " " << id_; + JLOG(journal_.info()) + << "compression enabled " << (compressionEnabled_ == Compressed::On) + << " vp reduce-relay base squelch enabled " + << peerFeatureEnabled(headers_, kFeatureVprr, app_.config().vpReduceRelayBaseSquelchEnable) + << " tx reduce-relay enabled " << txReduceRelayEnabled_ << " on " << remoteAddress_ << " " + << id_; } template 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/PeerSet.cpp b/src/xrpld/overlay/detail/PeerSet.cpp index 6dda492315..463b68bb6c 100644 --- a/src/xrpld/overlay/detail/PeerSet.cpp +++ b/src/xrpld/overlay/detail/PeerSet.cpp @@ -167,9 +167,9 @@ public: [[nodiscard]] std::set const& getPeerIds() const override { - static std::set const kEMPTY_PEERS; + static std::set const kEmptyPeers; JLOG(j_.error()) << "DummyPeerSet getPeerIds should not be called"; - return kEMPTY_PEERS; + return kEmptyPeers; } private: diff --git a/src/xrpld/overlay/detail/ProtocolMessage.h b/src/xrpld/overlay/detail/ProtocolMessage.h index 0550cf68e0..b1a30bad10 100644 --- a/src/xrpld/overlay/detail/ProtocolMessage.h +++ b/src/xrpld/overlay/detail/ProtocolMessage.h @@ -98,19 +98,19 @@ struct MessageHeader @note This is the sum of sizes of the header and the payload. */ - std::uint32_t total_wire_size = 0; + std::uint32_t totalWireSize = 0; /** The size of the header associated with this message. */ - std::uint32_t header_size = 0; + std::uint32_t headerSize = 0; /** The size of the payload on the wire. */ - std::uint32_t payload_wire_size = 0; + std::uint32_t payloadWireSize = 0; /** Uncompressed message size if the message is compressed. */ - std::uint32_t uncompressed_size = 0; + std::uint32_t uncompressedSize = 0; /** The type of the message. */ - std::uint16_t message_type = 0; + std::uint16_t messageType = 0; /** Indicates which compression algorithm the payload is compressed with. * Currently only lz4 is supported. If None then the message is not @@ -159,10 +159,10 @@ parseMessageHeader(boost::system::error_code& ec, BufferSequence const& bufs, st // - 32 bits are the uncompressed data size if (*iter & 0x80) { - hdr.header_size = kHEADER_BYTES_COMPRESSED; + hdr.headerSize = kHeaderBytesCompressed; // not enough bytes to parse the header - if (size < hdr.header_size) + if (size < hdr.headerSize) { ec = make_error_code(boost::system::errc::success); return std::nullopt; @@ -183,18 +183,18 @@ parseMessageHeader(boost::system::error_code& ec, BufferSequence const& bufs, st } for (int i = 0; i != 4; ++i) - hdr.payload_wire_size = (hdr.payload_wire_size << 8) + *iter++; + hdr.payloadWireSize = (hdr.payloadWireSize << 8) + *iter++; // clear the top four bits (the compression bits). - hdr.payload_wire_size &= 0x0FFFFFFF; + hdr.payloadWireSize &= 0x0FFFFFFF; - hdr.total_wire_size = hdr.header_size + hdr.payload_wire_size; + hdr.totalWireSize = hdr.headerSize + hdr.payloadWireSize; for (int i = 0; i != 2; ++i) - hdr.message_type = (hdr.message_type << 8) + *iter++; + hdr.messageType = (hdr.messageType << 8) + *iter++; for (int i = 0; i != 4; ++i) - hdr.uncompressed_size = (hdr.uncompressed_size << 8) + *iter++; + hdr.uncompressedSize = (hdr.uncompressedSize << 8) + *iter++; return hdr; } @@ -204,9 +204,9 @@ parseMessageHeader(boost::system::error_code& ec, BufferSequence const& bufs, st // - 26 bits are the payload size if ((*iter & 0xFC) == 0) { - hdr.header_size = kHEADER_BYTES; + hdr.headerSize = kHeaderBytes; - if (size < hdr.header_size) + if (size < hdr.headerSize) { ec = make_error_code(boost::system::errc::success); return std::nullopt; @@ -215,13 +215,13 @@ parseMessageHeader(boost::system::error_code& ec, BufferSequence const& bufs, st hdr.algorithm = Algorithm::None; for (int i = 0; i != 4; ++i) - hdr.payload_wire_size = (hdr.payload_wire_size << 8) + *iter++; + hdr.payloadWireSize = (hdr.payloadWireSize << 8) + *iter++; - hdr.uncompressed_size = hdr.payload_wire_size; - hdr.total_wire_size = hdr.header_size + hdr.payload_wire_size; + hdr.uncompressedSize = hdr.payloadWireSize; + hdr.totalWireSize = hdr.headerSize + hdr.payloadWireSize; for (int i = 0; i != 2; ++i) - hdr.message_type = (hdr.message_type << 8) + *iter++; + hdr.messageType = (hdr.messageType << 8) + *iter++; return hdr; } @@ -240,18 +240,18 @@ parseMessageContent(MessageHeader const& header, Buffers const& buffers) auto m = std::make_shared(); ZeroCopyInputStream stream(buffers); - stream.Skip(header.header_size); + stream.Skip(header.headerSize); if (header.algorithm != compression::Algorithm::None) { std::vector payload; - payload.resize(header.uncompressed_size); + payload.resize(header.uncompressedSize); auto const payloadSize = xrpl::compression::decompress( stream, - header.payload_wire_size, + header.payloadWireSize, payload.data(), - header.uncompressed_size, + header.uncompressedSize, header.algorithm); if (payloadSize == 0 || !m->ParseFromArray(payload.data(), payloadSize)) @@ -279,13 +279,13 @@ invoke(MessageHeader const& header, Buffers const& buffers, Handler& handler) using namespace xrpl::compression; handler.onMessageBegin( - header.message_type, + header.messageType, m, - header.payload_wire_size, - header.uncompressed_size, + header.payloadWireSize, + header.uncompressedSize, header.algorithm != Algorithm::None); handler.onMessage(m); - handler.onMessageEnd(header.message_type, m); + handler.onMessageEnd(header.messageType, m); return true; } @@ -329,8 +329,8 @@ invokeProtocolMessage(Buffers const& buffers, Handler& handler, std::size_t& hin // whose size exceeds this may result in the connection being dropped. A // larger message size may be supported in the future or negotiated as // part of a protocol upgrade. - if (header->payload_wire_size > kMAXIMUM_MESSAGE_SIZE || - header->uncompressed_size > kMAXIMUM_MESSAGE_SIZE) + if (header->payloadWireSize > kMaximumMessageSize || + header->uncompressedSize > kMaximumMessageSize) { result.second = make_error_code(boost::system::errc::message_size); return result; @@ -345,15 +345,15 @@ invokeProtocolMessage(Buffers const& buffers, Handler& handler, std::size_t& hin // We don't have the whole message yet. This isn't an error but we have // nothing to do. - if (header->total_wire_size > size) + if (header->totalWireSize > size) { - hint = header->total_wire_size - size; + hint = header->totalWireSize - size; return result; } bool success = false; - switch (header->message_type) + switch (header->messageType) { case protocol::mtMANIFESTS: success = detail::invoke(*header, buffers, handler); @@ -420,12 +420,12 @@ invokeProtocolMessage(Buffers const& buffers, Handler& handler, std::size_t& hin success = detail::invoke(*header, buffers, handler); break; default: - handler.onMessageUnknown(header->message_type); + handler.onMessageUnknown(header->messageType); success = true; break; } - result.first = header->total_wire_size; + result.first = header->totalWireSize; if (!success) result.second = make_error_code(boost::system::errc::bad_message); diff --git a/src/xrpld/overlay/detail/ProtocolVersion.cpp b/src/xrpld/overlay/detail/ProtocolVersion.cpp index 86525068f8..62660b0e01 100644 --- a/src/xrpld/overlay/detail/ProtocolVersion.cpp +++ b/src/xrpld/overlay/detail/ProtocolVersion.cpp @@ -25,7 +25,7 @@ namespace xrpl { it may not contain any duplicates!) */ -constexpr ProtocolVersion const kSUPPORTED_PROTOCOL_LIST[]{ +constexpr ProtocolVersion const kSupportedProtocolList[]{ {2, 1}, {2, 2}, }; @@ -36,7 +36,7 @@ constexpr ProtocolVersion const kSUPPORTED_PROTOCOL_LIST[]{ static_assert( []() constexpr -> bool { auto const len = - std::distance(std::begin(kSUPPORTED_PROTOCOL_LIST), std::end(kSUPPORTED_PROTOCOL_LIST)); + std::distance(std::begin(kSupportedProtocolList), std::end(kSupportedProtocolList)); // There should be at least one protocol we're willing to speak. if (len == 0) @@ -48,7 +48,7 @@ static_assert( { for (auto i = 0; i != len - 1; ++i) { - if (kSUPPORTED_PROTOCOL_LIST[i] >= kSUPPORTED_PROTOCOL_LIST[i + 1]) + if (kSupportedProtocolList[i] >= kSupportedProtocolList[i + 1]) return false; } } @@ -125,7 +125,7 @@ negotiateProtocolVersion(std::vector const& versions) [&result](ProtocolVersion const& v) { result = v; }; std::ranges::set_intersection( - versions, kSUPPORTED_PROTOCOL_LIST, boost::make_function_output_iterator(pickVersion)); + versions, kSupportedProtocolList, boost::make_function_output_iterator(pickVersion)); return result; } @@ -141,9 +141,9 @@ negotiateProtocolVersion(boost::beast::string_view const& versions) std::string const& supportedProtocolVersions() { - static std::string const kSUPPORTED = []() { + static std::string const kSupported = []() { std::string ret; - for (auto const& v : kSUPPORTED_PROTOCOL_LIST) + for (auto const& v : kSupportedProtocolList) { if (!ret.empty()) ret += ", "; @@ -153,13 +153,13 @@ supportedProtocolVersions() return ret; }(); - return kSUPPORTED; + return kSupported; } bool isProtocolSupported(ProtocolVersion const& v) { - return std::end(kSUPPORTED_PROTOCOL_LIST) != std::ranges::find(kSUPPORTED_PROTOCOL_LIST, v); + return std::end(kSupportedProtocolList) != std::ranges::find(kSupportedProtocolList, v); } } // namespace xrpl diff --git a/src/xrpld/overlay/detail/TrafficCount.cpp b/src/xrpld/overlay/detail/TrafficCount.cpp index 4dc99e3e37..bdce9e68f0 100644 --- a/src/xrpld/overlay/detail/TrafficCount.cpp +++ b/src/xrpld/overlay/detail/TrafficCount.cpp @@ -8,7 +8,7 @@ namespace xrpl { -std::unordered_map const kTYPE_LOOKUP = { +std::unordered_map const kTypeLookup = { {protocol::mtPING, TrafficCount::Category::Base}, {protocol::mtSTATUS_CHANGE, TrafficCount::Category::Base}, {protocol::mtMANIFESTS, TrafficCount::Category::Manifests}, @@ -33,7 +33,7 @@ TrafficCount::categorize( protocol::MessageType type, bool inbound) { - if (auto item = kTYPE_LOOKUP.find(type); item != kTYPE_LOOKUP.end()) + if (auto item = kTypeLookup.find(type); item != kTypeLookup.end()) return item->second; if (type == protocol::mtHAVE_SET) diff --git a/src/xrpld/overlay/detail/TrafficCount.h b/src/xrpld/overlay/detail/TrafficCount.h index 233f06b70f..cb77c2359f 100644 --- a/src/xrpld/overlay/detail/TrafficCount.h +++ b/src/xrpld/overlay/detail/TrafficCount.h @@ -226,7 +226,7 @@ public: static std::string toString(Category cat) { - static std::unordered_map const kCATEGORY_MAP = { + static std::unordered_map const kCategoryMap = { {Category::Base, "overhead"}, {Category::Cluster, "overhead_cluster"}, {Category::Overlay, "overhead_overlay"}, @@ -284,7 +284,7 @@ public: {Category::RequestedTransactions, "requested_transactions"}, {Category::Total, "total"}}; - if (auto it = kCATEGORY_MAP.find(cat); it != kCATEGORY_MAP.end()) + if (auto it = kCategoryMap.find(cat); it != kCategoryMap.end()) return it->second; return "unknown"; diff --git a/src/xrpld/overlay/detail/Tuning.h b/src/xrpld/overlay/detail/Tuning.h index c54fa24498..a0f57ec3d7 100644 --- a/src/xrpld/overlay/detail/Tuning.h +++ b/src/xrpld/overlay/detail/Tuning.h @@ -1,47 +1,40 @@ #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 kConvergedLedgerLimit = 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 kDivergedLedgerLimit = 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 kSoftMaxReplyNodes = 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 kHardMaxReplyNodes = 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 kSendqIntervals = 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 kDropSendQueue = 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 kTargetSendQueue = 128; - /** How often to log send queue size */ - SendQueueLogFreq = 64, +/** How often to log send queue size */ +static constexpr auto kSendQueueLogFreq = 64; - /** How often we check for idle peers (seconds) */ - CheckIdlePeers = 4, +/** How often we check for idle peers (seconds) */ +static constexpr auto kCheckIdlePeers = 4; - /** The maximum number of levels to search */ - MaxQueryDepth = 3, -}; +/** The maximum number of levels to search */ +static constexpr auto kMaxQueryDepth = 3; /** Size of buffer used to read from the socket. */ -std::size_t constexpr kREAD_BUFFER_BYTES = 16384; +constexpr std::size_t kReadBufferBytes = 16384; } // namespace xrpl::Tuning diff --git a/src/xrpld/overlay/detail/TxMetrics.cpp b/src/xrpld/overlay/detail/TxMetrics.cpp index c1a336b11e..d2597cb19f 100644 --- a/src/xrpld/overlay/detail/TxMetrics.cpp +++ b/src/xrpld/overlay/detail/TxMetrics.cpp @@ -77,13 +77,13 @@ SingleMetrics::addMetrics(std::uint32_t val) { using namespace std::chrono_literals; accum += val; - N++; + n++; auto const timeElapsed = clock_type::now() - intervalStart; auto const timeElapsedInSecs = std::chrono::duration_cast(timeElapsed); if (timeElapsedInSecs >= 1s) { - auto const avg = accum / (perTimeUnit ? timeElapsedInSecs.count() : N); + auto const avg = accum / (perTimeUnit ? timeElapsedInSecs.count() : n); rollingAvgAggregate.push_back(avg); auto const total = @@ -92,7 +92,7 @@ SingleMetrics::addMetrics(std::uint32_t val) intervalStart = clock_type::now(); accum = 0; - N = 0; + n = 0; } } @@ -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/detail/TxMetrics.h b/src/xrpld/overlay/detail/TxMetrics.h index 7b8b4bae1b..50df7a65cc 100644 --- a/src/xrpld/overlay/detail/TxMetrics.h +++ b/src/xrpld/overlay/detail/TxMetrics.h @@ -29,7 +29,7 @@ struct SingleMetrics clock_type::time_point intervalStart{clock_type::now()}; std::uint64_t accum{0}; std::uint64_t rollingAvg{0}; - std::uint32_t N{0}; + std::uint32_t n{0}; bool perTimeUnit{true}; boost::circular_buffer rollingAvgAggregate{30, 0ull}; /** Add metrics value 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..f88b1b637c 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::kDefaultMaxPeers}; /** 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..a0a753530b 100644 --- a/src/xrpld/peerfinder/detail/Bootcache.cpp +++ b/src/xrpld/peerfinder/detail/Bootcache.cpp @@ -110,13 +110,13 @@ Bootcache::insert(beast::IP::Endpoint const& endpoint) bool Bootcache::insertStatic(beast::IP::Endpoint const& endpoint) { - auto result(map_.insert(value_type(endpoint, kSTATIC_VALENCE))); + auto result(map_.insert(value_type(endpoint, kStaticValence))); - if (!result.second && (result.first->right.valence() < kSTATIC_VALENCE)) + if (!result.second && (result.first->right.valence() < kStaticValence)) { // An existing entry has too low a valence, replace it map_.erase(result.first); - result = map_.insert(value_type(endpoint, kSTATIC_VALENCE)); + result = map_.insert(value_type(endpoint, kStaticValence)); } if (result.second) @@ -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::kBootcacheSize) return; // Calculate the amount to remove - auto count((size() * Tuning::BootcachePrunePercent) / 100); + auto count((size() * Tuning::kBootcachePrunePercent) / 100); decltype(count) pruned(0); // Work backwards because bimap doesn't handle @@ -240,7 +240,7 @@ Bootcache::update() store_.save(list); // Reset the flag and cooldown timer needsUpdate_ = false; - whenUpdate_ = clock_.now() + Tuning::kBOOTCACHE_COOLDOWN_TIME; + whenUpdate_ = clock_.now() + Tuning::kBootcacheCooldownTime; } // Checks the clock and calls update if we are off the cooldown. diff --git a/src/xrpld/peerfinder/detail/Bootcache.h b/src/xrpld/peerfinder/detail/Bootcache.h index c061f37595..01ee2cad33 100644 --- a/src/xrpld/peerfinder/detail/Bootcache.h +++ b/src/xrpld/peerfinder/detail/Bootcache.h @@ -97,7 +97,7 @@ private: bool needsUpdate_{false}; public: - static constexpr int kSTATIC_VALENCE = 32; + static constexpr int kStaticValence = 32; using iterator = boost::transform_iterator; diff --git a/src/xrpld/peerfinder/detail/Counts.h b/src/xrpld/peerfinder/detail/Counts.h index e859b09d21..67b8370996 100644 --- a/src/xrpld/peerfinder/detail/Counts.h +++ b/src/xrpld/peerfinder/detail/Counts.h @@ -42,18 +42,18 @@ public: return true; if (s.inbound()) - return in_active_ < in_max_; + return inActive_ < inMax_; - return out_active_ < out_max_; + return outActive_ < outMax_; } /** Returns the number of attempts needed to bring us to the max. */ [[nodiscard]] std::size_t attemptsNeeded() const { - if (attempts_ >= Tuning::MaxConnectAttempts) + if (attempts_ >= Tuning::kMaxConnectAttempts) return 0; - return Tuning::MaxConnectAttempts - attempts_; + return Tuning::kMaxConnectAttempts - attempts_; } /** Returns the number of outbound connection attempts. */ @@ -67,7 +67,7 @@ public: [[nodiscard]] int outMax() const { - return out_max_; + return outMax_; } /** Returns the number of outbound peers assigned an open slot. @@ -76,7 +76,7 @@ public: [[nodiscard]] int outActive() const { - return out_active_; + return outActive_; } /** Returns the number of fixed connections. */ @@ -90,7 +90,7 @@ public: [[nodiscard]] std::size_t fixedActive() const { - return fixed_active_; + return fixedActive_; } //-------------------------------------------------------------------------- @@ -99,9 +99,9 @@ public: void onConfig(Config const& config) { - out_max_ = config.outPeers; + outMax_ = config.outPeers; if (config.wantIncoming) - in_max_ = config.inPeers; + inMax_ = config.inPeers; } /** Returns the number of accepted connections that haven't handshaked. */ @@ -129,21 +129,21 @@ public: [[nodiscard]] int inMax() const { - return in_max_; + return inMax_; } /** Returns the number of inbound peers assigned an open slot. */ [[nodiscard]] int inboundActive() const { - return in_active_; + return inActive_; } /** Returns the total number of active peers excluding fixed peers. */ [[nodiscard]] int totalActive() const { - return in_active_ + out_active_; + return inActive_ + outActive_; } /** Returns the number of unused inbound slots. @@ -152,8 +152,8 @@ public: [[nodiscard]] int inboundSlotsFree() const { - if (in_active_ < in_max_) - return in_max_ - in_active_; + if (inActive_ < inMax_) + return inMax_ - inActive_; return 0; } @@ -163,8 +163,8 @@ public: [[nodiscard]] int outboundSlotsFree() const { - if (out_active_ < out_max_) - return out_max_ - out_active_; + if (outActive_ < outMax_) + return outMax_ - outActive_; return 0; } @@ -181,7 +181,7 @@ public: // // Fixed peers do not count towards the active outgoing total. - return out_max_ <= 0; + return outMax_ <= 0; } /** Output statistics. */ @@ -191,9 +191,9 @@ public: map["accept"] = acceptCount(); map["connect"] = connectCount(); map["close"] = closingCount(); - map["in"] << in_active_ << "/" << in_max_; - map["out"] << out_active_ << "/" << out_max_; - map["fixed"] = fixed_active_; + map["in"] << inActive_ << "/" << inMax_; + map["out"] << outActive_ << "/" << outMax_; + map["fixed"] = fixedActive_; map["reserved"] = reserved_; map["total"] = active_; } @@ -203,7 +203,7 @@ public: stateString() const { std::stringstream ss; - ss << out_active_ << "/" << out_max_ << " out, " << in_active_ << "/" << in_max_ << " in, " + ss << outActive_ << "/" << outMax_ << " out, " << inActive_ << "/" << inMax_ << " in, " << connectCount() << " connecting, " << closingCount() << " closing"; return ss.str(); } @@ -262,16 +262,16 @@ private: case Slot::State::Active: if (s.fixed()) - adjustCounter(fixed_active_, dir); + adjustCounter(fixedActive_, dir); if (!s.fixed() && !s.reserved()) { if (s.inbound()) { - adjustCounter(in_active_, dir); + adjustCounter(inActive_, dir); } else { - adjustCounter(out_active_, dir); + adjustCounter(outActive_, dir); } } adjustCounter(active_, dir); @@ -297,22 +297,22 @@ private: std::size_t active_{0}; /** Total number of inbound slots. */ - std::size_t in_max_{0}; + std::size_t inMax_{0}; /** Number of inbound slots assigned to active peers. */ - std::size_t in_active_{0}; + std::size_t inActive_{0}; /** Maximum desired outbound slots. */ - std::size_t out_max_{0}; + std::size_t outMax_{0}; /** Active outbound slots. */ - std::size_t out_active_{0}; + std::size_t outActive_{0}; /** Fixed connections. */ std::size_t fixed_{0}; /** Active fixed connections. */ - std::size_t fixed_active_{0}; + std::size_t fixedActive_{0}; /** Reserved connections. */ std::size_t reserved_{0}; diff --git a/src/xrpld/peerfinder/detail/Endpoint.cpp b/src/xrpld/peerfinder/detail/Endpoint.cpp index ab9cd66809..15de5cd153 100644 --- a/src/xrpld/peerfinder/detail/Endpoint.cpp +++ b/src/xrpld/peerfinder/detail/Endpoint.cpp @@ -10,7 +10,7 @@ namespace xrpl::PeerFinder { Endpoint::Endpoint(beast::IP::Endpoint ep, std::uint32_t hops) - : hops(std::min(hops, Tuning::kMAX_HOPS + 1)), address(std::move(ep)) + : hops(std::min(hops, Tuning::kMaxHops + 1)), address(std::move(ep)) { } diff --git a/src/xrpld/peerfinder/detail/Fixed.h b/src/xrpld/peerfinder/detail/Fixed.h index c334b9ac99..61df9caddb 100644 --- a/src/xrpld/peerfinder/detail/Fixed.h +++ b/src/xrpld/peerfinder/detail/Fixed.h @@ -25,8 +25,8 @@ public: void failure(clock_type::time_point const& now) { - failures_ = std::min(failures_ + 1, Tuning::kCONNECTION_BACKOFF.size() - 1); - when_ = now + std::chrono::minutes(Tuning::kCONNECTION_BACKOFF[failures_]); + failures_ = std::min(failures_ + 1, Tuning::kConnectionBackoff.size() - 1); + when_ = now + std::chrono::minutes(Tuning::kConnectionBackoff[failures_]); } /** Updates metadata to reflect a successful connection. */ diff --git a/src/xrpld/peerfinder/detail/Handouts.h b/src/xrpld/peerfinder/detail/Handouts.h index f4c7483e3f..19a367f8c1 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; @@ -88,7 +88,7 @@ public: [[nodiscard]] bool full() const { - return list_.size() >= Tuning::kREDIRECT_ENDPOINT_COUNT; + return list_.size() >= Tuning::kRedirectEndpointCount; } [[nodiscard]] SlotImp::ptr const& @@ -117,7 +117,7 @@ private: template RedirectHandouts::RedirectHandouts(SlotImp::ptr slot) : slot_(std::move(slot)) { - list_.reserve(Tuning::kREDIRECT_ENDPOINT_COUNT); + list_.reserve(Tuning::kRedirectEndpointCount); } template @@ -131,7 +131,7 @@ RedirectHandouts::tryInsert(Endpoint const& ep) // addresses in a peer HTTP handshake instead of // the tmENDPOINTS message. // - if (ep.hops > Tuning::kMAX_HOPS) + if (ep.hops > Tuning::kMaxHops) return false; // Don't send them our address @@ -172,7 +172,7 @@ public: [[nodiscard]] bool full() const { - return list_.size() >= Tuning::kNUMBER_OF_ENDPOINTS; + return list_.size() >= Tuning::kNumberOfEndpoints; } void @@ -201,7 +201,7 @@ private: template SlotHandouts::SlotHandouts(SlotImp::ptr slot) : slot_(std::move(slot)) { - list_.reserve(Tuning::kNUMBER_OF_ENDPOINTS); + list_.reserve(Tuning::kNumberOfEndpoints); } template @@ -211,7 +211,7 @@ SlotHandouts::tryInsert(Endpoint const& ep) if (full()) return false; - if (ep.hops > Tuning::kMAX_HOPS) + if (ep.hops > Tuning::kMaxHops) return false; if (slot_->recent.filter(ep.address, ep.hops)) diff --git a/src/xrpld/peerfinder/detail/Livecache.h b/src/xrpld/peerfinder/detail/Livecache.h index 063fb622cf..84efcb7bd1 100644 --- a/src/xrpld/peerfinder/detail/Livecache.h +++ b/src/xrpld/peerfinder/detail/Livecache.h @@ -202,8 +202,8 @@ public: // but not given out (since they would exceed maxHops). They // are used for automatic connection attempts. // - using Histogram = std::array; - using lists_type = std::array; + using Histogram = std::array; + using lists_type = std::array; template struct Transform @@ -371,7 +371,7 @@ Livecache::expire() { std::size_t n(0); typename cache_type::time_point const expired( - cache_.clock().now() - Tuning::kLIVE_CACHE_SECONDS_TO_LIVE); + cache_.clock().now() - Tuning::kLiveCacheSecondsToLive); for (auto iter(cache_.chronological.begin()); iter != cache_.chronological.end() && iter.when() <= expired;) { @@ -398,7 +398,7 @@ Livecache::insert(Endpoint const& ep) // when redirecting. // XRPL_ASSERT( - ep.hops <= (Tuning::kMAX_HOPS + 1), + ep.hops <= (Tuning::kMaxHops + 1), "xrpl::PeerFinder::Livecache::insert : maximum input hops"); auto result = cache_.emplace(ep.address, ep); Element& e(result.first->second); @@ -439,7 +439,7 @@ void Livecache::onWrite(beast::PropertyStream::Map& map) { typename cache_type::time_point const expired( - cache_.clock().now() - Tuning::kLIVE_CACHE_SECONDS_TO_LIVE); + cache_.clock().now() - Tuning::kLiveCacheSecondsToLive); map["size"] = size(); map["hist"] = hops.histogram(); beast::PropertyStream::Set set("entries", map); @@ -498,8 +498,8 @@ void Livecache::HopsT::insert(Element& e) { XRPL_ASSERT( - e.endpoint.hops <= Tuning::kMAX_HOPS + 1, - "xrpl::PeerFinder::Livecache::hops_t::insert : maximum input hops"); + e.endpoint.hops <= Tuning::kMaxHops + 1, + "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]; @@ -510,8 +510,8 @@ void 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"); + numHops <= Tuning::kMaxHops + 1, + "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..3ebe0cf2f4 100644 --- a/src/xrpld/peerfinder/detail/Logic.h +++ b/src/xrpld/peerfinder/detail/Logic.h @@ -633,7 +633,7 @@ public: result.emplace_back(slot, list); } - whenBroadcast = now + Tuning::kSECONDS_PER_MESSAGE; + whenBroadcast = now + Tuning::kSecondsPerMessage; } return result; @@ -652,7 +652,7 @@ public: entry.second->expire(); // Expire the recent attempts table - beast::expire(squelches, Tuning::kRECENT_ATTEMPT_DURATION); + beast::expire(squelches, Tuning::kRecentAttemptDuration); bootcache.periodicActivity(); } @@ -669,7 +669,7 @@ public: Endpoint& ep(*iter); // Enforce hop limit - if (ep.hops > Tuning::kMAX_HOPS) + if (ep.hops > Tuning::kMaxHops) { JLOG(journal.debug()) << beast::Leftw(18) << "Endpoints drop " << ep.address << " for excess hops " << ep.hops; @@ -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"; @@ -731,10 +731,10 @@ public: beast::Journal const journal{sink}; // If we're sent too many endpoints, sample them at random: - if (list.size() > Tuning::kNUMBER_OF_ENDPOINTS_MAX) + if (list.size() > Tuning::kNumberOfEndpointsMax) { std::shuffle(list.begin(), list.end(), defaultPrng()); - list.resize(Tuning::kNUMBER_OF_ENDPOINTS_MAX); + list.resize(Tuning::kNumberOfEndpointsMax); } JLOG(journal.trace()) << "Endpoints contained " << list.size() @@ -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); @@ -816,7 +816,7 @@ public: bootcache.insert(ep.address); } - slot->whenAcceptEndpoints = now + Tuning::kSECONDS_PER_MESSAGE; + slot->whenAcceptEndpoints = now + Tuning::kSecondsPerMessage; } //-------------------------------------------------------------------------- @@ -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::kMaxRedirects; ++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..fcf30fa4f4 100644 --- a/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp +++ b/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp @@ -15,20 +15,10 @@ 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::kOutPercent + 50) / 100, std::size_t(Tuning::kMinOutCount)); } void @@ -41,8 +31,8 @@ Config::applyTuning() // IP addresses. ipLimit = 2; - if (inPeers > Tuning::DefaultMaxPeers) - ipLimit += std::min(5, static_cast(inPeers / Tuning::DefaultMaxPeers)); + if (inPeers > Tuning::kDefaultMaxPeers) + ipLimit += std::min(5, static_cast(inPeers / Tuning::kDefaultMaxPeers)); } // We don't allow a single IP to consume all incoming slots, @@ -60,6 +50,7 @@ Config::onWrite(beast::PropertyStream::Map& map) const map["port"] = listeningPort; map["features"] = features; map["ip_limit"] = ipLimit; + map["verify_endpoints"] = verifyEndpoints; } Config @@ -67,21 +58,22 @@ Config::makeConfig( xrpl::Config const& cfg, std::uint16_t port, bool validationPublicKey, - int ipLimit) + int ipLimit, + bool verifyEndpoints) { PeerFinder::Config config; - config.peerPrivate = cfg.PEER_PRIVATE; + config.peerPrivate = cfg.peerPrivate; // Servers with peer privacy don't want to allow incoming connections config.wantIncoming = (!config.peerPrivate) && (port != 0); - if ((cfg.PEERS_OUT_MAX == 0u) && (cfg.PEERS_IN_MAX == 0u)) + if ((cfg.peersOutMax == 0u) && (cfg.peersInMax == 0u)) { - if (cfg.PEERS_MAX != 0) - config.maxPeers = cfg.PEERS_MAX; + if (cfg.peersMax != 0) + config.maxPeers = cfg.peersMax; - config.maxPeers = std::max(config.maxPeers, Tuning::MinOutCount); + config.maxPeers = std::max(config.maxPeers, Tuning::kMinOutCount); config.outPeers = config.calcOutPeers(); // Calculate the number of outbound peers we want. If we dont want @@ -102,8 +94,8 @@ Config::makeConfig( } else { - config.outPeers = cfg.PEERS_OUT_MAX; - config.inPeers = cfg.PEERS_IN_MAX; + config.outPeers = cfg.peersOutMax; + config.inPeers = cfg.peersInMax; config.maxPeers = 0; } @@ -116,10 +108,11 @@ Config::makeConfig( // if it's a private peer or we are running as standalone // automatic connections would defeat the purpose. - config.autoConnect = !cfg.standalone() && !cfg.PEER_PRIVATE; + config.autoConnect = !cfg.standalone() && !cfg.peerPrivate; config.listeningPort = port; config.features = ""; config.ipLimit = ipLimit; + config.verifyEndpoints = verifyEndpoints; // Enforce business rules config.applyTuning(); diff --git a/src/xrpld/peerfinder/detail/SlotImp.cpp b/src/xrpld/peerfinder/detail/SlotImp.cpp index b941f54b48..a54ddb56e7 100644 --- a/src/xrpld/peerfinder/detail/SlotImp.cpp +++ b/src/xrpld/peerfinder/detail/SlotImp.cpp @@ -23,9 +23,9 @@ SlotImp::SlotImp( , fixed_(fixed) , reserved_(false) , state_(State::Accept) - , remote_endpoint_(std::move(remoteEndpoint)) - , local_endpoint_(localEndpoint) - , listening_port_(kUNKNOWN_PORT) + , remoteEndpoint_(std::move(remoteEndpoint)) + , localEndpoint_(localEndpoint) + , listeningPort_(kUnknownPort) , checked(false) , canAccept(false) , connectivityCheckInProgress(false) @@ -38,8 +38,8 @@ SlotImp::SlotImp(beast::IP::Endpoint remoteEndpoint, bool fixed, clock_type& clo , fixed_(fixed) , reserved_(false) , state_(State::Connect) - , remote_endpoint_(std::move(remoteEndpoint)) - , listening_port_(kUNKNOWN_PORT) + , remoteEndpoint_(std::move(remoteEndpoint)) + , listeningPort_(kUnknownPort) , checked(true) , canAccept(true) , connectivityCheckInProgress(false) @@ -131,7 +131,7 @@ SlotImp::RecentT::filter(beast::IP::Endpoint const& ep, std::uint32_t hops) void SlotImp::RecentT::expire() { - beast::expire(cache_, Tuning::kLIVE_CACHE_SECONDS_TO_LIVE); + beast::expire(cache_, Tuning::kLiveCacheSecondsToLive); } } // namespace xrpl::PeerFinder diff --git a/src/xrpld/peerfinder/detail/SlotImp.h b/src/xrpld/peerfinder/detail/SlotImp.h index b198c93e5d..0cf4d7a3c8 100644 --- a/src/xrpld/peerfinder/detail/SlotImp.h +++ b/src/xrpld/peerfinder/detail/SlotImp.h @@ -52,19 +52,19 @@ public: beast::IP::Endpoint const& remoteEndpoint() const override { - return remote_endpoint_; + return remoteEndpoint_; } std::optional const& localEndpoint() const override { - return local_endpoint_; + return localEndpoint_; } std::optional const& publicKey() const override { - return public_key_; + return publicKey_; } std::string @@ -76,8 +76,8 @@ public: std::optional listeningPort() const override { - std::uint32_t const value = listening_port_; - if (value == kUNKNOWN_PORT) + std::uint32_t const value = listeningPort_; + if (value == kUnknownPort) return std::nullopt; return value; } @@ -85,25 +85,25 @@ public: void setListeningPort(std::uint16_t port) { - listening_port_ = port; + listeningPort_ = port; } void localEndpoint(beast::IP::Endpoint const& endpoint) { - local_endpoint_ = endpoint; + localEndpoint_ = endpoint; } void remoteEndpoint(beast::IP::Endpoint const& endpoint) { - remote_endpoint_ = endpoint; + remoteEndpoint_ = endpoint; } void publicKey(PublicKey const& key) { - public_key_ = key; + publicKey_ = key; } void @@ -160,12 +160,12 @@ private: bool const fixed_; bool reserved_; State state_; - beast::IP::Endpoint remote_endpoint_; - std::optional local_endpoint_; - std::optional public_key_; + beast::IP::Endpoint remoteEndpoint_; + std::optional localEndpoint_; + std::optional publicKey_; - static std::int32_t constexpr kUNKNOWN_PORT = -1; - std::atomic listening_port_; + static constexpr std::int32_t kUnknownPort = -1; + std::atomic listeningPort_; public: // DEPRECATED public data members diff --git a/src/xrpld/peerfinder/detail/StoreSqdb.h b/src/xrpld/peerfinder/detail/StoreSqdb.h index 13338cbd73..19cdd774b7 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 kCurrentSchemaVersion = 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_, kCurrentSchemaVersion, journal_); } private: diff --git a/src/xrpld/peerfinder/detail/Tuning.h b/src/xrpld/peerfinder/detail/Tuning.h index 4fc57a69a0..b4781495b8 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 kSecondsPerConnect = 10; - /** Maximum number of simultaneous connection attempts. */ - , - MaxConnectAttempts = 20 +/** Maximum number of simultaneous connection attempts. */ +static constexpr auto kMaxConnectAttempts = 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 kOutPercent = 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 kMinOutCount = 10; - /** The default value of Config::maxPeers. */ - , - DefaultMaxPeers = 21 +/** The default value of Config::maxPeers. */ +static constexpr auto kDefaultMaxPeers = 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 kMaxRedirects = 30; //------------------------------------------------------------------------------ // @@ -55,7 +46,7 @@ enum { // //------------------------------------------------------------------------------ -static std::array const kCONNECTION_BACKOFF{{1, 1, 2, 3, 5, 8, 13, 21, 34, 55}}; +static std::array const kConnectionBackoff{{1, 1, 2, 3, 5, 8, 13, 21, 34, 55}}; //------------------------------------------------------------------------------ // @@ -63,22 +54,17 @@ 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 kBootcacheSize = 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 kBootcachePrunePercent = 10; // The cool down wait between database updates // Ideally this should be larger than the time it takes a full // peer to send us a set of addresses and then disconnect. // -static std::chrono::seconds const kBOOTCACHE_COOLDOWN_TIME(60); +static std::chrono::seconds const kBootcacheCooldownTime(60); //------------------------------------------------------------------------------ // @@ -87,29 +73,29 @@ static std::chrono::seconds const kBOOTCACHE_COOLDOWN_TIME(60); //------------------------------------------------------------------------------ // Drop incoming messages with hops greater than this number -std::uint32_t constexpr kMAX_HOPS = 6; +constexpr std::uint32_t kMaxHops = 6; // How many Endpoint to send in each mtENDPOINTS -std::uint32_t constexpr kNUMBER_OF_ENDPOINTS = 2 * kMAX_HOPS; +constexpr std::uint32_t kNumberOfEndpoints = 2 * kMaxHops; // The most Endpoint we will accept in mtENDPOINTS -std::uint32_t constexpr kNUMBER_OF_ENDPOINTS_MAX = - std::max(kNUMBER_OF_ENDPOINTS * 2, 64); +constexpr std::uint32_t kNumberOfEndpointsMax = + std::max(kNumberOfEndpoints * 2, 64); // Number of addresses we provide when redirecting. -std::uint32_t constexpr kREDIRECT_ENDPOINT_COUNT = 10; +constexpr std::uint32_t kRedirectEndpointCount = 10; // How often we send or accept mtENDPOINTS messages per peer // (we use a prime number of purpose) -std::chrono::seconds constexpr kSECONDS_PER_MESSAGE(151); +constexpr std::chrono::seconds kSecondsPerMessage(151); // How long an Endpoint will stay in the cache // This should be a small multiple of the broadcast frequency -std::chrono::seconds constexpr kLIVE_CACHE_SECONDS_TO_LIVE(30); +constexpr std::chrono::seconds kLiveCacheSecondsToLive(30); // How much time to wait before trying an outgoing address again. // Note that we ignore the port for purposes of comparison. -std::chrono::seconds constexpr kRECENT_ATTEMPT_DURATION(60); +constexpr std::chrono::seconds kRecentAttemptDuration(60); } // namespace xrpl::PeerFinder::Tuning /** @} */ 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..45c3cf2e4b 100644 --- a/src/xrpld/rpc/BookChanges.h +++ b/src/xrpld/rpc/BookChanges.h @@ -108,15 +108,15 @@ computeBookChanges(std::shared_ptr const& lpAccepted) STAmount second = noswap ? deltaPays : deltaGets; // defensively programmed, should (probably) never happen - if (second == beast::kZERO) + if (second == beast::kZero) continue; STAmount const rate = divide(first, second, noIssue()); - if (first < beast::kZERO) + if (first < beast::kZero) first = -first; - if (second < beast::kZERO) + if (second < beast::kZero) second = -second; std::stringstream ss; @@ -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/CTID.h b/src/xrpld/rpc/CTID.h index 6c7e95a246..781cd85e29 100644 --- a/src/xrpld/rpc/CTID.h +++ b/src/xrpld/rpc/CTID.h @@ -30,11 +30,11 @@ namespace xrpl::RPC { inline std::optional encodeCTID(uint32_t ledgerSeq, uint32_t txnIndex, uint32_t networkID) noexcept { - constexpr uint32_t kMAX_LEDGER_SEQ = 0x0FFF'FFFF; - constexpr uint32_t kMAX_TXN_INDEX = 0xFFFF; - constexpr uint32_t kMAX_NETWORK_ID = 0xFFFF; + static constexpr uint32_t kMaxLedgerSeq = 0x0FFF'FFFF; + static constexpr uint32_t kMaxTxnIndex = 0xFFFF; + static constexpr uint32_t kMaxNetworkId = 0xFFFF; - if (ledgerSeq > kMAX_LEDGER_SEQ || txnIndex > kMAX_TXN_INDEX || networkID > kMAX_NETWORK_ID) + if (ledgerSeq > kMaxLedgerSeq || txnIndex > kMaxTxnIndex || networkID > kMaxNetworkId) return std::nullopt; uint64_t const ctidValue = ((0xC000'0000ULL + static_cast(ledgerSeq)) << 32) | @@ -68,8 +68,8 @@ decodeCTID(T const ctid) noexcept if (ctidString.size() != 16) return std::nullopt; - static boost::regex const kHEX_REGEX("^[0-9A-Fa-f]{16}$"); - if (!boost::regex_match(ctidString, kHEX_REGEX)) + static boost::regex const kHexRegex("^[0-9A-Fa-f]{16}$"); + if (!boost::regex_match(ctidString, kHexRegex)) return std::nullopt; try @@ -94,9 +94,9 @@ decodeCTID(T const ctid) noexcept } // Validate CTID prefix. - constexpr uint64_t kCTID_PREFIX_MASK = 0xF000'0000'0000'0000ULL; - constexpr uint64_t kCTID_PREFIX = 0xC000'0000'0000'0000ULL; - if ((ctidValue & kCTID_PREFIX_MASK) != kCTID_PREFIX) + static constexpr uint64_t kCtidPrefixMask = 0xF000'0000'0000'0000ULL; + static constexpr uint64_t kCtidPrefix = 0xC000'0000'0000'0000ULL; + if ((ctidValue & kCtidPrefixMask) != kCtidPrefix) return std::nullopt; uint32_t const ledgerSeq = static_cast((ctidValue >> 32) & 0x0FFF'FFFF); diff --git a/src/xrpld/rpc/ServerHandler.h b/src/xrpld/rpc/ServerHandler.h index 6b4cc34cc5..0aac05ea44 100644 --- a/src/xrpld/rpc/ServerHandler.h +++ b/src/xrpld/rpc/ServerHandler.h @@ -46,8 +46,8 @@ public: std::uint16_t port = 0; std::string user; std::string password; - std::string admin_user; - std::string admin_password; + std::string adminUser; + std::string adminPassword; }; // Configuration when acting in client role @@ -72,9 +72,9 @@ private: Setup setup_; Endpoints endpoints_; JobQueue& jobQueue_; - beast::insight::Counter rpc_requests_; - beast::insight::Event rpc_size_; - beast::insight::Event rpc_time_; + beast::insight::Counter rpcRequests_; + beast::insight::Event rpcSize_; + beast::insight::Event rpcTime_; std::mutex mutex_; std::condition_variable condition_; bool stopped_{false}; diff --git a/src/xrpld/rpc/detail/AccountAssets.cpp b/src/xrpld/rpc/detail/AccountAssets.cpp index 5bc4360a0e..67b9174fe3 100644 --- a/src/xrpld/rpc/detail/AccountAssets.cpp +++ b/src/xrpld/rpc/detail/AccountAssets.cpp @@ -32,7 +32,7 @@ accountSourceAssets( auto& saBalance = rspEntry.getBalance(); // Filter out non - if (saBalance > beast::kZERO + if (saBalance > beast::kZero // Have IOUs to send. || (rspEntry.getLimitPeer() // Peer extends credit. diff --git a/src/xrpld/rpc/detail/AssetCache.h b/src/xrpld/rpc/detail/AssetCache.h index 9112d78715..dd53620cdf 100644 --- a/src/xrpld/rpc/detail/AssetCache.h +++ b/src/xrpld/rpc/detail/AssetCache.h @@ -56,10 +56,10 @@ private: { AccountID account; LineDirection direction; - std::size_t hash_value; + std::size_t hashValue; AccountKey(AccountID const& account, LineDirection direction, std::size_t hash) - : account(account), direction(direction), hash_value(hash) + : account(account), direction(direction), hashValue(hash) { } @@ -71,14 +71,14 @@ private: bool operator==(AccountKey const& lhs) const { - return hash_value == lhs.hash_value && account == lhs.account && + return hashValue == lhs.hashValue && account == lhs.account && direction == lhs.direction; } [[nodiscard]] std::size_t getHash() const { - return hash_value; + return hashValue; } struct Hash 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..23eb8fdeec 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"); @@ -75,287 +75,296 @@ handlerFrom() HandlerImpl::maxApiVer}; } -Handler const kHANDLER_ARRAY[]{ +Handler const kHandlerArray[]{ // Some handlers not specified here are added to the table via addHandler() // Request-response methods {.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 @@ -373,7 +382,7 @@ private: { XRPL_ASSERT(minVer <= maxVer, "xrpl::RPC::HandlerTable : valid API version range"); XRPL_ASSERT( - maxVer <= RPC::kAPI_MAXIMUM_VALID_VERSION, + maxVer <= RPC::kApiMaximumValidVersion, "xrpl::RPC::HandlerTable : valid max API version"); return std::any_of( @@ -409,15 +418,15 @@ public: static HandlerTable const& instance() { - static HandlerTable const kHANDLER_TABLE(kHANDLER_ARRAY); - return kHANDLER_TABLE; + static HandlerTable const kHandlerTable(kHandlerArray); + return kHandlerTable; } [[nodiscard]] Handler const* getHandler(unsigned version, bool betaEnabled, std::string const& name) const { - if (version < RPC::kAPI_MINIMUM_SUPPORTED_VERSION || - version > (betaEnabled ? RPC::kAPI_BETA_VERSION : RPC::kAPI_MAXIMUM_SUPPORTED_VERSION)) + if (version < RPC::kApiMinimumSupportedVersion || + version > (betaEnabled ? RPC::kApiBetaVersion : RPC::kApiMaximumSupportedVersion)) return nullptr; auto const range = table_.equal_range(name); @@ -446,8 +455,8 @@ private: addHandler() { static_assert(HandlerImpl::minApiVer <= HandlerImpl::maxApiVer); - static_assert(HandlerImpl::maxApiVer <= RPC::kAPI_MAXIMUM_VALID_VERSION); - static_assert(RPC::kAPI_MINIMUM_SUPPORTED_VERSION <= HandlerImpl::minApiVer); + static_assert(HandlerImpl::maxApiVer <= RPC::kApiMaximumValidVersion); + static_assert(RPC::kApiMinimumSupportedVersion <= HandlerImpl::minApiVer); if (overlappingApiVersion( table_.equal_range(HandlerImpl::name), diff --git a/src/xrpld/rpc/detail/Handler.h b/src/xrpld/rpc/detail/Handler.h index 1e1db7bb99..140f421ed3 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, @@ -34,19 +32,19 @@ struct Handler Role role; RPC::Condition condition; - unsigned minApiVer = kAPI_MINIMUM_SUPPORTED_VERSION; - unsigned maxApiVer = kAPI_MAXIMUM_VALID_VERSION; + unsigned minApiVer = kApiMinimumSupportedVersion; + unsigned maxApiVer = kApiMaximumValidVersion; }; 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,9 +78,9 @@ 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) + if (context.ledgerMaster.getValidatedLedgerAge() > Tuning::kMaxValidatedLedgerAge) { if (context.apiVersion == 1) return RpcNoCurrent; @@ -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/LegacyPathFind.cpp b/src/xrpld/rpc/detail/LegacyPathFind.cpp index 83c7c30549..0bfa19a1f4 100644 --- a/src/xrpld/rpc/detail/LegacyPathFind.cpp +++ b/src/xrpld/rpc/detail/LegacyPathFind.cpp @@ -21,13 +21,13 @@ LegacyPathFind::LegacyPathFind(bool isAdmin, Application& app) } auto const& jobCount = app.getJobQueue().getJobCountGE(JtClient); - if (jobCount > Tuning::kMAX_PATHFIND_JOB_COUNT || app.getFeeTrack().isLoadedLocal()) + if (jobCount > Tuning::kMaxPathfindJobCount || app.getFeeTrack().isLoadedLocal()) return; while (true) { int prevVal = inProgress.load(); - if (prevVal >= Tuning::kMAX_PATHFINDS_IN_PROGRESS) + if (prevVal >= Tuning::kMaxPathfindsInProgress) return; if (inProgress.compare_exchange_strong( diff --git a/src/xrpld/rpc/detail/PathRequest.cpp b/src/xrpld/rpc/detail/PathRequest.cpp index 46069ce3bb..06507319f7 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) @@ -101,16 +101,16 @@ PathRequest::~PathRequest() return; std::string fast, full; - if (quick_reply_ != steady_clock::time_point{}) + if (quickReply_ != steady_clock::time_point{}) { fast = " fast:"; - fast += std::to_string(duration_cast(quick_reply_ - created_).count()); + fast += std::to_string(duration_cast(quickReply_ - created_).count()); fast += "ms"; } - if (full_reply_ != steady_clock::time_point{}) + if (fullReply_ != steady_clock::time_point{}) { full = " full:"; - full += std::to_string(duration_cast(full_reply_ - created_).count()); + full += std::to_string(duration_cast(fullReply_ - created_).count()); full += "ms"; } stream << iIdentifier_ << " complete:" << fast << full @@ -180,7 +180,7 @@ PathRequest::isValid(std::shared_ptr const& crCache) if (!raSrcAccount_ || !raDstAccount_) return false; - if (!convert_all_ && (saSendMax_ || saDstAmount_ <= beast::kZERO)) + if (!convertAll_ && (saSendMax_ || saDstAmount_ <= beast::kZero)) { // If send max specified, dst amt must be -1. jvStatus_ = rpcError(RpcDstAmtMalformed); @@ -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) { @@ -210,7 +210,7 @@ PathRequest::isValid(std::shared_ptr const& crCache) return false; } - if (!convert_all_ && saDstAmount_ < STAmount(lrLedger->fees().reserve)) + if (!convertAll_ && saDstAmount_ < STAmount(lrLedger->fees().reserve)) { // Payment must meet reserve. jvStatus_ = rpcError(RpcDstAmtMalformed); @@ -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); @@ -312,9 +312,9 @@ PathRequest::parseJson(json::Value const& jvParams) return PFR_PJ_INVALID; } - convert_all_ = saDstAmount_ == STAmount(saDstAmount_.asset(), 1u, 0, true); + convertAll_ = saDstAmount_ == STAmount(saDstAmount_.asset(), 1u, 0, true); - if (!validAsset(saDstAmount_.asset()) || (!convert_all_ && saDstAmount_ <= beast::kZERO)) + if (!validAsset(saDstAmount_.asset()) || (!convertAll_ && saDstAmount_ <= beast::kZero)) { jvStatus_ = rpcError(RpcDstAmtMalformed); return PFR_PJ_INVALID; @@ -323,7 +323,7 @@ PathRequest::parseJson(json::Value const& jvParams) if (jvParams.isMember(jss::send_max)) { // Send_max requires destination amount to be -1. - if (!convert_all_) + if (!convertAll_) { jvStatus_ = rpcError(RpcDstAmtMalformed); return PFR_PJ_INVALID; @@ -332,7 +332,7 @@ PathRequest::parseJson(json::Value const& jvParams) saSendMax_.emplace(); if (!amountFromJsonNoThrow(*saSendMax_, jvParams[jss::send_max]) || !validAsset(saSendMax_->asset()) || - (*saSendMax_ <= beast::kZERO && + (*saSendMax_ <= beast::kZero && *saSendMax_ != STAmount(saSendMax_->asset(), 1u, 0, true))) { jvStatus_ = rpcError(RpcSendmaxMalformed); @@ -344,7 +344,7 @@ PathRequest::parseJson(json::Value const& jvParams) { json::Value const& jvSrcCurrencies = jvParams[jss::source_currencies]; if (!jvSrcCurrencies.isArray() || jvSrcCurrencies.size() == 0 || - jvSrcCurrencies.size() > RPC::Tuning::kMAX_SRC_CUR) + jvSrcCurrencies.size() > RPC::Tuning::kMaxSrcCur) { jvStatus_ = rpcError(RpcSrcCurMalformed); return PFR_PJ_INVALID; @@ -523,7 +523,7 @@ PathRequest::getPathFinder( // NOLINTEND(bugprone-unchecked-optional-access) if (pathfinder->findPaths(level, continueCallback)) { - pathfinder->computePathRanks(kMAX_PATHS, continueCallback); + pathfinder->computePathRanks(kMaxPaths, continueCallback); } else { @@ -556,7 +556,7 @@ PathRequest::findPaths( [&](TAsset const& a) { if (!sameAccount || a != saDstAmount_.asset()) { - if (sourceAssets.size() >= RPC::Tuning::kMAX_AUTO_SRC_CUR) + if (sourceAssets.size() >= RPC::Tuning::kMaxAutoSrcCur) return false; if constexpr (std::is_same_v) { @@ -577,7 +577,7 @@ PathRequest::findPaths( } } - auto const dstAmount = convertAmount(saDstAmount_, convert_all_); + auto const dstAmount = convertAmount(saDstAmount_, convertAll_); hash_map> currencyMap; for (auto const& asset : sourceAssets) { @@ -596,7 +596,7 @@ PathRequest::findPaths( STPath fullLiquidityPath; auto ps = pathfinder->getBestPaths( - kMAX_PATHS, fullLiquidityPath, context_[asset], asset.getIssuer(), continueCallback); + kMaxPaths, fullLiquidityPath, context_[asset], asset.getIssuer(), continueCallback); context_[asset] = ps; auto const& sourceAccount = [&] { @@ -622,7 +622,7 @@ PathRequest::findPaths( JLOG(journal_.debug()) << iIdentifier_ << " Paths found, calling rippleCalc"; path::RippleCalc::Input rcInput; - if (convert_all_) + if (convertAll_) rcInput.partialPaymentAllowed = true; auto sandbox = std::make_unique(&*cache->getLedger(), TapNone); auto rc = path::RippleCalc::rippleCalculate( @@ -639,7 +639,7 @@ PathRequest::findPaths( app_, &rcInput); - if (!convert_all_ && !fullLiquidityPath.empty() && + if (!convertAll_ && !fullLiquidityPath.empty() && (rc.result() == terNO_LINE || rc.result() == tecPATH_PARTIAL)) { JLOG(journal_.debug()) << iIdentifier_ << " Trying with an extra path element"; @@ -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); + if (convertAll_) + { + 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_) @@ -751,39 +754,39 @@ PathRequest::doUpdate( // first pass if (loaded || fast) { - iLevel_ = app_.config().PATH_SEARCH_FAST; + iLevel_ = app_.config().pathSearchFast; } else { - iLevel_ = app_.config().PATH_SEARCH; + iLevel_ = app_.config().pathSearch; } } - else if ((iLevel_ == app_.config().PATH_SEARCH_FAST) && !fast) + else if ((iLevel_ == app_.config().pathSearchFast) && !fast) { // leaving fast pathfinding - iLevel_ = app_.config().PATH_SEARCH; - if (loaded && (iLevel_ > app_.config().PATH_SEARCH_FAST)) + iLevel_ = app_.config().pathSearch; + if (loaded && (iLevel_ > app_.config().pathSearchFast)) --iLevel_; } else if (bLastSuccess_) { // decrement, if possible - if (iLevel_ > app_.config().PATH_SEARCH || - (loaded && (iLevel_ > app_.config().PATH_SEARCH_FAST))) + if (iLevel_ > app_.config().pathSearch || + (loaded && (iLevel_ > app_.config().pathSearchFast))) --iLevel_; } else { // adjust as needed - if (!loaded && (iLevel_ < app_.config().PATH_SEARCH_MAX)) + if (!loaded && (iLevel_ < app_.config().pathSearchMax)) ++iLevel_; - if (loaded && (iLevel_ > app_.config().PATH_SEARCH_FAST)) + if (loaded && (iLevel_ > app_.config().pathSearchFast)) --iLevel_; } 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; @@ -795,15 +798,15 @@ PathRequest::doUpdate( newStatus = rpcError(RpcInternal); } - if (fast && quick_reply_ == steady_clock::time_point{}) + if (fast && quickReply_ == steady_clock::time_point{}) { - quick_reply_ = steady_clock::now(); - owner_.reportFast(duration_cast(quick_reply_ - created_)); + quickReply_ = steady_clock::now(); + owner_.reportFast(duration_cast(quickReply_ - created_)); } - else if (!fast && full_reply_ == steady_clock::time_point{}) + else if (!fast && fullReply_ == steady_clock::time_point{}) { - full_reply_ = steady_clock::now(); - owner_.reportFull(duration_cast(full_reply_ - created_)); + fullReply_ = steady_clock::now(); + owner_.reportFull(duration_cast(fullReply_ - created_)); } { diff --git a/src/xrpld/rpc/detail/PathRequest.h b/src/xrpld/rpc/detail/PathRequest.h index b74d4c6ade..de8c10de0e 100644 --- a/src/xrpld/rpc/detail/PathRequest.h +++ b/src/xrpld/rpc/detail/PathRequest.h @@ -140,7 +140,7 @@ private: std::optional domain_; - bool convert_all_{}; + bool convertAll_{}; std::recursive_mutex indexLock_; LedgerIndex lastIndex_; @@ -152,10 +152,10 @@ private: int const iIdentifier_; std::chrono::steady_clock::time_point const created_; - std::chrono::steady_clock::time_point quick_reply_; - std::chrono::steady_clock::time_point full_reply_; + std::chrono::steady_clock::time_point quickReply_; + std::chrono::steady_clock::time_point fullReply_; - static unsigned int const kMAX_PATHS = 4; + static unsigned int const kMaxPaths = 4; }; } // namespace xrpl diff --git a/src/xrpld/rpc/detail/Pathfinder.cpp b/src/xrpld/rpc/detail/Pathfinder.cpp index 9a34cf44f1..daa50cfb07 100644 --- a/src/xrpld/rpc/detail/Pathfinder.cpp +++ b/src/xrpld/rpc/detail/Pathfinder.cpp @@ -94,14 +94,14 @@ namespace { // This is an arbitrary cutoff, and it might cause us to miss other // good paths with this arbitrary cut off. -constexpr std::size_t kPATHFINDER_MAX_COMPLETE_PATHS = 1000; +constexpr std::size_t kPathfinderMaxCompletePaths = 1000; struct AccountCandidate { int priority; AccountID account; - static int const kHIGH_PRIORITY = 10000; + static int const kHighPriority = 10000; }; bool @@ -226,7 +226,7 @@ Pathfinder::Pathfinder( , srcPathAsset_(uSrcPathAsset) , srcIssuer_(uSrcIssuer) , srcAmount_(amountFromPathAsset(uSrcPathAsset, uSrcIssuer, uSrcAccount)) - , convert_all_(convertAllCheck(dstAmount_)) + , convertAll_(convertAllCheck(dstAmount_)) , domain_(domain) , ledger_(cache->getLedger()) , rLCache_(cache) @@ -242,7 +242,7 @@ bool Pathfinder::findPaths(int searchLevel, std::function const& continueCallback) { JLOG(j_.trace()) << "findPaths start"; - if (dstAmount_ == beast::kZERO) + if (dstAmount_ == beast::kZero) { // No need to send zero money. JLOG(j_.debug()) << "Destination amount was zero."; @@ -367,7 +367,7 @@ Pathfinder::findPaths(int searchLevel, std::function const& continue JLOG(j_.trace()) << "findPaths trying payment type " << paymentType; addPathsForType(costedPath.type, continueCallback); - if (completePaths_.size() > kPATHFINDER_MAX_COMPLETE_PATHS) + if (completePaths_.size() > kPathfinderMaxCompletePaths) break; } } @@ -398,7 +398,7 @@ Pathfinder::getPathLiquidity( try { // Compute a path that provides at least the minimum liquidity. - if (convert_all_) + if (convertAll_) rcInput.partialPaymentAllowed = true; auto rc = path::RippleCalc::rippleCalculate( @@ -418,7 +418,7 @@ Pathfinder::getPathLiquidity( qualityOut = getRate(rc.actualAmountOut, rc.actualAmountIn); amountOut = rc.actualAmountOut; - if (!convert_all_) + if (!convertAll_) { // Now try to compute the remaining liquidity. rcInput.partialPaymentAllowed = true; @@ -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; } } @@ -451,7 +451,7 @@ Pathfinder::getPathLiquidity( void Pathfinder::computePathRanks(int maxPaths, std::function const& continueCallback) { - remainingAmount_ = convertAmount(dstAmount_, convert_all_); + remainingAmount_ = convertAmount(dstAmount_, convertAll_); // Must subtract liquidity in default path from remaining amount. try @@ -536,7 +536,7 @@ Pathfinder::rankPaths( rankedPaths.reserve(paths.size()); auto const saMinDstAmount = [&]() -> STAmount { - if (!convert_all_) + if (!convertAll_) { // Ignore paths that move only very small amounts. return smallestUsefulAmount(dstAmount_, maxPaths); @@ -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}); } @@ -581,7 +581,7 @@ Pathfinder::rankPaths( std::ranges::sort( rankedPaths, [&](Pathfinder::PathRank const& a, Pathfinder::PathRank const& b) { // 1) Higher quality (lower cost) is better - if (!convert_all_ && a.quality != b.quality) + if (!convertAll_ && a.quality != b.quality) return a.quality < b.quality; // 2) More liquidity (higher volume) is better @@ -713,15 +713,16 @@ 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); } } - if (remaining > beast::kZERO) + if (remaining > beast::kZero) { XRPL_ASSERT( fullLiquidityPath.empty(), "xrpl::Pathfinder::getBestPaths : second empty path result"); @@ -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; } @@ -794,7 +795,7 @@ Pathfinder::getPathsOut( { } else if ( - rspEntry.getBalance() <= beast::kZERO && + rspEntry.getBalance() <= beast::kZero && (!rspEntry.getLimitPeer() || -rspEntry.getBalance() >= rspEntry.getLimitPeer() || (bAuthRequired && !rspEntry.getAuth()))) @@ -909,26 +910,26 @@ Pathfinder::addPathsForType( break; case NodeType::Accounts: - addLinks(parentPaths, pathsOut, kAF_ADD_ACCOUNTS, continueCallback); + addLinks(parentPaths, pathsOut, kAfAddAccounts, continueCallback); break; case NodeType::Books: - addLinks(parentPaths, pathsOut, kAF_ADD_BOOKS, continueCallback); + addLinks(parentPaths, pathsOut, kAfAddBooks, continueCallback); break; case NodeType::XrpBook: - addLinks(parentPaths, pathsOut, kAF_ADD_BOOKS | kAF_OB_XRP, continueCallback); + addLinks(parentPaths, pathsOut, kAfAddBooks | kAfObXrp, continueCallback); break; case NodeType::DestBook: - addLinks(parentPaths, pathsOut, kAF_ADD_BOOKS | kAF_OB_LAST, continueCallback); + addLinks(parentPaths, pathsOut, kAfAddBooks | kAfObLast, continueCallback); break; case NodeType::Destination: // FIXME: What if a different issuer was specified on the // destination amount? // TODO(tom): what does this even mean? Should it be a JIRA? - addLinks(parentPaths, pathsOut, kAF_ADD_ACCOUNTS | kAF_AC_LAST, continueCallback); + addLinks(parentPaths, pathsOut, kAfAddAccounts | kAfAcLast, continueCallback); break; } @@ -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,9 +1011,9 @@ 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) + if ((addFlags & kAfAddAccounts) != 0u) { // add accounts if (bOnXRP) @@ -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,19 +1032,19 @@ 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); + bool const bDestOnly((addFlags & kAfAcLast) != 0u); AccountCandidates candidates; auto forAssets = [&](AssetType const& assets) { candidates.reserve(assets.size()); - static bool constexpr kIS_LINE = + static constexpr bool kIsLine = std::is_same_v>; - static bool constexpr kIS_MPT = + static constexpr bool kIsMpt = std::is_same_v>; for (auto const& asset : assets) @@ -1051,14 +1052,14 @@ Pathfinder::addLink( if (continueCallback && !continueCallback()) return; auto const& acct = [&]() constexpr { - if constexpr (kIS_LINE) + if constexpr (kIsLine) return asset.getAccountIDPeer(); // Unlike trustline, MPT is not bidirectional - if constexpr (kIS_MPT) + if constexpr (kIsMpt) return getMPTIssuer(asset); }(); auto const direction = [&]() constexpr -> LineDirection { - if constexpr (kIS_LINE) + if constexpr (kIsLine) return asset.getDirectionPeer(); // incoming for MPT since MPT doesn't support // rippling (see LineDirection comments) @@ -1079,27 +1080,27 @@ Pathfinder::addLink( } auto const correctAsset = [&]() { - if constexpr (kIS_LINE) + if constexpr (kIsLine) { return uEndPathAsset.get() == asset.getLimit().template get().currency; } - if constexpr (kIS_MPT) + if constexpr (kIsMpt) { return uEndPathAsset.get() == asset.getMptID(); } }(); auto checkAsset = [&]() { - if constexpr (kIS_LINE) + if constexpr (kIsLine) { return ( - (asset.getBalance() <= beast::kZERO && + (asset.getBalance() <= beast::kZero && (!asset.getLimitPeer() || -asset.getBalance() >= asset.getLimitPeer() || (bRequireAuth && !asset.getAuth()))) || (bIsNoRippleOut && asset.getNoRipple())); } - if constexpr (kIS_MPT) + if constexpr (kIsMpt) { return asset.isZeroBalance() || asset.isMaxedOut() || requireAuth(*ledger_, MPTIssue{asset}, acct); @@ -1122,15 +1123,16 @@ 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); } } else if (!bDestOnly) { // this is a high-priority candidate - candidates.push_back({AccountCandidate::kHIGH_PRIORITY, acct}); + candidates.push_back({AccountCandidate::kHighPriority, acct}); } } else if (acct == srcAccount_) @@ -1210,10 +1212,10 @@ Pathfinder::addLink( } } } - if ((addFlags & kAF_ADD_BOOKS) != 0u) + if ((addFlags & kAfAddBooks) != 0u) { // add order books - if ((addFlags & kAF_OB_XRP) != 0u) + if ((addFlags & kAfObXrp) != 0u) { // to XRP only if (!bOnXRP && @@ -1227,7 +1229,7 @@ Pathfinder::addLink( } else { - bool const bDestOnly = (addFlags & kAF_OB_LAST) != 0; + bool const bDestOnly = (addFlags & kAfObLast) != 0; auto books = app_.getOrderBookDB().getBooksByTakerPays( assetFromPathAsset(uEndPathAsset, uEndIssuer), domain_); JLOG(j_.trace()) << books.size() << " books found from this currency/issuer"; @@ -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/Pathfinder.h b/src/xrpld/rpc/detail/Pathfinder.h index ba1fc453b3..36caab308e 100644 --- a/src/xrpld/rpc/detail/Pathfinder.h +++ b/src/xrpld/rpc/detail/Pathfinder.h @@ -178,7 +178,7 @@ private: /** The amount remaining from srcAccount_ after the default liquidity has been removed. */ STAmount remainingAmount_; - bool convert_all_; + bool convertAll_; std::optional domain_; std::shared_ptr ledger_; @@ -196,19 +196,19 @@ private: beast::Journal const j_; // Add ripple paths - static std::uint32_t const kAF_ADD_ACCOUNTS = 0x001; + static std::uint32_t const kAfAddAccounts = 0x001; // Add order books - static std::uint32_t const kAF_ADD_BOOKS = 0x002; + static std::uint32_t const kAfAddBooks = 0x002; // Add order book to XRP only - static std::uint32_t const kAF_OB_XRP = 0x010; + static std::uint32_t const kAfObXrp = 0x010; // Must link to destination currency - static std::uint32_t const kAF_OB_LAST = 0x040; + static std::uint32_t const kAfObLast = 0x040; // Destination account only - static std::uint32_t const kAF_AC_LAST = 0x080; + static std::uint32_t const kAfAcLast = 0x080; }; } // namespace xrpl diff --git a/src/xrpld/rpc/detail/PathfinderUtils.h b/src/xrpld/rpc/detail/PathfinderUtils.h index ff47de3217..a703127148 100644 --- a/src/xrpld/rpc/detail/PathfinderUtils.h +++ b/src/xrpld/rpc/detail/PathfinderUtils.h @@ -10,10 +10,10 @@ largestAmount(STAmount const& amt) return amt.asset().visit( [&](Issue const& issue) -> STAmount { if (issue.native()) - return kINITIAL_XRP; - return STAmount(amt.asset(), STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET); + return kInitialXrp; + return STAmount(amt.asset(), STAmount::kMaxValue, STAmount::kMaxOffset); }, - [&](MPTIssue const&) { return STAmount(amt.asset(), kMAX_MP_TOKEN_AMOUNT, 0); }); + [&](MPTIssue const&) { return STAmount(amt.asset(), kMaxMpTokenAmount, 0); }); } inline STAmount diff --git a/src/xrpld/rpc/detail/RPCCall.cpp b/src/xrpld/rpc/detail/RPCCall.cpp index 98cb7ee9ba..f405ffe4de 100644 --- a/src/xrpld/rpc/detail/RPCCall.cpp +++ b/src/xrpld/rpc/detail/RPCCall.cpp @@ -128,13 +128,13 @@ private: // optionally followed by a forward slash and some other characters // (the issuer). // https://www.boost.org/doc/libs/1_82_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html - static boost::regex const kRE_CUR_ISS("\\`([][:alnum:]<>(){}[|?!@#$%^&*]{3})(?:/(.+))?\\'"); + static boost::regex const kReCurIss("\\`([][:alnum:]<>(){}[|?!@#$%^&*]{3})(?:/(.+))?\\'"); boost::smatch smMatch; - if (boost::regex_match(strCurrencyIssuer, smMatch, kRE_CUR_ISS)) + if (boost::regex_match(strCurrencyIssuer, smMatch, kReCurIss)) { - 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; @@ -900,11 +900,11 @@ private: parseVault(json::Value const& jvParams) { std::string const strVaultID = jvParams[0u].asString(); - uint256 id = beast::kZERO; + uint256 id = beast::kZero; 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; @@ -1269,7 +1269,7 @@ public: int maxParams; }; - static constexpr Command kCOMMANDS[] = { + static constexpr Command kCommands[] = { // Request-response methods // - Returns an error, or the request. // - To modify the method, provide a new method in the request. @@ -1483,7 +1483,7 @@ public: auto const count = jvParams.size(); - for (auto const& command : kCOMMANDS) + for (auto const& command : kCommands) { if (strMethod == command.name) { @@ -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)) @@ -1702,19 +1702,19 @@ rpcClient( // line client works without a config file } - if (config.rpc_ip) + if (config.rpcIp) { - setup.client.ip = config.rpc_ip->address().to_string(); - setup.client.port = config.rpc_ip->port(); + setup.client.ip = config.rpcIp->address().to_string(); + setup.client.port = config.rpcIp->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; + if (!setup.client.adminUser.empty()) + jvRequest["admin_user"] = setup.client.adminUser; - if (!setup.client.admin_password.empty()) - jvRequest["admin_password"] = setup.client.admin_password; + if (!setup.client.adminPassword.empty()) + jvRequest["admin_password"] = setup.client.adminPassword; if (jvRequest.isObject()) { @@ -1818,7 +1818,7 @@ namespace RPCCall { int fromCommandLine(Config const& config, std::vector const& vCmd, Logs& logs) { - auto const result = rpcClient(vCmd, config, logs, RPC::kAPI_COMMAND_LINE_VERSION); + auto const result = rpcClient(vCmd, config, logs, RPC::kApiCommandLineVersion); std::cout << result.second.toStyledString(); @@ -1860,10 +1860,10 @@ fromNetwork( // Number of bytes to try to receive if no // Content-Length header received - constexpr auto kRPC_REPLY_MAX_BYTES = megabytes(256); + constexpr auto kRpcReplyMaxBytes = megabytes(256); using namespace std::chrono_literals; - auto constexpr kRPC_WEBHOOK_TIMEOUT = 30s; + static constexpr auto kRpcWebhookTimeout = 30s; HTTPClient::request( bSSL, @@ -1879,8 +1879,8 @@ fromNetwork( std::placeholders::_1, std::placeholders::_2, j), - kRPC_REPLY_MAX_BYTES, - kRPC_WEBHOOK_TIMEOUT, + kRpcReplyMaxBytes, + kRpcWebhookTimeout, std::bind( &RPCCallImp::onResponse, callbackFuncP, diff --git a/src/xrpld/rpc/detail/RPCHandler.cpp b/src/xrpld/rpc/detail/RPCHandler.cpp index fb99aa682a..7e30b81fa6 100644 --- a/src/xrpld/rpc/detail/RPCHandler.cpp +++ b/src/xrpld/rpc/detail/RPCHandler.cpp @@ -114,7 +114,7 @@ fillHandler(JsonContext& context, Handler const*& result) { // Count all jobs at jtCLIENT priority or higher. int const jobCount = context.app.getJobQueue().getJobCountGE(JtClient); - if (jobCount > Tuning::kMAX_JOB_QUEUE_CLIENTS) + if (jobCount > Tuning::kMaxJobQueueClients) { JLOG(context.j.debug()) << "Too busy for command: " << jobCount; return RpcTooBusy; @@ -135,7 +135,7 @@ fillHandler(JsonContext& context, Handler const*& result) JLOG(context.j.trace()) << "COMMAND:" << strCommand; JLOG(context.j.trace()) << "REQUEST:" << context.params; - auto handler = getHandler(context.apiVersion, context.app.config().BETA_RPC_API, strCommand); + auto handler = getHandler(context.apiVersion, context.app.config().betaRpcApi, strCommand); if (handler == nullptr) return RpcUnknownCommand; @@ -157,9 +157,9 @@ template Status callMethod(JsonContext& context, Method method, std::string const& name, Object& result) { - static std::atomic kREQUEST_ID{0}; + static std::atomic kRequestId{0}; auto& perfLog = context.app.getPerfLog(); - std::uint64_t const curId = ++kREQUEST_ID; + std::uint64_t const curId = ++kRequestId; try { perfLog.rpcStart(name, curId); @@ -179,8 +179,8 @@ callMethod(JsonContext& context, Method method, std::string const& name, Object& perfLog.rpcError(name, curId); JLOG(context.j.info()) << "Caught throw: " << e.what(); - if (context.loadType == Resource::kFEE_REFERENCE_RPC) - context.loadType = Resource::kFEE_EXCEPTION_RPC; + if (context.loadType == Resource::kFeeReferenceRpc) + context.loadType = Resource::kFeeExceptionRpc; injectError(RpcInternal, result); return RpcInternal; diff --git a/src/xrpld/rpc/detail/RPCHelpers.cpp b/src/xrpld/rpc/detail/RPCHelpers.cpp index 84ecd4e607..d48057a0a8 100644 --- a/src/xrpld/rpc/detail/RPCHelpers.cpp +++ b/src/xrpld/rpc/detail/RPCHelpers.cpp @@ -164,7 +164,7 @@ getSeedFromRPC(json::Value const& params, json::Value& error) using string_to_seed_t = std::function(std::string const&)>; using seed_match_t = std::pair; - static seed_match_t const kSEED_TYPES[]{ + static seed_match_t const kSeedTypes[]{ {jss::passphrase.cStr(), [](std::string const& s) { return parseGenericSeed(s); }}, {jss::seed.cStr(), [](std::string const& s) { return parseBase58(s); }}, {jss::seed_hex.cStr(), [](std::string const& s) { @@ -177,7 +177,7 @@ getSeedFromRPC(json::Value const& params, json::Value& error) // Identify which seed type is in use. seed_match_t const* seedType = nullptr; int count = 0; - for (auto const& t : kSEED_TYPES) + for (auto const& t : kSeedTypes) { if (params.isMember(t.first)) { @@ -219,13 +219,13 @@ keypairForSignature(json::Value const& params, json::Value& error, unsigned int bool const hasKeyType = params.isMember(jss::key_type); // All of the secret types we allow, but only one at a time. - static char const* const kSECRET_TYPES[]{ + static char const* const kSecretTypes[]{ jss::passphrase.cStr(), jss::secret.cStr(), jss::seed.cStr(), jss::seed_hex.cStr()}; // Identify which secret type is in use. char const* secretType = nullptr; int count = 0; - for (auto t : kSECRET_TYPES) + for (auto t : kSecretTypes) { if (params.isMember(t)) { @@ -351,7 +351,7 @@ chooseLedgerEntryType(json::Value const& params) std::pair result{RPC::Status::kOK, ltANY}; if (params.isMember(jss::type)) { - static constexpr auto kTYPES = + static constexpr auto kTypes = std::to_array>({ #pragma push_macro("LEDGER_ENTRY") #undef LEDGER_ENTRY @@ -378,10 +378,10 @@ chooseLedgerEntryType(json::Value const& params) // against the canonical name (case-insensitive) or the RPC name // (case-sensitive). auto const filter = p.asString(); - auto const iter = std::ranges::find_if(kTYPES, [&filter](decltype(kTYPES.front())& t) { + auto const iter = std::ranges::find_if(kTypes, [&filter](decltype(kTypes.front())& t) { return boost::iequals(std::get<0>(t), filter) || std::get<1>(t) == filter; }); - if (iter == kTYPES.end()) + if (iter == kTypes.end()) { result.first = RPC::Status{RpcInvalidParams, "Invalid field 'type'."}; XRPL_ASSERT( diff --git a/src/xrpld/rpc/detail/RPCHelpers.h b/src/xrpld/rpc/detail/RPCHelpers.h index cdebd592c7..781db1b8a5 100644 --- a/src/xrpld/rpc/detail/RPCHelpers.h +++ b/src/xrpld/rpc/detail/RPCHelpers.h @@ -152,7 +152,7 @@ std::optional> keypairForSignature( json::Value const& params, json::Value& error, - unsigned int apiVersion = kAPI_VERSION_IF_UNSPECIFIED); + unsigned int apiVersion = kApiVersionIfUnspecified); /** Parse subscribe/unsubscribe parameters */ diff --git a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp index f8ab42f499..4d0d10a66b 100644 --- a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp +++ b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp @@ -36,7 +36,7 @@ isValidatedOld(LedgerMaster& ledgerMaster, bool standalone) if (standalone) return false; - return ledgerMaster.getValidatedLedgerAge() > Tuning::kMAX_VALIDATED_LEDGER_AGE; + return ledgerMaster.getValidatedLedgerAge() > Tuning::kMaxValidatedLedgerAge; } template @@ -304,9 +304,9 @@ getLedger(T& ledger, LedgerShortcut shortcut, Context const& context) return {RpcNotSynced, "notSynced"}; } - static auto const kMIN_SEQUENCE_GAP = 10; + static auto const kMinSequenceGap = 10; - if (ledger->header().seq + kMIN_SEQUENCE_GAP < context.ledgerMaster.getValidLedgerIndex()) + if (ledger->header().seq + kMinSequenceGap < context.ledgerMaster.getValidLedgerIndex()) { ledger.reset(); if (context.apiVersion == 1) @@ -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,18 +401,18 @@ 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")); // We need a validated ledger to get the hash from the sequence - if (ledgerMaster.getValidatedLedgerAge() > RPC::Tuning::kMAX_VALIDATED_LEDGER_AGE) + if (ledgerMaster.getValidatedLedgerAge() > RPC::Tuning::kMaxValidatedLedgerAge) { if (context.apiVersion == 1) return Unexpected(rpcError(RpcNoCurrent)); @@ -471,7 +471,7 @@ getOrAcquireLedger(RPC::JsonContext const& context) neededHash = hashOfSeq(*ledger, ledgerIndex, j); } XRPL_ASSERT(neededHash, "xrpl::RPC::getOrAcquireLedger : nonzero needed hash"); - ledgerHash = neededHash ? *neededHash : beast::kZERO; // kludge + ledgerHash = neededHash ? *neededHash : beast::kZero; // kludge } // Try to get the desired ledger diff --git a/src/xrpld/rpc/detail/RPCSub.cpp b/src/xrpld/rpc/detail/RPCSub.cpp index 56291ab34b..92e9849939 100644 --- a/src/xrpld/rpc/detail/RPCSub.cpp +++ b/src/xrpld/rpc/detail/RPCSub.cpp @@ -39,7 +39,7 @@ public: std::string strPassword, ServiceRegistry& registry) : RPCSub(source) - , io_context_(ioContext) + , ioContext_(ioContext) , jobQueue_(jobQueue) , url_(strUrl) , username_(std::move(strUsername)) @@ -159,7 +159,7 @@ private: JLOG(j_.info()) << "RPCCall::fromNetwork: " << ip_; RPCCall::fromNetwork( - io_context_, + ioContext_, ip_, port_, username_, @@ -180,7 +180,7 @@ private: } private: - boost::asio::io_context& io_context_; + boost::asio::io_context& ioContext_; JobQueue& jobQueue_; std::string url_; diff --git a/src/xrpld/rpc/detail/Role.cpp b/src/xrpld/rpc/detail/Role.cpp index 998eea15c9..68c5fcc484 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 @@ -27,14 +28,14 @@ bool passwordUnrequiredOrSentCorrect(Port const& port, json::Value const& params) { XRPL_ASSERT( - !(port.admin_nets_v4.empty() && port.admin_nets_v6.empty()), + !(port.adminNetsV4.empty() && port.adminNetsV6.empty()), "xrpl::passwordUnrequiredOrSentCorrect : non-empty admin nets"); - bool const passwordRequired = (!port.admin_user.empty() || !port.admin_password.empty()); + bool const passwordRequired = (!port.adminUser.empty() || !port.adminPassword.empty()); return !passwordRequired || ((params["admin_password"].isString() && - params["admin_password"].asString() == port.admin_password) && - (params["admin_user"].isString() && params["admin_user"].asString() == port.admin_user)); + params["admin_password"].asString() == port.adminPassword) && + (params["admin_user"].isString() && params["admin_user"].asString() == port.adminUser)); } bool @@ -79,7 +80,7 @@ ipAllowed( bool isAdmin(Port const& port, json::Value const& params, beast::IP::Address const& remoteIp) { - return ipAllowed(remoteIp, port.admin_nets_v4, port.admin_nets_v6) && + return ipAllowed(remoteIp, port.adminNetsV4, port.adminNetsV6) && passwordUnrequiredOrSentCorrect(port, params); } @@ -97,7 +98,7 @@ requestRole( if (required == Role::ADMIN) return Role::FORBID; - if (ipAllowed(remoteIp.address(), port.secure_gateway_nets_v4, port.secure_gateway_nets_v6)) + if (ipAllowed(remoteIp.address(), port.secureGatewayNetsV4, port.secureGatewayNetsV6)) { if (!user.empty()) return Role::IDENTIFIED; @@ -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 kForStr{"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(), + kForStr.begin(), + kForStr.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, kForStr.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..0bdece3ec3 100644 --- a/src/xrpld/rpc/detail/ServerHandler.cpp +++ b/src/xrpld/rpc/detail/ServerHandler.cpp @@ -139,9 +139,9 @@ ServerHandler::ServerHandler( , jobQueue_(jobQueue) { auto const& group(cm.group("rpc")); - rpc_requests_ = group->makeCounter("requests"); - rpc_size_ = group->makeEvent("size"); - rpc_time_ = group->makeEvent("time"); + rpcRequests_ = group->makeCounter("requests"); + rpcSize_ = group->makeEvent("size"); + rpcTime_ = group->makeEvent("time"); } ServerHandler::~ServerHandler() @@ -337,10 +337,9 @@ ServerHandler::onWSMessage( { json::Value jv; auto const size = boost::asio::buffer_size(buffers); - if (size > RPC::Tuning::kMAX_REQUEST_SIZE || !json::Reader{}.parse(jv, buffers) || - !jv.isObject()) + if (size > RPC::Tuning::kMaxRequestSize || !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,12 +425,12 @@ ServerHandler::processSession( } // Requests without "command" are invalid. - json::Value jr(json::ObjectValue); - Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; + json::Value jr(json::ValueType::Object); + Resource::Charge loadType = Resource::kFeeReferenceRpc; try { - auto apiVersion = RPC::getAPIVersionNumber(jv, app_.config().BETA_RPC_API); - if (apiVersion == RPC::kAPI_INVALID_VERSION || + auto apiVersion = RPC::getAPIVersionNumber(jv, app_.config().betaRpcApi); + if (apiVersion == RPC::kApiInvalidVersion || (!jv.isMember(jss::command) && !jv.isMember(jss::method)) || (jv.isMember(jss::command) && !jv[jss::command].isString()) || (jv.isMember(jss::method) && !jv[jss::method].isString()) || @@ -440,8 +439,8 @@ ServerHandler::processSession( { jr[jss::type] = jss::response; jr[jss::status] = jss::error; - jr[jss::error] = apiVersion == RPC::kAPI_INVALID_VERSION ? jss::invalid_API_version - : jss::missingCommand; + jr[jss::error] = apiVersion == RPC::kApiInvalidVersion ? jss::invalid_API_version + : jss::missingCommand; jr[jss::request] = jv; if (jv.isMember(jss::id)) jr[jss::id] = jv[jss::id]; @@ -452,13 +451,13 @@ ServerHandler::processSession( if (jv.isMember(jss::api_version)) jr[jss::api_version] = jv[jss::api_version]; - is->getConsumer().charge(Resource::kFEE_MALFORMED_RPC); + is->getConsumer().charge(Resource::kFeeMalformedRpc); return jr; } auto required = RPC::roleRequired( apiVersion, - app_.config().BETA_RPC_API, + app_.config().betaRpcApi, jv.isMember(jss::command) ? jv[jss::command].asString() : jv[jss::method].asString()); auto role = requestRole( required, @@ -468,7 +467,7 @@ ServerHandler::processSession( is->user()); if (Role::FORBID == role) { - loadType = Resource::kFEE_MALFORMED_RPC; + loadType = Resource::kFeeMalformedRpc; jr[jss::result] = rpcError(RpcForbidden); } else @@ -585,18 +584,18 @@ 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; } -json::Int constexpr kMETHOD_NOT_FOUND = -32601; -json::Int constexpr kSERVER_OVERLOADED = -32604; -json::Int constexpr kFORBIDDEN = -32605; -json::Int constexpr kWRONG_VERSION = -32606; +constexpr json::Int kMethodNotFound = -32601; +constexpr json::Int kServerOverloaded = -32604; +constexpr json::Int kForbidden = -32605; +constexpr json::Int kWrongVersion = -32606; void ServerHandler::processRequest( @@ -613,7 +612,7 @@ ServerHandler::processRequest( json::Value jsonOrig; { json::Reader reader; - if ((request.size() > RPC::Tuning::kMAX_REQUEST_SIZE) || !reader.parse(request, jsonOrig) || + if ((request.size() > RPC::Tuning::kMaxRequestSize) || !reader.parse(request, jsonOrig) || !jsonOrig || !jsonOrig.isObject()) { httpReply( @@ -638,7 +637,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,37 +645,37 @@ 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"); + r[jss::error] = makeJsonError(kMethodNotFound, "Method not found"); reply.append(r); continue; } - unsigned apiVersion = RPC::kAPI_VERSION_IF_UNSPECIFIED; + unsigned apiVersion = RPC::kApiVersionIfUnspecified; if (jsonRPC.isMember(jss::params) && jsonRPC[jss::params].isArray() && jsonRPC[jss::params].size() > 0 && jsonRPC[jss::params][0u].isObject()) { apiVersion = RPC::getAPIVersionNumber( - jsonRPC[jss::params][json::UInt(0)], app_.config().BETA_RPC_API); + jsonRPC[jss::params][json::UInt(0)], app_.config().betaRpcApi); } - if (apiVersion == RPC::kAPI_VERSION_IF_UNSPECIFIED && batch) + if (apiVersion == RPC::kApiVersionIfUnspecified && batch) { // for batch request, api_version may be at a different level - apiVersion = RPC::getAPIVersionNumber(jsonRPC, app_.config().BETA_RPC_API); + apiVersion = RPC::getAPIVersionNumber(jsonRPC, app_.config().betaRpcApi); } - if (apiVersion == RPC::kAPI_INVALID_VERSION) + if (apiVersion == RPC::kApiInvalidVersion) { if (!batch) { 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()); + r[jss::error] = makeJsonError(kWrongVersion, jss::invalid_API_version.cStr()); reply.append(r); continue; } @@ -687,7 +686,7 @@ ServerHandler::processRequest( if (jsonRPC.isMember(jss::method) && jsonRPC[jss::method].isString()) { required = RPC::roleRequired( - apiVersion, app_.config().BETA_RPC_API, jsonRPC[jss::method].asString()); + apiVersion, app_.config().betaRpcApi, jsonRPC[jss::method].asString()); } if (jsonRPC.isMember(jss::params) && jsonRPC[jss::params].isArray() && @@ -698,7 +697,7 @@ ServerHandler::processRequest( } else { - role = requestRole(required, port, json::ObjectValue, remoteIPAddress, user); + role = requestRole(required, port, json::ValueType::Object, remoteIPAddress, user); } Resource::Consumer usage; @@ -718,7 +717,7 @@ ServerHandler::processRequest( return; } json::Value r = jsonRPC; - r[jss::error] = makeJsonError(kSERVER_OVERLOADED, "Server is overloaded"); + r[jss::error] = makeJsonError(kServerOverloaded, "Server is overloaded"); reply.append(r); continue; } @@ -726,28 +725,28 @@ ServerHandler::processRequest( if (role == Role::FORBID) { - usage.charge(Resource::kFEE_MALFORMED_RPC); + usage.charge(Resource::kFeeMalformedRpc); if (!batch) { httpReply(403, "Forbidden", output, rpcJ); return; } json::Value r = jsonRPC; - r[jss::error] = makeJsonError(kFORBIDDEN, "Forbidden"); + r[jss::error] = makeJsonError(kForbidden, "Forbidden"); reply.append(r); continue; } if (!jsonRPC.isMember(jss::method) || jsonRPC[jss::method].isNull()) { - usage.charge(Resource::kFEE_MALFORMED_RPC); + usage.charge(Resource::kFeeMalformedRpc); if (!batch) { httpReply(400, "Null method", output, rpcJ); return; } json::Value r = jsonRPC; - r[jss::error] = makeJsonError(kMETHOD_NOT_FOUND, "Null method"); + r[jss::error] = makeJsonError(kMethodNotFound, "Null method"); reply.append(r); continue; } @@ -755,14 +754,14 @@ ServerHandler::processRequest( json::Value const& method = jsonRPC[jss::method]; if (!method.isString()) { - usage.charge(Resource::kFEE_MALFORMED_RPC); + usage.charge(Resource::kFeeMalformedRpc); if (!batch) { httpReply(400, "method is not string", output, rpcJ); return; } json::Value r = jsonRPC; - r[jss::error] = makeJsonError(kMETHOD_NOT_FOUND, "method is not string"); + r[jss::error] = makeJsonError(kMethodNotFound, "method is not string"); reply.append(r); continue; } @@ -770,14 +769,14 @@ ServerHandler::processRequest( std::string const strMethod = method.asString(); if (strMethod.empty()) { - usage.charge(Resource::kFEE_MALFORMED_RPC); + usage.charge(Resource::kFeeMalformedRpc); if (!batch) { httpReply(400, "method is empty", output, rpcJ); return; } json::Value r = jsonRPC; - r[jss::error] = makeJsonError(kMETHOD_NOT_FOUND, "method is empty"); + r[jss::error] = makeJsonError(kMethodNotFound, "method is empty"); reply.append(r); continue; } @@ -794,11 +793,11 @@ 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) { - usage.charge(Resource::kFEE_MALFORMED_RPC); + usage.charge(Resource::kFeeMalformedRpc); httpReply(400, "params unparsable", output, rpcJ); return; } @@ -807,7 +806,7 @@ ServerHandler::processRequest( params = std::move(params[0u]); if (!params.isObjectOrNull()) { - usage.charge(Resource::kFEE_MALFORMED_RPC); + usage.charge(Resource::kFeeMalformedRpc); httpReply(400, "params unparsable", output, rpcJ); return; } @@ -823,7 +822,7 @@ ServerHandler::processRequest( { if (!params[jss::ripplerpc].isString()) { - usage.charge(Resource::kFEE_MALFORMED_RPC); + usage.charge(Resource::kFeeMalformedRpc); if (!batch) { httpReply(400, "ripplerpc is not a string", output, rpcJ); @@ -831,7 +830,7 @@ ServerHandler::processRequest( } json::Value r = jsonRPC; - r[jss::error] = makeJsonError(kMETHOD_NOT_FOUND, "ripplerpc is not a string"); + r[jss::error] = makeJsonError(kMethodNotFound, "ripplerpc is not a string"); reply.append(r); continue; } @@ -854,7 +853,7 @@ ServerHandler::processRequest( params[jss::command] = strMethod; JLOG(journal_.trace()) << "doRpcCommand:" << strMethod << ":" << params; - Resource::Charge loadType = Resource::kFEE_REFERENCE_RPC; + Resource::Charge loadType = Resource::kFeeReferenceRpc; RPC::JsonContext context{ {.j = journal_, @@ -895,7 +894,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)) @@ -994,24 +993,24 @@ ServerHandler::processRequest( auto response = to_string(reply); - rpc_time_.notify( + rpcTime_.notify( std::chrono::duration_cast( std::chrono::high_resolution_clock::now() - start)); - ++rpc_requests_; - rpc_size_.notify(beast::insight::Event::value_type{response.size()}); + ++rpcRequests_; + rpcSize_.notify(beast::insight::Event::value_type{response.size()}); response += '\n'; if (auto stream = journal_.debug()) { - static int const kMAX_SIZE = 10000; - if (response.size() <= kMAX_SIZE) + static int const kMaxSize = 10000; + if (response.size() <= kMaxSize) { stream << "Reply: " << response; } else { - stream << "Reply: " << response.substr(0, kMAX_SIZE); + stream << "Reply: " << response.substr(0, kMaxSize); } } @@ -1061,13 +1060,13 @@ ServerHandler::Setup::makeContexts() { if (p.secure()) { - if (p.ssl_key.empty() && p.ssl_cert.empty() && p.ssl_chain.empty()) + if (p.sslKey.empty() && p.sslCert.empty() && p.sslChain.empty()) { - p.context = makeSslContext(p.ssl_ciphers); + p.context = makeSslContext(p.sslCiphers); } else { - p.context = makeSslContextAuthed(p.ssl_key, p.ssl_cert, p.ssl_chain, p.ssl_ciphers); + p.context = makeSslContextAuthed(p.sslKey, p.sslCert, p.sslChain, p.sslCiphers); } } else @@ -1107,19 +1106,19 @@ toPort(ParsedPort const& parsed, std::ostream& log) p.user = parsed.user; p.password = parsed.password; - p.admin_user = parsed.admin_user; - p.admin_password = parsed.admin_password; - p.ssl_key = parsed.ssl_key; - p.ssl_cert = parsed.ssl_cert; - p.ssl_chain = parsed.ssl_chain; - p.ssl_ciphers = parsed.ssl_ciphers; - p.pmd_options = parsed.pmd_options; - p.ws_queue_limit = parsed.ws_queue_limit; + p.adminUser = parsed.adminUser; + p.adminPassword = parsed.adminPassword; + p.sslKey = parsed.sslKey; + p.sslCert = parsed.sslCert; + p.sslChain = parsed.sslChain; + p.sslCiphers = parsed.sslCiphers; + p.pmdOptions = parsed.pmdOptions; + p.wsQueueLimit = parsed.wsQueueLimit; p.limit = parsed.limit; - p.admin_nets_v4 = parsed.admin_nets_v4; - p.admin_nets_v6 = parsed.admin_nets_v6; - p.secure_gateway_nets_v4 = parsed.secure_gateway_nets_v4; - p.secure_gateway_nets_v6 = parsed.secure_gateway_nets_v6; + p.adminNetsV4 = parsed.adminNetsV4; + p.adminNetsV6 = parsed.adminNetsV6; + p.secureGatewayNetsV4 = parsed.secureGatewayNetsV4; + p.secureGatewayNetsV6 = parsed.secureGatewayNetsV6; return p; } @@ -1222,8 +1221,8 @@ setupClient(ServerHandler::Setup& setup) setup.client.port = iter->port; setup.client.user = iter->user; setup.client.password = iter->password; - setup.client.admin_user = iter->admin_user; - setup.client.admin_password = iter->admin_password; + setup.client.adminUser = iter->adminUser; + setup.client.adminPassword = iter->adminPassword; } // Fill out the overlay portion of the Setup diff --git a/src/xrpld/rpc/detail/TransactionSign.cpp b/src/xrpld/rpc/detail/TransactionSign.cpp index c6ceeee65f..dd0e78c178 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 @@ -310,7 +312,7 @@ checkPayment( std::nullopt, domain, app); - if (pf.findPaths(app.config().PATH_SEARCH_OLD)) + if (pf.findPaths(app.config().pathSearchOld)) { // 4 is the maximum paths pf.computePathRanks(4); @@ -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(); @@ -380,7 +382,7 @@ checkTxJsonFields( } // Check for current ledger. - if (verify && !config.standalone() && (validatedLedgerAge > Tuning::kMAX_VALIDATED_LEDGER_AGE)) + if (verify && !config.standalone() && (validatedLedgerAge > Tuning::kMaxValidatedLedgerAge)) { if (apiVersion == 1) { @@ -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 @@ -487,7 +508,7 @@ transactionPreProcessImpl( validatedLedgerAge, app.config(), app.getFeeTrack(), - getAPIVersionNumber(params, app.config().BETA_RPC_API)); + getAPIVersionNumber(params, app.config().betaRpcApi)); if (RPC::containsError(txJsonResult)) return std::move(txJsonResult); @@ -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( @@ -825,16 +846,16 @@ getTxFee(Application const& app, Config const& config, json::Value tx) if (tx.isMember(jss::Signers)) { if (!tx[jss::Signers].isArray()) - return config.FEES.reference_fee; + return config.fees.referenceFee; - if (tx[jss::Signers].size() > STTx::kMAX_MULTI_SIGNERS) - return config.FEES.reference_fee; + if (tx[jss::Signers].size() > STTx::kMaxMultiSigners) + return config.fees.referenceFee; // check multi-signed signers for (auto& signer : tx[jss::Signers]) { if (!signer.isMember(jss::Signer) || !signer[jss::Signer].isObject()) - return config.FEES.reference_fee; + return config.fees.referenceFee; if (!signer[jss::Signer].isMember(jss::SigningPubKey)) { // autofill SigningPubKey @@ -851,7 +872,7 @@ getTxFee(Application const& app, Config const& config, json::Value tx) STParsedJSONObject parsed(std::string(jss::tx_json), tx); if (!parsed.object.has_value()) { - return config.FEES.reference_fee; + return config.fees.referenceFee; } try @@ -859,13 +880,13 @@ getTxFee(Application const& app, Config const& config, json::Value tx) STTx const& stTx = STTx(std::move(parsed.object.value())); std::string reason; if (!passesLocalChecks(stTx, reason)) - return config.FEES.reference_fee; + return config.fees.referenceFee; return calculateBaseFee(*app.getOpenLedger().current(), stTx); } catch (std::exception& e) { - return config.FEES.reference_fee; + return config.fees.referenceFee; } } @@ -924,8 +945,8 @@ checkFee( if (!doAutoFill) return RPC::missingFieldError("tx_json.Fee"); - int mult = Tuning::kDEFAULT_AUTO_FILL_FEE_MULTIPLIER; - int div = Tuning::kDEFAULT_AUTO_FILL_FEE_DIVISOR; + int mult = Tuning::kDefaultAutoFillFeeMultiplier; + int div = Tuning::kDefaultAutoFillFeeDivisor; if (request.isMember(jss::fee_mult_max)) { if (request[jss::fee_mult_max].isInt()) @@ -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()] = ""; } @@ -1226,7 +1255,9 @@ transactionSignFor( signers.emplaceBack(std::move(signer)); // The array must be sorted and validated. - auto err = sortAndValidateSigners(signers, (*sttx)[sfAccount]); + // For delegated transactions, the delegate account is + // the one forbidden from appearing in its own Signers array. + auto err = sortAndValidateSigners(signers, sttx->getFeePayer()); if (RPC::containsError(err)) return err; } @@ -1241,7 +1272,7 @@ transactionSignFor( return transactionFormatResultImpl(txn.second, apiVersion); } -/** Returns a json::objectValue. */ +/** Returns a json::ValueType::Object. */ json::Value transactionSubmitMultiSigned( json::Value jvRequest, @@ -1274,7 +1305,7 @@ transactionSubmitMultiSigned( validatedLedgerAge, app.config(), app.getFeeTrack(), - getAPIVersionNumber(jvRequest, app.config().BETA_RPC_API)); + getAPIVersionNumber(jvRequest, app.config().betaRpcApi)); if (RPC::containsError(txJsonResult)) return std::move(txJsonResult); @@ -1393,7 +1424,9 @@ transactionSubmitMultiSigned( } // The array must be sorted and validated. - auto err = sortAndValidateSigners(signers, srcAddressID); + // For delegated transactions, getFeePayer() returns sfDelegate, + // that account is the one forbidden from appearing in its own Signers array. + auto err = sortAndValidateSigners(signers, stTx->getFeePayer()); if (RPC::containsError(err)) return err; diff --git a/src/xrpld/rpc/detail/TransactionSign.h b/src/xrpld/rpc/detail/TransactionSign.h index 3d6f41ba30..1fd9e87b54 100644 --- a/src/xrpld/rpc/detail/TransactionSign.h +++ b/src/xrpld/rpc/detail/TransactionSign.h @@ -25,8 +25,8 @@ getCurrentNetworkFee( TxQ const& txQ, Application const& app, json::Value const& tx, - int mult = Tuning::kDEFAULT_AUTO_FILL_FEE_MULTIPLIER, - int div = Tuning::kDEFAULT_AUTO_FILL_FEE_DIVISOR); + int mult = Tuning::kDefaultAutoFillFeeMultiplier, + int div = Tuning::kDefaultAutoFillFeeDivisor); /** Fill in the fee on behalf of the client. This is called when the client does not explicitly specify the fee. @@ -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/detail/Tuning.h b/src/xrpld/rpc/detail/Tuning.h index 45c164efbe..12c09bcb15 100644 --- a/src/xrpld/rpc/detail/Tuning.h +++ b/src/xrpld/rpc/detail/Tuning.h @@ -11,57 +11,58 @@ struct LimitRange }; /** Limits for the account_lines command. */ -static LimitRange constexpr kACCOUNT_LINES = {.rmin = 10, .rDefault = 200, .rmax = 400}; +static constexpr LimitRange kAccountLines = {.rmin = 10, .rDefault = 200, .rmax = 400}; /** Limits for the account_channels command. */ -static LimitRange constexpr kACCOUNT_CHANNELS = {.rmin = 10, .rDefault = 200, .rmax = 400}; +static constexpr LimitRange kAccountChannels = {.rmin = 10, .rDefault = 200, .rmax = 400}; /** Limits for the account_objects command. */ -static LimitRange constexpr kACCOUNT_OBJECTS = {.rmin = 10, .rDefault = 200, .rmax = 400}; +static constexpr LimitRange kAccountObjects = {.rmin = 10, .rDefault = 200, .rmax = 400}; /** Limits for the account_offers command. */ -static LimitRange constexpr kACCOUNT_OFFERS = {.rmin = 10, .rDefault = 200, .rmax = 400}; +static constexpr LimitRange kAccountOffers = {.rmin = 10, .rDefault = 200, .rmax = 400}; /** Limits for the account_tx command. */ -static LimitRange constexpr kACCOUNT_TX = {.rmin = 10, .rDefault = 200, .rmax = 400}; +static constexpr LimitRange kAccountTx = {.rmin = 10, .rDefault = 200, .rmax = 400}; /** Limits for the book_offers command. */ -static LimitRange constexpr kBOOK_OFFERS = {.rmin = 1, .rDefault = 60, .rmax = 100}; +static constexpr LimitRange kBookOffers = {.rmin = 1, .rDefault = 60, .rmax = 100}; /** Limits for the no_ripple_check command. */ -static LimitRange constexpr kNO_RIPPLE_CHECK = {.rmin = 10, .rDefault = 300, .rmax = 400}; +static constexpr LimitRange kNoRippleCheck = {.rmin = 10, .rDefault = 300, .rmax = 400}; /** Limits for the account_nftokens command, in pages. */ -static LimitRange constexpr kACCOUNT_NF_TOKENS = {.rmin = 20, .rDefault = 100, .rmax = 400}; +static constexpr LimitRange kAccountNfTokens = {.rmin = 20, .rDefault = 100, .rmax = 400}; /** Limits for the nft_buy_offers & nft_sell_offers commands. */ -static LimitRange constexpr kNFT_OFFERS = {.rmin = 50, .rDefault = 250, .rmax = 500}; +static constexpr LimitRange kNftOffers = {.rmin = 50, .rDefault = 250, .rmax = 500}; -static int constexpr kDEFAULT_AUTO_FILL_FEE_MULTIPLIER = 10; -static int constexpr kDEFAULT_AUTO_FILL_FEE_DIVISOR = 1; -static int constexpr kMAX_PATHFINDS_IN_PROGRESS = 2; -static int constexpr kMAX_PATHFIND_JOB_COUNT = 50; -static int constexpr kMAX_JOB_QUEUE_CLIENTS = 500; -auto constexpr kMAX_VALIDATED_LEDGER_AGE = std::chrono::minutes{2}; -static int constexpr kMAX_REQUEST_SIZE = 1000000; +static constexpr int kDefaultAutoFillFeeMultiplier = 10; +static constexpr int kDefaultAutoFillFeeDivisor = 1; +static constexpr int kMaxPathfindsInProgress = 2; +static constexpr int kMaxPathfindJobCount = 50; +static constexpr int kMaxJobQueueClients = 500; +constexpr auto kMaxValidatedLedgerAge = std::chrono::minutes{2}; +static constexpr int kMaxRequestSize = 1000000; /** Maximum number of pages in one response from a binary LedgerData request. */ -static int constexpr kBINARY_PAGE_LENGTH = 2048; +static constexpr int kBinaryPageLength = 2048; /** Maximum number of pages in one response from a Json LedgerData request. */ -static int constexpr kJSON_PAGE_LENGTH = 256; +static constexpr int kJsonPageLength = 256; /** Maximum number of pages in a LedgerData response. */ -int constexpr pageLength(bool isBinary) +constexpr int +pageLength(bool isBinary) { - return isBinary ? kBINARY_PAGE_LENGTH : kJSON_PAGE_LENGTH; + return isBinary ? kBinaryPageLength : kJsonPageLength; } /** Maximum number of source currencies allowed in a path find request. */ -static int constexpr kMAX_SRC_CUR = 18; +static constexpr int kMaxSrcCur = 18; /** Maximum number of auto source currencies in a path find request. */ -static int constexpr kMAX_AUTO_SRC_CUR = 88; +static constexpr int kMaxAutoSrcCur = 88; } // namespace xrpl::RPC::Tuning /** @} */ diff --git a/src/xrpld/rpc/detail/WSInfoSub.h b/src/xrpld/rpc/detail/WSInfoSub.h index 336f35957f..c224b93e0e 100644 --- a/src/xrpld/rpc/detail/WSInfoSub.h +++ b/src/xrpld/rpc/detail/WSInfoSub.h @@ -24,8 +24,8 @@ public: auto const& h = ws->request(); if (ipAllowed( beast::IPAddressConversion::fromAsio(ws->remoteEndpoint()).address(), - ws->port().secure_gateway_nets_v4, - ws->port().secure_gateway_nets_v6)) + ws->port().secureGatewayNetsV4, + ws->port().secureGatewayNetsV6)) { auto it = h.find("X-User"); if (it != h.end()) 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..2c00205131 100644 --- a/src/xrpld/rpc/handlers/VaultInfo.cpp +++ b/src/xrpld/rpc/handlers/VaultInfo.cpp @@ -22,7 +22,7 @@ parseVault(json::Value const& params, json::Value& jvResult) auto const hasOwner = params.isMember(jss::owner); auto const hasSeq = params.isMember(jss::seq); - uint256 uNodeIndex = beast::kZERO; + uint256 uNodeIndex = beast::kZero; if (hasVaultId && !hasOwner && !hasSeq) { if (!uNodeIndex.parseHex(params[jss::vault_id].asString())) @@ -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::kMaxUInt)) { RPC::injectError(RpcInvalidParams, jvResult); return std::nullopt; @@ -69,8 +69,8 @@ doVaultInfo(RPC::JsonContext& context) if (!lpLedger) return jvResult; - auto const uNodeIndex = parseVault(context.params, jvResult).value_or(beast::kZERO); - if (uNodeIndex == beast::kZERO) + auto const uNodeIndex = parseVault(context.params, jvResult).value_or(beast::kZero); + if (uNodeIndex == beast::kZero) { jvResult[jss::error] = "malformedRequest"; return jvResult; @@ -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..6d5876322c 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]); @@ -108,10 +108,10 @@ doAccountChannels(RPC::JsonContext& context) return rpcError(RpcActMalformed); unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kACCOUNT_CHANNELS, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kAccountChannels, context)) return *err; - json::Value jsonChannels{json::ArrayValue}; + json::Value jsonChannels{json::ValueType::Array}; struct VisitData { std::vector> items; @@ -120,7 +120,7 @@ doAccountChannels(RPC::JsonContext& context) }; VisitData visitData = {.items = {}, .accountID = accountID, .raDstAccount = raDstAccount}; visitData.items.reserve(limit); - uint256 startAfter = beast::kZERO; + uint256 startAfter = beast::kZero; std::uint64_t startHint = 0; if (params.isMember(jss::marker)) @@ -214,7 +214,7 @@ doAccountChannels(RPC::JsonContext& context) for (auto const& item : visitData.items) addChannel(jsonChannels, *item); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; result[jss::channels] = std::move(jsonChannels); return result; } 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..d0f45cbc6f 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)) @@ -121,7 +121,7 @@ doAccountInfo(RPC::JsonContext& context) } auto const accountID{id.value()}; - static constexpr std::array, 9> kLS_FLAGS{ + static constexpr std::array, 9> kLsFlags{ {{"defaultRipple", lsfDefaultRipple}, {"depositAuth", lsfDepositAuth}, {"disableMasterKey", lsfDisableMaster}, @@ -133,17 +133,17 @@ doAccountInfo(RPC::JsonContext& context) {"requireDestinationTag", lsfRequireDestTag}}}; static constexpr std::array, 4> - kDISALLOW_INCOMING_FLAGS{ + kDisallowIncomingFlags{ {{"disallowIncomingNFTokenOffer", lsfDisallowIncomingNFTokenOffer}, {"disallowIncomingCheck", lsfDisallowIncomingCheck}, {"disallowIncomingPayChan", lsfDisallowIncomingPayChan}, {"disallowIncomingTrustline", lsfDisallowIncomingTrustline}}}; - static constexpr std::pair - kALLOW_TRUST_LINE_CLAWBACK_FLAG{"allowTrustLineClawback", lsfAllowTrustLineClawback}; + static constexpr std::pair kAllowTrustLineClawbackFlag{ + "allowTrustLineClawback", lsfAllowTrustLineClawback}; - static constexpr std::pair - kALLOW_TRUST_LINE_LOCKING_FLAG{"allowTrustLineLocking", lsfAllowTrustLineLocking}; + static constexpr std::pair kAllowTrustLineLockingFlag{ + "allowTrustLineLocking", lsfAllowTrustLineLocking}; auto const sleAccepted = ledger->read(keylet::account(accountID)); if (sleAccepted) @@ -158,27 +158,27 @@ 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}; - for (auto const& lsf : kLS_FLAGS) + json::Value acctFlags{json::ValueType::Object}; + for (auto const& lsf : kLsFlags) acctFlags[lsf.first.data()] = sleAccepted->isFlag(lsf.second); - for (auto const& lsf : kDISALLOW_INCOMING_FLAGS) + for (auto const& lsf : kDisallowIncomingFlags) acctFlags[lsf.first.data()] = sleAccepted->isFlag(lsf.second); if (ledger->rules().enabled(featureClawback)) { - acctFlags[kALLOW_TRUST_LINE_CLAWBACK_FLAG.first.data()] = - sleAccepted->isFlag(kALLOW_TRUST_LINE_CLAWBACK_FLAG.second); + acctFlags[kAllowTrustLineClawbackFlag.first.data()] = + sleAccepted->isFlag(kAllowTrustLineClawbackFlag.second); } if (ledger->rules().enabled(featureTokenEscrow)) { - acctFlags[kALLOW_TRUST_LINE_LOCKING_FLAG.first.data()] = - sleAccepted->isFlag(kALLOW_TRUST_LINE_LOCKING_FLAG.second); + acctFlags[kAllowTrustLineLockingFlag.first.data()] = + sleAccepted->isFlag(kAllowTrustLineLockingFlag.second); } result[jss::account_flags] = std::move(acctFlags); @@ -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..c60ce90201 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 @@ -121,7 +121,7 @@ doAccountLines(RPC::JsonContext& context) } unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kACCOUNT_LINES, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kAccountLines, context)) return *err; // this flag allows the requester to ask incoming trustlines in default @@ -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; @@ -144,7 +144,7 @@ doAccountLines(RPC::JsonContext& context) .raPeerAccount = raPeerAccount, .ignoreDefault = ignoreDefault, .foundCount = 0}; - uint256 startAfter = beast::kZERO; + uint256 startAfter = beast::kZero; std::uint64_t startHint = 0; if (params.isMember(jss::marker)) @@ -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); } } @@ -260,7 +260,7 @@ doAccountLines(RPC::JsonContext& context) for (auto const& item : visitData.items) addLine(jsonLines, item); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; return result; } diff --git a/src/xrpld/rpc/handlers/account/AccountNFTs.cpp b/src/xrpld/rpc/handlers/account/AccountNFTs.cpp index 077001e543..0eb91206f3 100644 --- a/src/xrpld/rpc/handlers/account/AccountNFTs.cpp +++ b/src/xrpld/rpc/handlers/account/AccountNFTs.cpp @@ -58,7 +58,7 @@ doAccountNFTs(RPC::JsonContext& context) return rpcError(RpcActNotFound); unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kACCOUNT_NF_TOKENS, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kAccountNfTokens, context)) return *err; uint256 marker; @@ -81,12 +81,12 @@ 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(); bool markerFound = false; - uint256 const maskedMarker = marker & nft::kPAGE_MASK; + uint256 const maskedMarker = marker & nft::kPageMask; while (cp) { auto arr = cp->getFieldArray(sfNFTokens); @@ -105,7 +105,7 @@ doAccountNFTs(RPC::JsonContext& context) // in that case then we need to compare against the full // 256 bits. uint256 const nftokenID = o[sfNFTokenID]; - uint256 const maskedNftokenID = nftokenID & nft::kPAGE_MASK; + uint256 const maskedNftokenID = nftokenID & nft::kPageMask; if (!pastMarker) { @@ -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); @@ -161,7 +161,7 @@ doAccountNFTs(RPC::JsonContext& context) return RPC::invalidFieldError(jss::marker); result[jss::account] = toBase58(accountID); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; return result; } diff --git a/src/xrpld/rpc/handlers/account/AccountObjects.cpp b/src/xrpld/rpc/handlers/account/AccountObjects.cpp index c930333d91..08a7fbe44a 100644 --- a/src/xrpld/rpc/handlers/account/AccountObjects.cpp +++ b/src/xrpld/rpc/handlers/account/AccountObjects.cpp @@ -59,83 +59,78 @@ 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 - if (firstNFTPage.key != (entryIndex & ~nft::kPAGE_MASK)) + if (firstNFTPage.key != (entryIndex & ~nft::kPageMask)) 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 // to iterating the root directory (and the conventional // behaviour of this RPC function.) Therefore we should // zero entryIndex so as not to terribly confuse things. - entryIndex = beast::kZERO; + entryIndex = beast::kZero; } 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; @@ -261,7 +257,7 @@ doAccountObjects(RPC::JsonContext& context) { json::StaticString name; LedgerEntryType type; - } static constexpr kDELETION_BLOCKERS[] = { + } static constexpr kDeletionBlockers[] = { {.name = jss::check, .type = ltCHECK}, {.name = jss::escrow, .type = ltESCROW}, {.name = jss::nft_page, .type = ltNFTOKEN_PAGE}, @@ -278,9 +274,9 @@ doAccountObjects(RPC::JsonContext& context) }; typeFilter.emplace(); - typeFilter->reserve(std::size(kDELETION_BLOCKERS)); + typeFilter->reserve(std::size(kDeletionBlockers)); - for (auto [name, type] : kDELETION_BLOCKERS) + for (auto [name, type] : kDeletionBlockers) { if (params.isMember(jss::type) && name != params[jss::type]) { @@ -310,7 +306,7 @@ doAccountObjects(RPC::JsonContext& context) } unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kACCOUNT_OBJECTS, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kAccountObjects, context)) return *err; uint256 dirIndex; @@ -337,7 +333,7 @@ doAccountObjects(RPC::JsonContext& context) return RPC::invalidFieldError(jss::marker); result[jss::account] = toBase58(accountID); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; return result; } diff --git a/src/xrpld/rpc/handlers/account/AccountOffers.cpp b/src/xrpld/rpc/handlers/account/AccountOffers.cpp index 6314dc8ec2..85d9470b75 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); @@ -83,12 +83,12 @@ doAccountOffers(RPC::JsonContext& context) return rpcError(RpcActNotFound); unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kACCOUNT_OFFERS, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kAccountOffers, 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; + uint256 startAfter = beast::kZero; std::uint64_t startHint = 0; if (params.isMember(jss::marker)) @@ -177,7 +177,7 @@ doAccountOffers(RPC::JsonContext& context) for (auto const& offer : offers) appendOfferJson(offer, jsonOffers); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; return result; } diff --git a/src/xrpld/rpc/handlers/account/AccountTx.cpp b/src/xrpld/rpc/handlers/account/AccountTx.cpp index 7c8e45f523..6c6d2bb6fd 100644 --- a/src/xrpld/rpc/handlers/account/AccountTx.cpp +++ b/src/xrpld/rpc/handlers/account/AccountTx.cpp @@ -211,7 +211,7 @@ getLedgerRange(RPC::Context& context, std::optional const& ledg std::pair doAccountTxHelp(RPC::Context& context, AccountTxArgs const& args) { - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; AccountTxResult result; @@ -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; } @@ -406,7 +410,7 @@ doAccountTx(RPC::JsonContext& context) return RPC::invalidFieldError(jss::forward); } - if (auto const err = RPC::readLimitField(args.limit, RPC::Tuning::kACCOUNT_TX, context)) + if (auto const err = RPC::readLimitField(args.limit, RPC::Tuning::kAccountTx, context)) return *err; args.binary = params.isMember(jss::binary) && params[jss::binary].asBool(); @@ -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/GatewayBalances.cpp b/src/xrpld/rpc/handlers/account/GatewayBalances.cpp index 7b6d6ca07b..146b9ead5c 100644 --- a/src/xrpld/rpc/handlers/account/GatewayBalances.cpp +++ b/src/xrpld/rpc/handlers/account/GatewayBalances.cpp @@ -72,7 +72,7 @@ doGatewayBalances(RPC::JsonContext& context) if (!id) return rpcError(RpcActMalformed); auto const accountID{id.value()}; - context.loadType = Resource::kFEE_HEAVY_BURDEN_RPC; + context.loadType = Resource::kFeeHeavyBurdenRpc; result[jss::account] = toBase58(accountID); @@ -153,7 +153,7 @@ doGatewayBalances(RPC::JsonContext& context) return; auto& bal = locked[escrow.get().currency]; - if (bal == beast::kZERO) + if (bal == beast::kZero) { // This is needed to set the currency code correctly bal = escrow; @@ -170,8 +170,7 @@ doGatewayBalances(RPC::JsonContext& context) // On overflow return the largest valid STAmount. // Very large sums of STAmount are approximations // anyway. - bal = - STAmount(bal.get(), STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET); + bal = STAmount(bal.get(), STAmount::kMaxValue, STAmount::kMaxOffset); } } } @@ -210,7 +209,7 @@ doGatewayBalances(RPC::JsonContext& context) { // normal negative balance, obligation to customer auto& bal = sums[rs->getBalance().get().currency]; - if (bal == beast::kZERO) + if (bal == beast::kZero) { // This is needed to set the currency code correctly bal = -rs->getBalance(); @@ -227,7 +226,7 @@ doGatewayBalances(RPC::JsonContext& context) // On overflow return the largest valid STAmount. // Very large sums of STAmount are approximations // anyway. - bal = STAmount(bal.asset(), STAmount::kMAX_VALUE, STAmount::kMAX_OFFSET); + bal = STAmount(bal.asset(), STAmount::kMaxValue, STAmount::kMaxOffset); } } } diff --git a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp index 2f4c90e4e7..bb48d3ebd5 100644 --- a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp +++ b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp @@ -75,7 +75,7 @@ doNoRippleCheck(RPC::JsonContext& context) } unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kNO_RIPPLE_CHECK, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kNoRippleCheck, context)) return *err; bool transactions = false; @@ -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/data/LedgerRequest.cpp b/src/xrpld/rpc/handlers/admin/data/LedgerRequest.cpp index 4b15dbdcaf..de1e4439cf 100644 --- a/src/xrpld/rpc/handlers/admin/data/LedgerRequest.cpp +++ b/src/xrpld/rpc/handlers/admin/data/LedgerRequest.cpp @@ -15,7 +15,7 @@ namespace xrpl { json::Value doLedgerRequest(RPC::JsonContext& context) { - context.loadType = Resource::kFEE_HEAVY_BURDEN_RPC; + context.loadType = Resource::kFeeHeavyBurdenRpc; auto res = RPC::getOrAcquireLedger(context); if (!res.has_value()) 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..568dcdaa26 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); } @@ -45,7 +45,7 @@ doConnect(RPC::JsonContext& context) } else { - iPort = kDEFAULT_PEER_PORT; + iPort = kDefaultPeerPort; } auto const ipStr = context.params[jss::ip].asString(); 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/signing/Sign.cpp b/src/xrpld/rpc/handlers/admin/signing/Sign.cpp index 6953dfd3d8..781e160f54 100644 --- a/src/xrpld/rpc/handlers/admin/signing/Sign.cpp +++ b/src/xrpld/rpc/handlers/admin/signing/Sign.cpp @@ -22,7 +22,7 @@ doSign(RPC::JsonContext& context) return RPC::makeError(RpcNotSupported, "Signing is not supported by this server."); } - context.loadType = Resource::kFEE_HEAVY_BURDEN_RPC; + context.loadType = Resource::kFeeHeavyBurdenRpc; NetworkOPs::FailHard const failType = NetworkOPs::doFailHard( context.params.isMember(jss::fail_hard) && context.params[jss::fail_hard].asBool()); diff --git a/src/xrpld/rpc/handlers/admin/signing/SignFor.cpp b/src/xrpld/rpc/handlers/admin/signing/SignFor.cpp index 102cea08b4..35274d51f4 100644 --- a/src/xrpld/rpc/handlers/admin/signing/SignFor.cpp +++ b/src/xrpld/rpc/handlers/admin/signing/SignFor.cpp @@ -23,7 +23,7 @@ doSignFor(RPC::JsonContext& context) return RPC::makeError(RpcNotSupported, "Signing is not supported by this server."); } - context.loadType = Resource::kFEE_HEAVY_BURDEN_RPC; + context.loadType = Resource::kFeeHeavyBurdenRpc; auto const failHard = context.params[jss::fail_hard].asBool(); auto const failType = NetworkOPs::doFailHard(failHard); 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..1b096002bd 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); @@ -103,8 +106,7 @@ LedgerHandler::check() { return RpcTooBusy; } - context_.loadType = - binary ? Resource::kFEE_MEDIUM_BURDEN_RPC : Resource::kFEE_HEAVY_BURDEN_RPC; + context_.loadType = binary ? Resource::kFeeMediumBurdenRpc : Resource::kFeeHeavyBurdenRpc; } if (*queue) @@ -134,19 +136,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..719e635170 100644 --- a/src/xrpld/rpc/handlers/ledger/Ledger.h +++ b/src/xrpld/rpc/handlers/ledger/Ledger.h @@ -40,13 +40,13 @@ public: // NOLINTBEGIN(readability-identifier-naming) static constexpr char name[] = "ledger"; - static constexpr unsigned minApiVer = RPC::kAPI_MINIMUM_SUPPORTED_VERSION; + static constexpr unsigned minApiVer = RPC::kApiMinimumSupportedVersion; - static constexpr unsigned maxApiVer = RPC::kAPI_MAXIMUM_VALID_VERSION; + static constexpr unsigned maxApiVer = RPC::kApiMaximumValidVersion; 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..9a9119d2ba 100644 --- a/src/xrpld/rpc/handlers/ledger/LedgerEntry.cpp +++ b/src/xrpld/rpc/handlers/ledger/LedgerEntry.cpp @@ -203,7 +203,7 @@ parseCredential( return Unexpected(issuer.error()); auto const credType = LedgerEntryHelpers::requiredHexBlob( - cred, jss::credential_type, kMAX_CREDENTIAL_TYPE_LENGTH, "malformedRequest"); + cred, jss::credential_type, kMaxCredentialTypeLength, "malformedRequest"); if (!credType) return Unexpected(credType.error()); @@ -244,7 +244,7 @@ parseAuthorizeCredentials(json::Value const& jv) } std::uint32_t const n = jv.size(); - if (n > kMAX_CREDENTIALS_ARRAY_SIZE) + if (n > kMaxCredentialsArraySize) { return Unexpected( LedgerEntryHelpers::malformedError( @@ -283,10 +283,7 @@ parseAuthorizeCredentials(json::Value const& jv) return Unexpected(issuer.error()); auto const credentialType = LedgerEntryHelpers::requiredHexBlob( - jo, - jss::credential_type, - kMAX_CREDENTIAL_TYPE_LENGTH, - "malformedAuthorizedCredentials"); + jo, jss::credential_type, kMaxCredentialTypeLength, "malformedAuthorizedCredentials"); if (!credentialType) return Unexpected(credentialType.error()); @@ -377,7 +374,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"); @@ -836,7 +833,7 @@ struct LedgerEntry json::Value doLedgerEntry(RPC::JsonContext& context) { - static auto kLEDGER_ENTRY_PARSERS = std::to_array({ + static auto kLedgerEntryParsers = std::to_array({ #pragma push_macro("LEDGER_ENTRY") #undef LEDGER_ENTRY @@ -859,7 +856,7 @@ doLedgerEntry(RPC::JsonContext& context) auto const hasMoreThanOneMember = [&]() { int count = 0; - for (auto const& ledgerEntry : kLEDGER_ENTRY_PARSERS) + for (auto const& ledgerEntry : kLedgerEntryParsers) { if (context.params.isMember(ledgerEntry.fieldName)) { @@ -888,7 +885,7 @@ doLedgerEntry(RPC::JsonContext& context) try { bool found = false; - for (auto const& ledgerEntry : kLEDGER_ENTRY_PARSERS) + for (auto const& ledgerEntry : kLedgerEntryParsers) { if (context.params.isMember(ledgerEntry.fieldName)) { @@ -970,7 +967,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..df6772e4c0 100644 --- a/src/xrpld/rpc/handlers/orderbook/AMMInfo.cpp +++ b/src/xrpld/rpc/handlers/orderbook/AMMInfo.cpp @@ -57,7 +57,7 @@ toIso8601(NetClock::time_point tp) return date::format( "%Y-%Om-%dT%H:%M:%OS%z", date::sys_time( - system_clock::time_point{tp.time_since_epoch() + kEPOCH_OFFSET})); + system_clock::time_point{tp.time_since_epoch() + kEpochOffset})); } json::Value @@ -85,13 +85,13 @@ doAMMInfo(RPC::JsonContext& context) std::optional asset2; std::optional ammID; - constexpr auto kINVALID = [](json::Value const& params) -> bool { + static constexpr auto kInvalid = [](json::Value const& params) -> bool { return (params.isMember(jss::asset) != params.isMember(jss::asset2)) || (params.isMember(jss::asset) == params.isMember(jss::amm_account)); }; // NOTE, identical check for apVersion >= 3 below - if (context.apiVersion < 3 && kINVALID(params)) + if (context.apiVersion < 3 && kInvalid(params)) return Unexpected(RpcInvalidParams); if (params.isMember(jss::asset)) @@ -139,7 +139,7 @@ doAMMInfo(RPC::JsonContext& context) } // NOTE, identical check for apVersion < 3 above - if (context.apiVersion >= 3 && kINVALID(params)) + if (context.apiVersion >= 3 && kInvalid(params)) return Unexpected(RpcInvalidParams); XRPL_ASSERT( @@ -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)) @@ -219,7 +219,7 @@ doAMMInfo(RPC::JsonContext& context) json::Value auction; auto const timeSlot = ammAuctionTimeSlot( ledger->header().parentCloseTime.time_since_epoch().count(), auctionSlot); - auction[jss::time_interval] = timeSlot ? *timeSlot : kAUCTION_SLOT_TIME_INTERVALS; + auction[jss::time_interval] = timeSlot ? *timeSlot : kAuctionSlotTimeIntervals; auctionSlot[sfPrice].setJson(auction[jss::price]); auction[jss::discounted_fee] = auctionSlot[sfDiscountedFee]; auction[jss::account] = to_string(auctionSlot.getAccountID(sfAccount)); diff --git a/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp b/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp index 2c9c53620c..5d031c2c74 100644 --- a/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp +++ b/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp @@ -242,25 +242,25 @@ doBookOffers(RPC::JsonContext& context) } unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kBOOK_OFFERS, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kBookOffers, context)) return *err; bool const bProof(context.params.isMember(jss::proof)); 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, {book.in, book.out, domain}, - takerID ? *takerID : beast::kZERO, + takerID ? *takerID : beast::kZero, bProof, limit, jvMarker, jvResult); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; return jvResult; } diff --git a/src/xrpld/rpc/handlers/orderbook/DepositAuthorized.cpp b/src/xrpld/rpc/handlers/orderbook/DepositAuthorized.cpp index 7e9f891e7f..cc176aaadb 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; @@ -101,7 +101,7 @@ doDepositAuthorized(RPC::JsonContext& context) RPC::expectedFieldMessage( jss::credentials, "is non-empty array of CredentialID(hash256)")); } - if (creds.size() > kMAX_CREDENTIALS_ARRAY_SIZE) + if (creds.size() > kMaxCredentialsArraySize) { return RPC::makeError( RpcInvalidParams, RPC::expectedFieldMessage(jss::credentials, "array too long")); @@ -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/GetAggregatePrice.cpp b/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp index 1d34ca21b2..ae551de1ab 100644 --- a/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp +++ b/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp @@ -51,8 +51,7 @@ iteratePriceData( std::shared_ptr const& sle, std::function const& f) { - using Meta = std::shared_ptr; - constexpr std::uint8_t kMAX_HISTORY = 3; + static constexpr std::uint8_t kMaxHistory = 3; bool isNew = false; std::uint8_t history = 0; @@ -73,7 +72,7 @@ iteratePriceData( // for the Oracle is not found in the inner loop STObject const* prevChain = nullptr; - Meta meta = nullptr; + std::shared_ptr meta = nullptr; while (true) { if (prevChain == chain) @@ -82,7 +81,7 @@ iteratePriceData( if ((oracle == nullptr) || f(*oracle) || isNew) return; - if (++history > kMAX_HISTORY) + if (++history > kMaxHistory) return; uint256 const prevTx = chain->getFieldH256(sfPreviousTxnID); @@ -93,6 +92,8 @@ iteratePriceData( return; // LCOV_EXCL_LINE meta = ledger->txRead(prevTx).second; + if (!meta) + return; prevChain = chain; for (STObject const& node : meta->getFieldArray(sfAffectedNodes)) @@ -152,11 +153,11 @@ doGetAggregatePrice(RPC::JsonContext& context) json::Value result; auto const& params(context.params); - constexpr std::uint16_t kMAX_ORACLES = 200; + static constexpr std::uint16_t kMaxOracles = 200; if (!params.isMember(jss::oracles)) return RPC::missingFieldError(jss::oracles); if (!params[jss::oracles].isArray() || params[jss::oracles].size() == 0 || - params[jss::oracles].size() > kMAX_ORACLES) + params[jss::oracles].size() > kMaxOracles) { RPC::injectError(RpcOracleMalformed, result); return result; @@ -215,7 +216,7 @@ doGetAggregatePrice(RPC::JsonContext& context) return result; } if (params.isMember(jss::trim) && - (std::get(trim) == 0 || std::get(trim) > kMAX_TRIM)) + (std::get(trim) == 0 || std::get(trim) > kMaxTrim)) { RPC::injectError(RpcInvalidParams, result); return result; @@ -341,11 +342,11 @@ doGetAggregatePrice(RPC::JsonContext& context) auto const middle = size / 2; if ((size % 2) == 0) { - static STAmount const kTWO{noIssue(), 2, 0}; + static STAmount const kTwo{noIssue(), 2, 0}; auto it = itAdvance(prices.right.begin(), middle - 1); auto const& a1 = it->first; auto const& a2 = (++it)->first; - return divide(a1 + a2, kTWO, noIssue()); + return divide(a1 + a2, kTwo, noIssue()); } return itAdvance(prices.right.begin(), middle)->first; }(); diff --git a/src/xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h b/src/xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h index ed68ae3ac1..b94e431117 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]; @@ -48,7 +48,7 @@ inline json::Value enumerateNFTOffers(RPC::JsonContext& context, uint256 const& nftId, Keylet const& directory) { unsigned int limit = 0; - if (auto err = readLimitField(limit, RPC::Tuning::kNFT_OFFERS, context)) + if (auto err = readLimitField(limit, RPC::Tuning::kNftOffers, context)) return *err; std::shared_ptr ledger; @@ -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); @@ -125,7 +125,7 @@ enumerateNFTOffers(RPC::JsonContext& context, uint256 const& nftId, Keylet const for (auto const& offer : offers) appendNftOfferJson(context.app, offer, jsonOffers); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; return result; } diff --git a/src/xrpld/rpc/handlers/orderbook/PathFind.cpp b/src/xrpld/rpc/handlers/orderbook/PathFind.cpp index da338dfcc8..3a6b52ee98 100644 --- a/src/xrpld/rpc/handlers/orderbook/PathFind.cpp +++ b/src/xrpld/rpc/handlers/orderbook/PathFind.cpp @@ -15,7 +15,7 @@ namespace xrpl { json::Value doPathFind(RPC::JsonContext& context) { - if (context.app.config().PATH_SEARCH_MAX == 0) + if (context.app.config().pathSearchMax == 0) return rpcError(RpcNotSupported); auto lpLedger = context.ledgerMaster.getClosedLedger(); @@ -34,7 +34,7 @@ doPathFind(RPC::JsonContext& context) if (sSubCommand == "create") { - context.loadType = Resource::kFEE_HEAVY_BURDEN_RPC; + context.loadType = Resource::kFeeHeavyBurdenRpc; context.infoSub->clearRequest(); return context.app.getPathRequestManager().makePathRequest( context.infoSub, lpLedger, context.params); diff --git a/src/xrpld/rpc/handlers/orderbook/RipplePathFind.cpp b/src/xrpld/rpc/handlers/orderbook/RipplePathFind.cpp index 316f26fa32..b7edfb6dbe 100644 --- a/src/xrpld/rpc/handlers/orderbook/RipplePathFind.cpp +++ b/src/xrpld/rpc/handlers/orderbook/RipplePathFind.cpp @@ -23,10 +23,10 @@ namespace xrpl { json::Value doRipplePathFind(RPC::JsonContext& context) { - if (context.app.config().PATH_SEARCH_MAX == 0) + if (context.app.config().pathSearchMax == 0) return rpcError(RpcNotSupported); - context.loadType = Resource::kFEE_HEAVY_BURDEN_RPC; + context.loadType = Resource::kFeeHeavyBurdenRpc; std::shared_ptr lpLedger; json::Value jvResult; @@ -37,7 +37,7 @@ doRipplePathFind(RPC::JsonContext& context) // No ledger specified, use pathfinding defaults // and dispatch to pathfinding engine if (context.app.getLedgerMaster().getValidatedLedgerAge() > - RPC::Tuning::kMAX_VALIDATED_LEDGER_AGE) + RPC::Tuning::kMaxValidatedLedgerAge) { if (context.apiVersion == 1) return rpcError(RpcNoNetwork); 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..aa23a7af26 100644 --- a/src/xrpld/rpc/handlers/server_info/ServerDefinitions.cpp +++ b/src/xrpld/rpc/handlers/server_info/ServerDefinitions.cpp @@ -78,7 +78,7 @@ ServerDefinitions::translate(std::string const& inp) return replace("UINT", "UInt"); } - static std::unordered_map const kREPLACEMENTS{ + static std::unordered_map const kReplacements{ {"OBJECT", "STObject"}, {"ARRAY", "STArray"}, {"ACCOUNT", "AccountID"}, @@ -89,7 +89,7 @@ ServerDefinitions::translate(std::string const& inp) {"XCHAIN_BRIDGE", "XChainBridge"}, }; - if (auto const& it = kREPLACEMENTS.find(inp); it != kREPLACEMENTS.end()) + if (auto const& it = kReplacements.find(inp); it != kReplacements.end()) { return std::string(it->second); } @@ -122,14 +122,14 @@ 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"}}; - for (auto const& [rawName, typeValue] : kS_TYPE_MAP) + for (auto const& [rawName, typeValue] : kSTypeMap) { std::string const typeName = translate(std::string(rawName).substr(4) /* remove STI_ */); defs_[jss::TYPES][typeName] = typeValue; @@ -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 kSortedFields( + xrpl::SField::getKnownCodeToField().begin(), xrpl::SField::getKnownCodeToField().end()); + + for (auto const& [code, field] : kSortedFields) { 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; @@ -374,8 +369,8 @@ ServerDefinitions::ServerDefinitions() : defs_{json::ObjectValue} ServerDefinitions const& getDefinitions() { - static ServerDefinitions const kDEFS{}; - return kDEFS; + static ServerDefinitions const kDefs{}; + return kDefs; } } // namespace detail @@ -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..1868df5d40 100644 --- a/src/xrpld/rpc/handlers/server_info/Version.h +++ b/src/xrpld/rpc/handlers/server_info/Version.h @@ -8,7 +8,7 @@ class VersionHandler { public: explicit VersionHandler(JsonContext& c) - : apiVersion_(c.apiVersion), betaEnabled_(c.app.config().BETA_RPC_API) + : apiVersion_(c.apiVersion), betaEnabled_(c.app.config().betaRpcApi) { } @@ -27,13 +27,13 @@ public: // NOLINTBEGIN(readability-identifier-naming) static constexpr char const* name = "version"; - static constexpr unsigned minApiVer = RPC::kAPI_MINIMUM_SUPPORTED_VERSION; + static constexpr unsigned minApiVer = RPC::kApiMinimumSupportedVersion; - static constexpr unsigned maxApiVer = RPC::kAPI_MAXIMUM_VALID_VERSION; + static constexpr unsigned maxApiVer = RPC::kApiMaximumValidVersion; 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..93840bb6d6 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)) { @@ -197,7 +197,7 @@ doSubscribe(RPC::JsonContext& context) if (!context.app.config().useTxTables()) return rpcError(RpcNotEnabled); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; auto const& req = context.params[jss::account_history_tx_stream]; if (!req.isMember(jss::account) || !req[jss::account].isString()) return rpcError(RpcInvalidParams); @@ -285,13 +285,13 @@ doSubscribe(RPC::JsonContext& context) if ((j.isMember(jss::snapshot) && j[jss::snapshot].asBool()) || (j.isMember(jss::state_now) && j[jss::state_now].asBool())) { - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; std::shared_ptr lpLedger = 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( @@ -299,7 +299,7 @@ doSubscribe(RPC::JsonContext& context) field == jss::asks ? reversed(book) : book, takerID ? *takerID : noAccount(), false, - RPC::Tuning::kBOOK_OFFERS.rDefault, + RPC::Tuning::kBookOffers.rDefault, jvMarker, jvOffers); 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..7a11b728ce 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), sfGeneric).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; @@ -306,7 +306,7 @@ simulateTxn(RPC::JsonContext& context, std::shared_ptr transaction) json::Value doSimulate(RPC::JsonContext& context) { - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; json::Value txJson; // the tx as a JSON @@ -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..f0c4cb2391 100644 --- a/src/xrpld/rpc/handlers/transaction/Submit.cpp +++ b/src/xrpld/rpc/handlers/transaction/Submit.cpp @@ -44,7 +44,7 @@ getFailHard(RPC::JsonContext const& context) json::Value doSubmit(RPC::JsonContext& context) { - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; if (!context.params.isMember(jss::tx_blob)) { @@ -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/SubmitMultiSigned.cpp b/src/xrpld/rpc/handlers/transaction/SubmitMultiSigned.cpp index 80ec0c6702..cc04ed073e 100644 --- a/src/xrpld/rpc/handlers/transaction/SubmitMultiSigned.cpp +++ b/src/xrpld/rpc/handlers/transaction/SubmitMultiSigned.cpp @@ -15,7 +15,7 @@ namespace xrpl { json::Value doSubmitMultiSigned(RPC::JsonContext& context) { - context.loadType = Resource::kFEE_HEAVY_BURDEN_RPC; + context.loadType = Resource::kFeeHeavyBurdenRpc; auto const failHard = context.params[jss::fail_hard].asBool(); auto const failType = NetworkOPs::doFailHard(failHard); 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..c065bc268e 100644 --- a/src/xrpld/rpc/handlers/transaction/Tx.cpp +++ b/src/xrpld/rpc/handlers/transaction/Tx.cpp @@ -77,12 +77,12 @@ doTxHelp(RPC::Context& context, TxArgs args) if (args.ledgerRange) { - constexpr uint16_t kMAX_RANGE = 1000; + static constexpr uint16_t kMaxRange = 1000; if (args.ledgerRange->second < args.ledgerRange->first) return {result, RpcInvalidLgrRange}; - if (args.ledgerRange->second - args.ledgerRange->first > kMAX_RANGE) + if (args.ledgerRange->second - args.ledgerRange->first > kMaxRange) return {result, RpcExcessiveLgrRange}; range = ClosedInterval(args.ledgerRange->first, args.ledgerRange->second); @@ -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); } @@ -205,15 +205,16 @@ populateJsonResponse( auto const& sttx = result.txn->getSTransaction(); if (context.apiVersion > 1) { - constexpr auto kOPTIONS_JSON = - JsonOptions::KIncludeDate | JsonOptions::KDisableApiPriorV2; + static constexpr auto kOptionsJson = + static_cast(JsonOptions::Values::IncludeDate) | + static_cast(JsonOptions::Values::DisableApiPriorV2); if (args.binary) { - response[jss::tx_blob] = result.txn->getJson(kOPTIONS_JSON, true); + response[jss::tx_blob] = result.txn->getJson(kOptionsJson, true); } else { - response[jss::tx_json] = result.txn->getJson(kOPTIONS_JSON); + response[jss::tx_json] = result.txn->getJson(kOptionsJson); RPC::insertDeliverMax( response[jss::tx_json], sttx->getTxnType(), context.apiVersion); } @@ -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..a45046773c 100644 --- a/src/xrpld/rpc/handlers/transaction/TxHistory.cpp +++ b/src/xrpld/rpc/handlers/transaction/TxHistory.cpp @@ -21,7 +21,7 @@ doTxHistory(RPC::JsonContext& context) if (!context.app.config().useTxTables()) return rpcError(RpcNotEnabled); - context.loadType = Resource::kFEE_MEDIUM_BURDEN_RPC; + context.loadType = Resource::kFeeMediumBurdenRpc; if (!context.params.isMember(jss::start)) return rpcError(RpcInvalidParams); @@ -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: diff --git a/src/xrpld/rpc/json_body.h b/src/xrpld/rpc/json_body.h index 9f881cacbc..4520a8bf39 100644 --- a/src/xrpld/rpc/json_body.h +++ b/src/xrpld/rpc/json_body.h @@ -56,7 +56,7 @@ struct JsonBody class writer // NOLINT(readability-identifier-naming) -- Boost.Beast body concept name { - std::string body_string_; + std::string bodyString_; public: using const_buffers_type = boost::asio::const_buffer; @@ -65,7 +65,7 @@ struct JsonBody explicit writer( boost::beast::http::header const& fields, value_type const& value) - : body_string_(to_string(value)) + : bodyString_(to_string(value)) { } @@ -81,7 +81,7 @@ struct JsonBody get(boost::beast::error_code& ec) { ec.assign(0, ec.category()); - return {{const_buffers_type{body_string_.data(), body_string_.size()}, false}}; + return {{const_buffers_type{bodyString_.data(), bodyString_.size()}, false}}; } }; }; diff --git a/src/xrpld/shamap/NodeFamily.cpp b/src/xrpld/shamap/NodeFamily.cpp index aab36b7ca3..a1668e80b2 100644 --- a/src/xrpld/shamap/NodeFamily.cpp +++ b/src/xrpld/shamap/NodeFamily.cpp @@ -30,8 +30,8 @@ NodeFamily::NodeFamily(Application& app, CollectorManager& cm) stopwatch(), app.getJournal("NodeFamilyFulLBelowCache"), cm.collector(), - kFULL_BELOW_TARGET_SIZE, - kFULL_BELOW_EXPIRATION)) + kFullBelowTargetSize, + kFullBelowExpiration)) , tnCache_( std::make_shared( "Node family tree node cache",