diff --git a/.github/scripts/conan/generate_matrix.py b/.github/scripts/conan/generate_matrix.py index 213ea23d3..1d81be767 100755 --- a/.github/scripts/conan/generate_matrix.py +++ b/.github/scripts/conan/generate_matrix.py @@ -4,7 +4,7 @@ import json LINUX_OS = ["heavy", "heavy-arm64"] LINUX_CONTAINERS = [ - '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' ] LINUX_COMPILERS = ["gcc", "clang"] diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 937c5522c..fae804e36 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -49,7 +49,7 @@ jobs: build_type: [Release, Debug] container: [ - '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }', + '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }', ] static: [true] @@ -79,7 +79,7 @@ jobs: uses: ./.github/workflows/reusable-build.yml with: runs_on: heavy - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' conan_profile: gcc build_type: Debug download_ccache: true @@ -97,7 +97,7 @@ jobs: needs: build-and-test runs-on: heavy container: - image: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 + image: ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 steps: - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1 diff --git a/.github/workflows/check-libxrpl.yml b/.github/workflows/check-libxrpl.yml index ad43ad8d9..d87b85983 100644 --- a/.github/workflows/check-libxrpl.yml +++ b/.github/workflows/check-libxrpl.yml @@ -21,7 +21,7 @@ jobs: name: Build Clio / `libXRPL ${{ github.event.client_payload.version }}` runs-on: heavy container: - image: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 + image: ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 steps: - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1 @@ -69,7 +69,7 @@ jobs: needs: build runs-on: heavy container: - image: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 + image: ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 steps: - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0 diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml index 8e1ba6676..5d402e46c 100644 --- a/.github/workflows/clang-tidy.yml +++ b/.github/workflows/clang-tidy.yml @@ -31,7 +31,7 @@ jobs: if: github.event_name != 'push' || contains(github.event.head_commit.message, 'clang-tidy auto fixes') runs-on: heavy container: - image: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 + image: ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 permissions: contents: write diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index c6be3b059..e014a4a4a 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -18,7 +18,7 @@ jobs: build: runs-on: ubuntu-latest container: - image: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 + image: ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 steps: - name: Checkout diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 064c5e7ae..9a7116247 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -55,17 +55,17 @@ jobs: conan_profile: gcc build_type: Release static: true - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' - os: heavy conan_profile: gcc build_type: Debug static: true - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' - os: heavy conan_profile: gcc.ubsan build_type: Release static: false - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' uses: ./.github/workflows/reusable-build-test.yml with: @@ -88,7 +88,7 @@ jobs: uses: ./.github/workflows/reusable-build.yml with: runs_on: heavy - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' conan_profile: gcc build_type: Release download_ccache: false @@ -111,7 +111,7 @@ jobs: include: - os: heavy conan_profile: clang - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' static: true - os: macos15 conan_profile: apple-clang diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index d600735f0..309140c39 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -11,4 +11,4 @@ jobs: uses: XRPLF/actions/.github/workflows/pre-commit.yml@282890f46d6921249d5659dd38babcb0bd8aef48 with: runs_on: heavy - container: '{ "image": "ghcr.io/xrplf/clio-pre-commit:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-pre-commit:6bb4953f1643b999781609ca79d5ec467289c996" }' diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 99bd26534..0ad3a517a 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -29,7 +29,7 @@ jobs: conan_profile: gcc build_type: Release static: true - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' uses: ./.github/workflows/reusable-build-test.yml with: @@ -51,7 +51,7 @@ jobs: uses: ./.github/workflows/reusable-build.yml with: runs_on: heavy - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' conan_profile: gcc build_type: Release download_ccache: false diff --git a/.github/workflows/reusable-release.yml b/.github/workflows/reusable-release.yml index 8e664514d..a95c69c45 100644 --- a/.github/workflows/reusable-release.yml +++ b/.github/workflows/reusable-release.yml @@ -46,7 +46,7 @@ jobs: release: runs-on: heavy container: - image: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 + image: ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 env: GH_REPO: ${{ github.repository }} GH_TOKEN: ${{ github.token }} diff --git a/.github/workflows/reusable-upload-coverage-report.yml b/.github/workflows/reusable-upload-coverage-report.yml index 61befa38b..5e5976da6 100644 --- a/.github/workflows/reusable-upload-coverage-report.yml +++ b/.github/workflows/reusable-upload-coverage-report.yml @@ -28,7 +28,7 @@ jobs: - name: Upload coverage report if: ${{ hashFiles('build/coverage_report.xml') != '' }} - uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2 + uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1 with: files: build/coverage_report.xml fail_ci_if_error: true diff --git a/.github/workflows/sanitizers.yml b/.github/workflows/sanitizers.yml index ba397423b..8a613ba9a 100644 --- a/.github/workflows/sanitizers.yml +++ b/.github/workflows/sanitizers.yml @@ -44,7 +44,7 @@ jobs: uses: ./.github/workflows/reusable-build-test.yml with: runs_on: heavy - container: '{ "image": "ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696" }' + container: '{ "image": "ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996" }' download_ccache: false upload_ccache: false conan_profile: ${{ matrix.compiler }}${{ matrix.sanitizer_ext }} diff --git a/cmake/deps/Boost.cmake b/cmake/deps/Boost.cmake index ce282580d..ed9473882 100644 --- a/cmake/deps/Boost.cmake +++ b/cmake/deps/Boost.cmake @@ -1,4 +1,4 @@ set(Boost_USE_STATIC_LIBS ON) set(Boost_USE_STATIC_RUNTIME ON) -find_package(Boost 1.82 REQUIRED CONFIG COMPONENTS program_options coroutine system log log_setup) +find_package(Boost 1.82 REQUIRED CONFIG COMPONENTS program_options system log log_setup) diff --git a/cmake/deps/OpenSSL.cmake b/cmake/deps/OpenSSL.cmake index 2b735f20b..9176ef1e1 100644 --- a/cmake/deps/OpenSSL.cmake +++ b/cmake/deps/OpenSSL.cmake @@ -1,3 +1,3 @@ -find_package(OpenSSL 1.1.1 REQUIRED CONFIG) +find_package(OpenSSL 3 REQUIRED CONFIG) set_target_properties(OpenSSL::SSL PROPERTIES INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2) diff --git a/conan.lock b/conan.lock index 3bbf1eee4..61398dba9 100644 --- a/conan.lock +++ b/conan.lock @@ -1,58 +1,76 @@ { "version": "0.5", "requires": [ - "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075", + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1778091116.056", "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987", - "xrpl/3.0.0#534d3f65a336109eee929b88962bae4e%1765375071.547", - "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1765850149.926", - "spdlog/1.17.0#bcbaaf7147bda6ad24ffbd1ac3d7142c%1767636069.964", - "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1765850149.46", - "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1765850148.103", + "xrpl/3.2.0-rc3+e5cf1a0#694aadb2bdc6226effdb3b1920463e37%1780518730.129", + "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1778091117.311", + "spdlog/1.17.0#bcbaaf7147bda6ad24ffbd1ac3d7142c%1768312128.781", + "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", "rapidjson/cci.20220822#1b9d8c2256876a154172dc5cfbe447c6%1754325007.656", - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88%1764175361.456", - "openssl/1.1.1w#a8f0792d7c5121b954578a7149d23e03%1756223730.729", - "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1765850143.957", + "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12", + "openssl/3.6.2#4789bbf131b77d0515d15e094c8f697f%1778071755.506", + "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1775040983.408", "minizip/1.2.13#9e87d57804bd372d6d1e32b1871517a3%1754325004.374", "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914", "libuv/1.46.0#dc28c1f653fa197f00db5b577a6f6011%1754325003.592", "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492", "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03", - "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1765850144.736", + "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1778091117.848", "http_parser/2.9.4#98d91690d6fd021e9e624218a85d9d97%1754325001.385", - "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1755784855.585", - "grpc/1.50.1#02291451d1e17200293a409410d1c4e1%1756234248.958", + "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1768312129.152", + "grpc/1.78.1#b1a9e74b145cc471bed4dc64dc6eb2c1%1774467387.342", "fmt/12.1.0#50abab23274d56bb8f42c94b3b9a40c7%1763984116.926", - "doctest/2.4.11#a4211dfc329a16ba9f280f9574025659%1756234220.819", + "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1765850143.772", "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772", "cassandra-cpp-driver/2.17.0#bd3934138689482102c265d01288a316%1764175359.611", - "c-ares/1.34.5#5581c2b62a608b40bb85d965ab3ec7c8%1765850144.336", + "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1774439234.681", "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837", - "boost/1.83.0#91d8b1572534d2c334d6790e3c34d0c1%1764175359.61", + "boost/1.91.0#ea540ca2133d831b560036aa24dece3c%1778091165.282", "benchmark/1.9.4#ce4403f7a24d3e1f907cd9da4b678be4%1754578869.672", - "abseil/20230802.1#90ba607d4ee8fb5fb157c3db540671fc%1764175359.429" + "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196" ], "build_requires": [ - "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075", - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88%1764175361.456", - "cmake/4.2.0#ae0a44f44a1ef9ab68fd4b3e9a1f8671%1765850153.937", - "cmake/3.31.10#313d16a1aa16bbdb2ca0792467214b76%1765850153.479", - "b2/5.3.3#107c15377719889654eb9a162a673975%1765850144.355" + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1778091116.056", + "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12", + "cmake/4.3.0#b939a42e98f593fb34d3a8c5cc860359%1774439249.183", + "cmake/3.31.11#f325c933f618a1fcebc1e1c0babfd1ba%1774439246.719", + "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1774439233.447", + "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196" ], "python_requires": [], "overrides": { - "boost/1.83.0": [ - null, - "boost/1.83.0#91d8b1572534d2c334d6790e3c34d0c1" + "zlib/[>=1.2.11 <2]": [ + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb" ], - "protobuf/3.21.12": [ + "zlib/1.3.2": [ null, - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88" + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb" + ], + "boost/1.91.0": [ + "boost/1.91.0#ea540ca2133d831b560036aa24dece3c" + ], + "protobuf/[>=5.27.0 <7]": [ + "protobuf/6.33.5" ], "lz4/1.9.4": [ "lz4/1.10.0" ], - "sqlite3/3.44.2": [ - "sqlite3/3.49.1" + "boost/[>=1.83.0 <1.91.0]": [ + "boost/1.91.0" + ], + "sqlite3/[>=3.44 <4]": [ + "sqlite3/3.53.0" + ], + "boost/1.83.0": [ + "boost/1.91.0" + ], + "lz4/[>=1.9.4 <2]": [ + "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504" ] }, "config_requires": [] diff --git a/conanfile.py b/conanfile.py index f06e5d018..23fd94a02 100644 --- a/conanfile.py +++ b/conanfile.py @@ -12,16 +12,11 @@ class ClioConan(ConanFile): options = {} requires = [ - "boost/1.83.0", "cassandra-cpp-driver/2.17.0", "fmt/12.1.0", - "grpc/1.50.1", "libbacktrace/cci.20210118", - "openssl/1.1.1w", - "protobuf/3.21.12", "spdlog/1.17.0", - "xrpl/3.0.0", - "zlib/1.3.1", + "xrpl/3.2.0-rc3+e5cf1a0", ] default_options = { @@ -36,7 +31,7 @@ class ClioConan(ConanFile): "protobuf/*:shared": False, "protobuf/*:with_zlib": True, "snappy/*:shared": False, - "xrpl/*:rocksdb": False, + "xrpl/*:rocksdb": True, # TODO: revert to false when includes are fixed in libxrpl "xrpl/*:tests": False, } @@ -45,6 +40,19 @@ class ClioConan(ConanFile): def requirements(self): self.requires("gtest/1.17.0") self.requires("benchmark/1.9.4") + # Clio's own code includes grpc () and openssl (via + # ) headers directly, but xrpl does not re-export them + # (only boost/date/xxhash are required with transitive_headers=True). + # So they must be direct requirements of clio to get their include dirs; + # the version pins match xrpl's, so this does not change any package_id. + self.requires("grpc/1.78.1") + self.requires("openssl/3.6.2") + # Pin the remaining transitive deps to the exact versions xrpl uses. + # override=True only sets the version when the package appears + # transitively (it does not make them direct deps), and matches xrpl's + # force=True boost pin that overrides nudb's `boost < 1.91.0` cap. + self.requires("boost/1.91.0", override=True) + self.requires("zlib/1.3.2", override=True) def configure(self): if self.settings.compiler == "apple-clang": diff --git a/docker/develop/compose.yaml b/docker/develop/compose.yaml index bd18473d8..e841b26b1 100644 --- a/docker/develop/compose.yaml +++ b/docker/develop/compose.yaml @@ -1,6 +1,6 @@ services: clio_develop: - image: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 + image: ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 volumes: - clio_develop_conan_data:/root/.conan2/p - clio_develop_ccache:/root/.ccache diff --git a/docs/build-clio.md b/docs/build-clio.md index 81a43e006..85dcea240 100644 --- a/docs/build-clio.md +++ b/docs/build-clio.md @@ -175,7 +175,7 @@ Open the `index.html` file in your browser to see the documentation pages. It is also possible to build Clio using [Docker](https://www.docker.com/) if you don't want to install all the dependencies on your machine. ```sh -docker run -it ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696 +docker run -it ghcr.io/xrplf/clio-ci:6bb4953f1643b999781609ca79d5ec467289c996 git clone https://github.com/XRPLF/clio cd clio ``` diff --git a/src/app/WebHandlers.cpp b/src/app/WebHandlers.cpp index a84fd97be..f2348a6e0 100644 --- a/src/app/WebHandlers.cpp +++ b/src/app/WebHandlers.cpp @@ -120,7 +120,7 @@ MetricsHandler::operator()( if (!postSuccessful) { return web::ng::Response{ - boost::beast::http::status::too_many_requests, rpc::makeError(rpc::RippledError::rpcTOO_BUSY), request + boost::beast::http::status::too_many_requests, rpc::makeError(rpc::RippledError::RpcTooBusy), request }; } diff --git a/src/app/WebHandlers.hpp b/src/app/WebHandlers.hpp index cd5880cea..4f7162b6e 100644 --- a/src/app/WebHandlers.hpp +++ b/src/app/WebHandlers.hpp @@ -252,7 +252,7 @@ public: } catch (std::exception const&) { return web::ng::Response{ boost::beast::http::status::internal_server_error, - rpc::makeError(rpc::RippledError::rpcINTERNAL), + rpc::makeError(rpc::RippledError::RpcInternal), request }; } diff --git a/src/data/AmendmentCenter.cpp b/src/data/AmendmentCenter.cpp index 4863ff0e5..c8298ed47 100644 --- a/src/data/AmendmentCenter.cpp +++ b/src/data/AmendmentCenter.cpp @@ -57,7 +57,7 @@ supportedAmendments() } bool -lookupAmendment(auto const& allAmendments, std::vector const& ledgerAmendments, std::string_view name) +lookupAmendment(auto const& allAmendments, std::vector const& ledgerAmendments, std::string_view name) { namespace rg = std::ranges; if (auto const am = rg::find(allAmendments, name, &data::Amendment::name); am != rg::end(allAmendments)) @@ -91,7 +91,7 @@ operator std::string_view() const } AmendmentKey:: -operator ripple::uint256() const +operator xrpl::uint256() const { return Amendment::getAmendmentId(name); } @@ -102,14 +102,14 @@ AmendmentCenter::AmendmentCenter(std::shared_ptr const& namespace vs = std::views; rg::copy( - ripple::allAmendments() | vs::transform([&](auto const& p) { + xrpl::allAmendments() | vs::transform([&](auto const& p) { auto const& [name, support] = p; return Amendment{ .name = name, .feature = Amendment::getAmendmentId(name), - .isSupportedByXRPL = support != ripple::AmendmentSupport::Unsupported, + .isSupportedByXRPL = support != xrpl::AmendmentSupport::Unsupported, .isSupportedByClio = rg::find(supportedAmendments(), name) != rg::end(supportedAmendments()), - .isRetired = support == ripple::AmendmentSupport::Retired + .isRetired = support == xrpl::AmendmentSupport::Retired }; }), std::back_inserter(all_) @@ -191,25 +191,25 @@ AmendmentCenter::operator[](AmendmentKey const& key) const return getAmendment(key); } -ripple::uint256 +xrpl::uint256 Amendment::getAmendmentId(std::string_view name) { - return ripple::sha512Half(ripple::Slice(name.data(), name.size())); + return xrpl::sha512Half(xrpl::Slice(name.data(), name.size())); } -std::optional> +std::optional> AmendmentCenter::fetchAmendmentsList(boost::asio::yield_context yield, uint32_t seq) const { // the amendments should always be present on the ledger - auto const amendments = backend_->fetchLedgerObject(ripple::keylet::amendments().key, seq, yield); + auto const amendments = backend_->fetchLedgerObject(xrpl::keylet::amendments().key, seq, yield); if (not amendments.has_value()) throw std::runtime_error("Amendments ledger object must be present in the database"); - ripple::SLE const amendmentsSLE{ - ripple::SerialIter{amendments->data(), amendments->size()}, ripple::keylet::amendments().key + xrpl::SLE const amendmentsSLE{ + xrpl::SerialIter{amendments->data(), amendments->size()}, xrpl::keylet::amendments().key }; - return amendmentsSLE[~ripple::sfAmendments]; + return amendmentsSLE[~xrpl::sfAmendments]; } } // namespace data diff --git a/src/data/AmendmentCenter.hpp b/src/data/AmendmentCenter.hpp index 7b990d877..cf6b976cb 100644 --- a/src/data/AmendmentCenter.hpp +++ b/src/data/AmendmentCenter.hpp @@ -153,6 +153,11 @@ struct Amendments { REGISTER(fixIncludeKeyletFields); REGISTER(fixTokenEscrowV1); REGISTER(LendingProtocol); + REGISTER(MPTokensV2); + REGISTER(PermissionDelegationV1_1); + REGISTER(fixBatchInnerSigs); + REGISTER(fixCleanup3_1_3); + REGISTER(fixCleanup3_2_0); // Obsolete but supported by libxrpl REGISTER(CryptoConditionsSuite); @@ -276,7 +281,7 @@ public: operator[](AmendmentKey const& key) const final; private: - [[nodiscard]] std::optional> + [[nodiscard]] std::optional> fetchAmendmentsList(boost::asio::yield_context yield, uint32_t seq) const; }; diff --git a/src/data/BackendInterface.cpp b/src/data/BackendInterface.cpp index 2a8978fad..7466a7e48 100644 --- a/src/data/BackendInterface.cpp +++ b/src/data/BackendInterface.cpp @@ -64,7 +64,7 @@ BackendInterface::finishWrites(std::uint32_t const ledgerSequence) void BackendInterface::writeLedgerObject(std::string&& key, std::uint32_t const seq, std::string&& blob) { - ASSERT(key.size() == sizeof(ripple::uint256), "Key must be 256 bits"); + ASSERT(key.size() == sizeof(xrpl::uint256), "Key must be 256 bits"); doWriteLedgerObject(std::move(key), seq, std::move(blob)); } @@ -77,14 +77,14 @@ BackendInterface::hardFetchLedgerRangeNoThrow() const // *** state data methods std::optional BackendInterface::fetchLedgerObject( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t const sequence, boost::asio::yield_context yield ) const { auto obj = cache_.get().get(key, sequence); if (obj) { - LOG(log_.trace()) << "Cache hit - " << ripple::strHex(key); + LOG(log_.trace()) << "Cache hit - " << xrpl::strHex(key); return obj; } @@ -99,7 +99,7 @@ BackendInterface::fetchLedgerObject( std::optional BackendInterface::fetchLedgerObjectSeq( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t const sequence, boost::asio::yield_context yield ) const @@ -112,14 +112,14 @@ BackendInterface::fetchLedgerObjectSeq( std::vector BackendInterface::fetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t const sequence, boost::asio::yield_context yield ) const { std::vector results; results.resize(keys.size()); - std::vector misses; + std::vector misses; for (size_t i = 0; i < keys.size(); ++i) { auto obj = cache_.get().get(keys[i], sequence); if (obj) { @@ -144,25 +144,25 @@ BackendInterface::fetchLedgerObjects( } // Fetches the successor to key/index -std::optional +std::optional BackendInterface::fetchSuccessorKey( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const { auto succ = cache_.get().getSuccessor(key, ledgerSequence); if (succ) { - LOG(log_.trace()) << "Cache hit - " << ripple::strHex(key); + LOG(log_.trace()) << "Cache hit - " << xrpl::strHex(key); } else { - LOG(log_.trace()) << "Cache miss - " << ripple::strHex(key); + LOG(log_.trace()) << "Cache miss - " << xrpl::strHex(key); } return succ ? succ->key : doFetchSuccessorKey(key, ledgerSequence, yield); } std::optional BackendInterface::fetchSuccessorObject( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const @@ -180,7 +180,7 @@ BackendInterface::fetchSuccessorObject( BookOffersPage BackendInterface::fetchBookOffers( - ripple::uint256 const& book, + xrpl::uint256 const& book, std::uint32_t const ledgerSequence, std::uint32_t const limit, boost::asio::yield_context yield @@ -189,9 +189,9 @@ BackendInterface::fetchBookOffers( // TODO try to speed this up. This can take a few seconds. The goal is // to get it down to a few hundred milliseconds. BookOffersPage page; - ripple::uint256 const bookEnd = ripple::getQualityNext(book); - ripple::uint256 uTipIndex = book; - std::vector keys; + xrpl::uint256 const bookEnd = xrpl::getQualityNext(book); + xrpl::uint256 uTipIndex = book; + std::vector keys; auto getMillis = [](auto diff) { return std::chrono::duration_cast(diff).count(); }; auto begin = std::chrono::system_clock::now(); std::uint32_t numSucc = 0; @@ -211,17 +211,17 @@ BackendInterface::fetchBookOffers( uTipIndex = offerDir->key; while (keys.size() < limit) { ++numPages; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{offerDir->blob.data(), offerDir->blob.size()}, offerDir->key + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{offerDir->blob.data(), offerDir->blob.size()}, offerDir->key }; - auto indexes = sle.getFieldV256(ripple::sfIndexes); + auto indexes = sle.getFieldV256(xrpl::sfIndexes); keys.insert(keys.end(), indexes.begin(), indexes.end()); - auto next = sle.getFieldU64(ripple::sfIndexNext); + auto next = sle.getFieldU64(xrpl::sfIndexNext); if (next == 0u) { LOG(log_.trace()) << "Next is empty. breaking"; break; } - auto nextKey = ripple::keylet::page(uTipIndex, next); + auto nextKey = xrpl::keylet::page(uTipIndex, next); auto nextDir = fetchLedgerObject(nextKey.key, ledgerSequence, yield); ASSERT(nextDir.has_value(), "Next dir must exist"); offerDir->blob = *nextDir; @@ -233,7 +233,7 @@ BackendInterface::fetchBookOffers( auto mid = std::chrono::system_clock::now(); auto objs = fetchLedgerObjects(keys, ledgerSequence, yield); for (size_t i = 0; i < keys.size() && i < limit; ++i) { - LOG(log_.trace()) << "Key = " << ripple::strHex(keys[i]) << " blob = " << ripple::strHex(objs[i]) + LOG(log_.trace()) << "Key = " << xrpl::strHex(keys[i]) << " blob = " << xrpl::strHex(objs[i]) << " ledgerSequence = " << ledgerSequence; ASSERT(!objs[i].empty(), "Ledger object can't be empty"); page.offers.push_back({keys[i], objs[i]}); @@ -247,7 +247,7 @@ BackendInterface::fetchBookOffers( << ". num pages = " << std::to_string(numPages) << ". Fetching all objects took " << std::to_string(getMillis(end - mid)) << " milliseconds. total time = " << std::to_string(getMillis(end - begin)) << " milliseconds" - << " book = " << ripple::strHex(book); + << " book = " << xrpl::strHex(book); return page; } @@ -305,7 +305,7 @@ BackendInterface::setRange(uint32_t min, uint32_t max, bool force) LedgerPage BackendInterface::fetchLedgerPage( - std::optional const& cursor, + std::optional const& cursor, std::uint32_t const ledgerSequence, std::uint32_t const limit, bool outOfOrder, @@ -314,11 +314,11 @@ BackendInterface::fetchLedgerPage( { LedgerPage page; - std::vector keys; + std::vector keys; bool reachedEnd = false; while (keys.size() < limit && !reachedEnd) { - ripple::uint256 const& curCursor = [&]() { + xrpl::uint256 const& curCursor = [&]() { if (!keys.empty()) return keys.back(); return (cursor ? *cursor : kFIRST_KEY); @@ -339,11 +339,11 @@ BackendInterface::fetchLedgerPage( if (!objects[i].empty()) { page.objects.push_back({keys[i], std::move(objects[i])}); } else if (!outOfOrder) { - LOG(log_.error()) << "Deleted or non-existent object in successor table. key = " << ripple::strHex(keys[i]) + LOG(log_.error()) << "Deleted or non-existent object in successor table. key = " << xrpl::strHex(keys[i]) << " - seq = " << ledgerSequence; std::stringstream msg; for (size_t j = 0; j < objects.size(); ++j) { - msg << " - " << ripple::strHex(keys[j]); + msg << " - " << xrpl::strHex(keys[j]); } LOG(log_.error()) << msg.str(); @@ -357,12 +357,12 @@ BackendInterface::fetchLedgerPage( return page; } -std::optional +std::optional BackendInterface::fetchFees(std::uint32_t const seq, boost::asio::yield_context yield) const { - ripple::Fees fees; + xrpl::Fees fees; - auto key = ripple::keylet::fees().key; + auto key = xrpl::keylet::fees().key; auto bytes = fetchLedgerObject(key, seq, yield); if (!bytes) { @@ -370,17 +370,17 @@ BackendInterface::fetchFees(std::uint32_t const seq, boost::asio::yield_context return {}; } - ripple::SerialIter it(bytes->data(), bytes->size()); - ripple::SLE const sle{it, key}; + xrpl::SerialIter it(bytes->data(), bytes->size()); + xrpl::SLE const sle{it, key}; // XRPFees amendment introduced new fields for fees calculations. // New fields are set and the old fields are removed via `set_fees` tx. // Fallback to old fields if `set_fees` was not yet used to update the fields on this tx. auto hasNewFields = false; { - auto const baseFeeXRP = sle.at(~ripple::sfBaseFeeDrops); - auto const reserveBaseXRP = sle.at(~ripple::sfReserveBaseDrops); - auto const reserveIncrementXRP = sle.at(~ripple::sfReserveIncrementDrops); + auto const baseFeeXRP = sle.at(~xrpl::sfBaseFeeDrops); + auto const reserveBaseXRP = sle.at(~xrpl::sfReserveBaseDrops); + auto const reserveIncrementXRP = sle.at(~xrpl::sfReserveIncrementDrops); if (baseFeeXRP) fees.base = baseFeeXRP->xrp(); @@ -396,9 +396,9 @@ BackendInterface::fetchFees(std::uint32_t const seq, boost::asio::yield_context if (not hasNewFields) { // Fallback to old fields - auto const baseFee = sle.at(~ripple::sfBaseFee); - auto const reserveBase = sle.at(~ripple::sfReserveBase); - auto const reserveIncrement = sle.at(~ripple::sfReserveIncrement); + auto const baseFee = sle.at(~xrpl::sfBaseFee); + auto const reserveBase = sle.at(~xrpl::sfReserveBase); + auto const reserveIncrement = sle.at(~xrpl::sfReserveIncrement); if (baseFee) fees.base = baseFee.value(); diff --git a/src/data/BackendInterface.hpp b/src/data/BackendInterface.hpp index 7a823c76a..c4cda0a20 100644 --- a/src/data/BackendInterface.hpp +++ b/src/data/BackendInterface.hpp @@ -192,9 +192,9 @@ public: * * @param sequence The sequence number to fetch for * @param yield The coroutine context - * @return The ripple::LedgerHeader if found; nullopt otherwise + * @return The xrpl::LedgerHeader if found; nullopt otherwise */ - virtual std::optional + virtual std::optional fetchLedgerBySequence(std::uint32_t sequence, boost::asio::yield_context yield) const = 0; /** @@ -202,10 +202,10 @@ public: * * @param hash The hash to fetch for * @param yield The coroutine context - * @return The ripple::LedgerHeader if found; nullopt otherwise + * @return The xrpl::LedgerHeader if found; nullopt otherwise */ - virtual std::optional - fetchLedgerByHash(ripple::uint256 const& hash, boost::asio::yield_context yield) const = 0; + virtual std::optional + fetchLedgerByHash(xrpl::uint256 const& hash, boost::asio::yield_context yield) const = 0; /** * @brief Fetches the latest ledger sequence. @@ -231,9 +231,9 @@ public: * @param pageSize The maximum number of accounts per page * @param seq The accounts need to exist for this sequence * @param yield The coroutine context - * @return A vector of ripple::uint256 representing the account roots + * @return A vector of xrpl::uint256 representing the account roots */ - virtual std::vector + virtual std::vector fetchAccountRoots( std::uint32_t number, std::uint32_t pageSize, @@ -275,7 +275,7 @@ public: * @param yield The coroutine context * @return Fees if fees are found; nullopt otherwise */ - std::optional + std::optional fetchFees(std::uint32_t seq, boost::asio::yield_context yield) const; /** @@ -286,7 +286,7 @@ public: * @return TransactionAndMetadata if transaction is found; nullopt otherwise */ virtual std::optional - fetchTransaction(ripple::uint256 const& hash, boost::asio::yield_context yield) const = 0; + fetchTransaction(xrpl::uint256 const& hash, boost::asio::yield_context yield) const = 0; /** * @brief Fetches multiple transactions. @@ -296,7 +296,7 @@ public: * @return A vector of TransactionAndMetadata matching the given hashes */ virtual std::vector - fetchTransactions(std::vector const& hashes, boost::asio::yield_context yield) const = 0; + fetchTransactions(std::vector const& hashes, boost::asio::yield_context yield) const = 0; /** * @brief Fetches all transactions for a specific account. @@ -310,7 +310,7 @@ public: */ virtual TransactionsAndCursor fetchAccountTransactions( - ripple::AccountID const& account, + xrpl::AccountID const& account, std::uint32_t limit, bool forward, std::optional const& txnCursor, @@ -332,9 +332,9 @@ public: * * @param ledgerSequence The ledger sequence to fetch for * @param yield The coroutine context - * @return Hashes as ripple::uint256 in a vector + * @return Hashes as xrpl::uint256 in a vector */ - virtual std::vector + virtual std::vector fetchAllTransactionHashesInLedger(std::uint32_t ledgerSequence, boost::asio::yield_context yield) const = 0; /** @@ -346,7 +346,7 @@ public: * @return NFT object on success; nullopt otherwise */ virtual std::optional - fetchNFT(ripple::uint256 const& tokenID, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const = 0; + fetchNFT(xrpl::uint256 const& tokenID, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const = 0; /** * @brief Fetches all transactions for a specific NFT. @@ -360,7 +360,7 @@ public: */ virtual TransactionsAndCursor fetchNFTTransactions( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t limit, bool forward, std::optional const& cursorIn, @@ -380,11 +380,11 @@ public: */ virtual NFTsAndCursor fetchNFTsByIssuer( - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, std::optional const& taxon, std::uint32_t ledgerSequence, std::uint32_t limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield ) const = 0; @@ -400,9 +400,9 @@ public: */ virtual MPTHoldersAndCursor fetchMPTHolders( - ripple::uint192 const& mptID, + xrpl::uint192 const& mptID, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const = 0; @@ -419,7 +419,7 @@ public: * @return The object as a Blob on success; nullopt otherwise */ std::optional - fetchLedgerObject(ripple::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield) const; + fetchLedgerObject(xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield) const; /** * @brief Fetches a specific ledger object sequence. @@ -432,7 +432,7 @@ public: * @return The sequence in unit32_t on success; nullopt otherwise */ std::optional - fetchLedgerObjectSeq(ripple::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield) const; + fetchLedgerObjectSeq(xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield) const; /** * @brief Fetches all ledger objects by their keys. @@ -447,7 +447,7 @@ public: */ std::vector fetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t sequence, boost::asio::yield_context yield ) const; @@ -461,7 +461,7 @@ public: * @return The object as a Blob on success; nullopt otherwise */ virtual std::optional - doFetchLedgerObject(ripple::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield) const = 0; + doFetchLedgerObject(xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield) const = 0; /** * @brief The database-specific implementation for fetching a ledger object sequence. @@ -473,7 +473,7 @@ public: */ virtual std::optional doFetchLedgerObjectSeq( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const = 0; @@ -488,7 +488,7 @@ public: */ virtual std::vector doFetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t sequence, boost::asio::yield_context yield ) const = 0; @@ -515,7 +515,7 @@ public: */ LedgerPage fetchLedgerPage( - std::optional const& cursor, + std::optional const& cursor, std::uint32_t ledgerSequence, std::uint32_t limit, bool outOfOrder, @@ -531,7 +531,7 @@ public: * @return The successor on success; nullopt otherwise */ std::optional - fetchSuccessorObject(ripple::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const; + fetchSuccessorObject(xrpl::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const; /** * @brief Fetches the successor key. @@ -544,8 +544,8 @@ public: * @param yield The coroutine context * @return The successor key on success; nullopt otherwise */ - std::optional - fetchSuccessorKey(ripple::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const; + std::optional + fetchSuccessorKey(xrpl::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const; /** * @brief Database-specific implementation of fetching the successor key @@ -555,8 +555,8 @@ public: * @param yield The coroutine context * @return The successor on success; nullopt otherwise */ - virtual std::optional - doFetchSuccessorKey(ripple::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const = 0; + virtual std::optional + doFetchSuccessorKey(xrpl::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const = 0; /** * @brief Fetches book offers. @@ -569,7 +569,7 @@ public: */ BookOffersPage fetchBookOffers( - ripple::uint256 const& book, + xrpl::uint256 const& book, std::uint32_t ledgerSequence, std::uint32_t limit, boost::asio::yield_context yield @@ -632,7 +632,7 @@ public: * @param blob r-value string serialization of ledger header. */ virtual void - writeLedger(ripple::LedgerHeader const& ledgerHeader, std::string&& blob) = 0; + writeLedger(xrpl::LedgerHeader const& ledgerHeader, std::string&& blob) = 0; /** * @brief Writes a new ledger object. diff --git a/src/data/CassandraBackend.hpp b/src/data/CassandraBackend.hpp index e9b716b6d..f1c5ec391 100644 --- a/src/data/CassandraBackend.hpp +++ b/src/data/CassandraBackend.hpp @@ -116,11 +116,11 @@ public: NFTsAndCursor fetchNFTsByIssuer( - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, std::optional const& taxon, std::uint32_t const ledgerSequence, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield ) const override { @@ -130,7 +130,7 @@ public: if (taxon.has_value()) { auto r = schema_->selectNFTIDsByIssuerTaxon.bind(issuer); r.bindAt(1, *taxon); - r.bindAt(2, cursorIn.value_or(ripple::uint256(0))); + r.bindAt(2, cursorIn.value_or(xrpl::uint256(0))); r.bindAt(3, Limit{limit}); return r; } @@ -139,8 +139,8 @@ public: r.bindAt( 1, std::make_tuple( - cursorIn.has_value() ? ripple::nft::toUInt32(ripple::nft::getTaxon(*cursorIn)) : 0, - cursorIn.value_or(ripple::uint256(0)) + cursorIn.has_value() ? xrpl::nft::toUInt32(xrpl::nft::getTaxon(*cursorIn)) : 0, + cursorIn.value_or(xrpl::uint256(0)) ) ); r.bindAt(2, Limit{limit}); @@ -156,8 +156,8 @@ public: return {}; } - std::vector nftIDs; - for (auto const [nftID] : extract(idQueryResults)) + std::vector nftIDs; + for (auto const [nftID] : extract(idQueryResults)) nftIDs.push_back(nftID); if (nftIDs.empty()) @@ -189,11 +189,11 @@ public: auto const nftUris = executor_.readEach(yield, selectNFTURIStatements); for (auto i = 0u; i < nftIDs.size(); i++) { - if (auto const maybeRow = nftInfos[i].template get(); + if (auto const maybeRow = nftInfos[i].template get(); maybeRow.has_value()) { auto [seq, owner, isBurned] = *maybeRow; NFT nft(nftIDs[i], seq, owner, isBurned); - if (auto const maybeUri = nftUris[i].template get(); maybeUri.has_value()) + if (auto const maybeUri = nftUris[i].template get(); maybeUri.has_value()) nft.uri = *maybeUri; ret.nfts.push_back(nft); } @@ -201,7 +201,7 @@ public: return ret; } - std::vector + std::vector fetchAccountRoots( std::uint32_t number, std::uint32_t pageSize, @@ -209,8 +209,8 @@ public: boost::asio::yield_context yield ) const override { - std::vector liveAccounts; - std::optional lastItem; + std::vector liveAccounts; + std::optional lastItem; while (liveAccounts.size() < number) { Statement const statement = lastItem ? schema_->selectAccountFromToken.bind(*lastItem, Limit{pageSize}) @@ -224,9 +224,9 @@ public: break; } // The results should not contain duplicates, we just filter out deleted accounts - std::vector fullAccounts; - for (auto [account] : extract(results)) { - fullAccounts.push_back(ripple::keylet::account(account).key); + std::vector fullAccounts; + for (auto [account] : extract(results)) { + fullAccounts.push_back(xrpl::keylet::account(account).key); lastItem = account; } auto const objs = this->doFetchLedgerObjects(fullAccounts, seq, yield); diff --git a/src/data/DBHelpers.hpp b/src/data/DBHelpers.hpp index 589e79061..626951880 100644 --- a/src/data/DBHelpers.hpp +++ b/src/data/DBHelpers.hpp @@ -43,10 +43,10 @@ * @brief Struct used to keep track of what to write to account_transactions/account_tx tables. */ struct AccountTransactionsData { - boost::container::flat_set accounts; + boost::container::flat_set accounts; std::uint32_t ledgerSequence{}; std::uint32_t transactionIndex{}; - ripple::uint256 txHash; + xrpl::uint256 txHash; /** * @brief Construct a new AccountTransactionsData object @@ -54,7 +54,7 @@ struct AccountTransactionsData { * @param meta The transaction metadata * @param txHash The transaction hash */ - AccountTransactionsData(ripple::TxMeta const& meta, ripple::uint256 const& txHash) + AccountTransactionsData(xrpl::TxMeta const& meta, xrpl::uint256 const& txHash) : accounts(meta.getAffectedAccounts()) , ledgerSequence(meta.getLgrSeq()) , transactionIndex(meta.getIndex()) @@ -71,10 +71,10 @@ struct AccountTransactionsData { * Gets written to nf_token_transactions table and the like. */ struct NFTTransactionsData { - ripple::uint256 tokenID; + xrpl::uint256 tokenID; std::uint32_t ledgerSequence; std::uint32_t transactionIndex; - ripple::uint256 txHash; + xrpl::uint256 txHash; /** * @brief Construct a new NFTTransactionsData object @@ -83,7 +83,7 @@ struct NFTTransactionsData { * @param meta The transaction metadata * @param txHash The transaction hash */ - NFTTransactionsData(ripple::uint256 const& tokenID, ripple::TxMeta const& meta, ripple::uint256 const& txHash) + NFTTransactionsData(xrpl::uint256 const& tokenID, xrpl::TxMeta const& meta, xrpl::uint256 const& txHash) : tokenID(tokenID), ledgerSequence(meta.getLgrSeq()), transactionIndex(meta.getIndex()), txHash(txHash) { } @@ -101,11 +101,11 @@ struct NFTTransactionsData { * We only set the uri if this is a mint tx, or if we are loading initial state from NFTokenPage objects. */ struct NFTsData { - ripple::uint256 tokenID; + xrpl::uint256 tokenID; std::uint32_t ledgerSequence; std::optional transactionIndex; - ripple::AccountID owner; - std::optional uri; + xrpl::AccountID owner; + std::optional uri; bool isBurned = false; bool onlyUriChanged = false; // Whether only the URI was changed @@ -122,10 +122,10 @@ struct NFTsData { * @param meta The transaction metadata */ NFTsData( - ripple::uint256 const& tokenID, - ripple::AccountID const& owner, - ripple::Blob const& uri, - ripple::TxMeta const& meta + xrpl::uint256 const& tokenID, + xrpl::AccountID const& owner, + xrpl::Blob const& uri, + xrpl::TxMeta const& meta ) : tokenID(tokenID), ledgerSequence(meta.getLgrSeq()), transactionIndex(meta.getIndex()), owner(owner), uri(uri) { @@ -141,7 +141,7 @@ struct NFTsData { * @param meta The transaction metadata * @param isBurned Whether the NFT is burned */ - NFTsData(ripple::uint256 const& tokenID, ripple::AccountID const& owner, ripple::TxMeta const& meta, bool isBurned) + NFTsData(xrpl::uint256 const& tokenID, xrpl::AccountID const& owner, xrpl::TxMeta const& meta, bool isBurned) : tokenID(tokenID) , ledgerSequence(meta.getLgrSeq()) , transactionIndex(meta.getIndex()) @@ -163,10 +163,10 @@ struct NFTsData { * @param uri The URI */ NFTsData( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t const ledgerSequence, - ripple::AccountID const& owner, - ripple::Blob const& uri + xrpl::AccountID const& owner, + xrpl::Blob const& uri ) : tokenID(tokenID), ledgerSequence(ledgerSequence), owner(owner), uri(uri) { @@ -180,7 +180,7 @@ struct NFTsData { * @param uri The new URI * */ - NFTsData(ripple::uint256 const& tokenID, ripple::TxMeta const& meta, ripple::Blob const& uri) + NFTsData(xrpl::uint256 const& tokenID, xrpl::TxMeta const& meta, xrpl::Blob const& uri) : tokenID(tokenID) , ledgerSequence(meta.getLgrSeq()) , transactionIndex(meta.getIndex()) @@ -194,8 +194,8 @@ struct NFTsData { * @brief Represents an MPT and holder pair */ struct MPTHolderData { - ripple::uint192 mptID; - ripple::AccountID holder; + xrpl::uint192 mptID; + xrpl::AccountID holder; }; /** @@ -231,25 +231,25 @@ isBookDir(T const& key, R const& object) if (!isDirNode(object)) return false; - ripple::STLedgerEntry const sle{ripple::SerialIter{object.data(), object.size()}, key}; - return !sle[~ripple::sfOwner].has_value(); + xrpl::STLedgerEntry const sle{xrpl::SerialIter{object.data(), object.size()}, key}; + return !sle[~xrpl::sfOwner].has_value(); } /** * @brief Get the book base. * * @param key The key to get the book base out of - * @return Book base as ripple::uint256 + * @return Book base as xrpl::uint256 */ template -inline ripple::uint256 +inline xrpl::uint256 getBookBase(T const& key) { static constexpr size_t kEY_SIZE = 24; - ASSERT(key.size() == ripple::uint256::size(), "Invalid key size {}", key.size()); + ASSERT(key.size() == xrpl::uint256::size(), "Invalid key size {}", key.size()); - ripple::uint256 ret; + xrpl::uint256 ret; for (size_t i = 0; i < kEY_SIZE; ++i) ret.data()[i] = key.data()[i]; @@ -257,15 +257,15 @@ getBookBase(T const& key) } /** - * @brief Stringify a ripple::uint256. + * @brief Stringify a xrpl::uint256. * * @param input The input value * @return The input value as a string */ inline std::string -uint256ToString(ripple::uint256 const& input) +uint256ToString(xrpl::uint256 const& input) { - return {reinterpret_cast(input.data()), ripple::uint256::size()}; + return {reinterpret_cast(input.data()), xrpl::uint256::size()}; } /** @brief The ripple epoch start timestamp. Midnight on 1st January 2000. */ diff --git a/src/data/KeyspaceBackend.hpp b/src/data/KeyspaceBackend.hpp index eaf74dd96..6d540c9a9 100644 --- a/src/data/KeyspaceBackend.hpp +++ b/src/data/KeyspaceBackend.hpp @@ -117,22 +117,22 @@ public: NFTsAndCursor fetchNFTsByIssuer( - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, std::optional const& taxon, std::uint32_t const ledgerSequence, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield ) const override { - std::vector nftIDs; + std::vector nftIDs; if (taxon.has_value()) { // Keyspace and ScyllaDB uses the same logic for taxon-filtered queries nftIDs = fetchNFTIDsByTaxon(issuer, *taxon, limit, cursorIn, yield); } else { // Amazon Keyspaces Workflow for non-taxon queries - auto const startTaxon = cursorIn.has_value() ? ripple::nft::toUInt32(ripple::nft::getTaxon(*cursorIn)) : 0; - auto const startTokenID = cursorIn.value_or(ripple::uint256(0)); + auto const startTaxon = cursorIn.has_value() ? xrpl::nft::toUInt32(xrpl::nft::getTaxon(*cursorIn)) : 0; + auto const startTokenID = cursorIn.value_or(xrpl::uint256(0)); Statement const firstQuery = schema_->selectNFTIDsByIssuerTaxon.bind(issuer); firstQuery.bindAt(1, startTaxon); @@ -141,7 +141,7 @@ public: auto const firstRes = executor_.read(yield, firstQuery); if (firstRes.has_value()) { - for (auto const [nftID] : extract(*firstRes)) + for (auto const [nftID] : extract(*firstRes)) nftIDs.push_back(nftID); } @@ -153,7 +153,7 @@ public: auto const secondRes = executor_.read(yield, secondQuery); if (secondRes.has_value()) { - for (auto const [nftID] : extract(*secondRes)) + for (auto const [nftID] : extract(*secondRes)) nftIDs.push_back(nftID); } } @@ -172,9 +172,9 @@ public: * @param pageSize The maximum number of accounts per page. * @param seq The accounts need to exist at this ledger sequence. * @param yield The coroutine context. - * @return A vector of ripple::uint256 representing the account root hashes. + * @return A vector of xrpl::uint256 representing the account root hashes. */ - std::vector + std::vector fetchAccountRoots( [[maybe_unused]] std::uint32_t number, [[maybe_unused]] std::uint32_t pageSize, @@ -187,41 +187,41 @@ public: } private: - std::vector + std::vector fetchNFTIDsByTaxon( - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, std::uint32_t const taxon, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield ) const { - std::vector nftIDs; + std::vector nftIDs; Statement const statement = schema_->selectNFTIDsByIssuerTaxon.bind(issuer); statement.bindAt(1, taxon); - statement.bindAt(2, cursorIn.value_or(ripple::uint256(0))); + statement.bindAt(2, cursorIn.value_or(xrpl::uint256(0))); statement.bindAt(3, Limit{limit}); auto const res = executor_.read(yield, statement); if (res.has_value() && res->hasRows()) { - for (auto const [nftID] : extract(*res)) + for (auto const [nftID] : extract(*res)) nftIDs.push_back(nftID); } return nftIDs; } - std::vector + std::vector fetchNFTIDsWithoutTaxon( - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield ) const { - std::vector nftIDs; + std::vector nftIDs; - auto const startTaxon = cursorIn.has_value() ? ripple::nft::toUInt32(ripple::nft::getTaxon(*cursorIn)) : 0; - auto const startTokenID = cursorIn.value_or(ripple::uint256(0)); + auto const startTaxon = cursorIn.has_value() ? xrpl::nft::toUInt32(xrpl::nft::getTaxon(*cursorIn)) : 0; + auto const startTokenID = cursorIn.value_or(xrpl::uint256(0)); Statement firstQuery = schema_->selectNFTIDsByIssuerTaxon.bind(issuer); firstQuery.bindAt(1, startTaxon); @@ -230,7 +230,7 @@ private: auto const firstRes = executor_.read(yield, firstQuery); if (firstRes.has_value()) { - for (auto const [nftID] : extract(*firstRes)) + for (auto const [nftID] : extract(*firstRes)) nftIDs.push_back(nftID); } @@ -242,7 +242,7 @@ private: auto const secondRes = executor_.read(yield, secondQuery); if (secondRes.has_value()) { - for (auto const [nftID] : extract(*secondRes)) + for (auto const [nftID] : extract(*secondRes)) nftIDs.push_back(nftID); } } @@ -254,7 +254,7 @@ private: */ NFTsAndCursor populateNFTsAndCreateCursor( - std::vector const& nftIDs, + std::vector const& nftIDs, std::uint32_t const ledgerSequence, std::uint32_t const limit, boost::asio::yield_context yield @@ -291,11 +291,11 @@ private: // Combine the results into final NFT objects. for (auto i = 0u; i < nftIDs.size(); ++i) { - if (auto const maybeRow = nftInfos[i].template get(); + if (auto const maybeRow = nftInfos[i].template get(); maybeRow.has_value()) { auto [seq, owner, isBurned] = *maybeRow; NFT nft(nftIDs[i], seq, owner, isBurned); - if (auto const maybeUri = nftUris[i].template get(); maybeUri.has_value()) + if (auto const maybeUri = nftUris[i].template get(); maybeUri.has_value()) nft.uri = *maybeUri; ret.nfts.push_back(nft); } diff --git a/src/data/LedgerCache.cpp b/src/data/LedgerCache.cpp index b48748620..63dcb4496 100644 --- a/src/data/LedgerCache.cpp +++ b/src/data/LedgerCache.cpp @@ -131,7 +131,7 @@ LedgerCache::update(std::vector const& objs, uint32_t seq) } std::optional -LedgerCache::getSuccessor(ripple::uint256 const& key, uint32_t seq) const +LedgerCache::getSuccessor(xrpl::uint256 const& key, uint32_t seq) const { if (disabled_ or not full_) return {}; @@ -148,7 +148,7 @@ LedgerCache::getSuccessor(ripple::uint256 const& key, uint32_t seq) const } std::optional -LedgerCache::getPredecessor(ripple::uint256 const& key, uint32_t seq) const +LedgerCache::getPredecessor(xrpl::uint256 const& key, uint32_t seq) const { if (disabled_ or not full_) return {}; @@ -164,7 +164,7 @@ LedgerCache::getPredecessor(ripple::uint256 const& key, uint32_t seq) const } std::optional -LedgerCache::get(ripple::uint256 const& key, uint32_t seq) const +LedgerCache::get(xrpl::uint256 const& key, uint32_t seq) const { if (disabled_) return {}; @@ -183,7 +183,7 @@ LedgerCache::get(ripple::uint256 const& key, uint32_t seq) const } std::optional -LedgerCache::getDeleted(ripple::uint256 const& key, uint32_t seq) const +LedgerCache::getDeleted(xrpl::uint256 const& key, uint32_t seq) const { if (disabled_) return std::nullopt; diff --git a/src/data/LedgerCache.hpp b/src/data/LedgerCache.hpp index b6346f47a..176bd26a0 100644 --- a/src/data/LedgerCache.hpp +++ b/src/data/LedgerCache.hpp @@ -54,7 +54,7 @@ public: Blob blob; }; - using CacheMap = std::map; + using CacheMap = std::map; private: // counters for fetchLedgerObject(s) hit rate @@ -97,7 +97,7 @@ private: )}; // temporary set to prevent background thread from writing already deleted data. not used when cache is full - std::unordered_set> deletes_; + std::unordered_set> deletes_; public: void @@ -107,16 +107,16 @@ public: update(std::vector const& objs, uint32_t seq) override; std::optional - get(ripple::uint256 const& key, uint32_t seq) const override; + get(xrpl::uint256 const& key, uint32_t seq) const override; std::optional - getDeleted(ripple::uint256 const& key, uint32_t seq) const override; + getDeleted(xrpl::uint256 const& key, uint32_t seq) const override; std::optional - getSuccessor(ripple::uint256 const& key, uint32_t seq) const override; + getSuccessor(xrpl::uint256 const& key, uint32_t seq) const override; std::optional - getPredecessor(ripple::uint256 const& key, uint32_t seq) const override; + getPredecessor(xrpl::uint256 const& key, uint32_t seq) const override; void setDisabled() override; diff --git a/src/data/LedgerCacheInterface.hpp b/src/data/LedgerCacheInterface.hpp index d2ff7e488..9ae90a255 100644 --- a/src/data/LedgerCacheInterface.hpp +++ b/src/data/LedgerCacheInterface.hpp @@ -75,7 +75,7 @@ public: * @return If found in cache, will return the cached Blob; otherwise nullopt is returned */ virtual std::optional - get(ripple::uint256 const& key, uint32_t seq) const = 0; + get(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Fetch a recently deleted object by its key and sequence number. @@ -85,7 +85,7 @@ public: * @return If found in deleted cache, will return the cached Blob; otherwise nullopt is returned */ virtual std::optional - getDeleted(ripple::uint256 const& key, uint32_t seq) const = 0; + getDeleted(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Gets a cached successor. @@ -97,7 +97,7 @@ public: * @return If found in cache, will return the cached successor; otherwise nullopt is returned */ virtual std::optional - getSuccessor(ripple::uint256 const& key, uint32_t seq) const = 0; + getSuccessor(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Gets a cached predcessor. @@ -109,7 +109,7 @@ public: * @return If found in cache, will return the cached predcessor; otherwise nullopt is returned */ virtual std::optional - getPredecessor(ripple::uint256 const& key, uint32_t seq) const = 0; + getPredecessor(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Disables the cache. diff --git a/src/data/LedgerHeaderCache.hpp b/src/data/LedgerHeaderCache.hpp index 9bed26304..0283825ec 100644 --- a/src/data/LedgerHeaderCache.hpp +++ b/src/data/LedgerHeaderCache.hpp @@ -30,7 +30,7 @@ namespace data { /** - * @brief A simple cache holding one `ripple::LedgerHeader` to reduce DB lookups. + * @brief A simple cache holding one `xrpl::LedgerHeader` to reduce DB lookups. * * Used internally by backend implementations. When a ledger header is * fetched via `FetchLedgerBySeq` (often triggered by RPC commands), @@ -46,7 +46,7 @@ public: * @brief Struct to store ledger header cache entry and the sequence it belongs to */ struct CacheEntry { - ripple::LedgerHeader ledger; + xrpl::LedgerHeader ledger; uint32_t seq{}; /** diff --git a/src/data/Types.hpp b/src/data/Types.hpp index 175583efa..ab7f66d5e 100644 --- a/src/data/Types.hpp +++ b/src/data/Types.hpp @@ -39,7 +39,7 @@ using Blob = std::vector; * @brief Represents an object in the ledger. */ struct LedgerObject { - ripple::uint256 key; + xrpl::uint256 key; Blob blob; bool @@ -51,7 +51,7 @@ struct LedgerObject { */ struct LedgerPage { std::vector objects; - std::optional cursor; + std::optional cursor; }; /** @@ -59,7 +59,7 @@ struct LedgerPage { */ struct BookOffersPage { std::vector offers; - std::optional cursor; + std::optional cursor; }; /** @@ -170,9 +170,9 @@ struct TransactionsAndCursor { * @brief Represents a NFToken. */ struct NFT { - ripple::uint256 tokenID; + xrpl::uint256 tokenID; std::uint32_t ledgerSequence{}; - ripple::AccountID owner; + xrpl::AccountID owner; Blob uri; bool isBurned{}; @@ -187,9 +187,9 @@ struct NFT { * @param uri The URI * @param isBurned Whether the token is burned */ - NFT(ripple::uint256 const& tokenID, + NFT(xrpl::uint256 const& tokenID, std::uint32_t ledgerSequence, - ripple::AccountID const& owner, + xrpl::AccountID const& owner, Blob uri, bool isBurned) : tokenID{tokenID}, ledgerSequence{ledgerSequence}, owner{owner}, uri{std::move(uri)}, isBurned{isBurned} @@ -204,7 +204,7 @@ struct NFT { * @param owner The owner * @param isBurned Whether the token is burned */ - NFT(ripple::uint256 const& tokenID, std::uint32_t ledgerSequence, ripple::AccountID const& owner, bool isBurned) + NFT(xrpl::uint256 const& tokenID, std::uint32_t ledgerSequence, xrpl::AccountID const& owner, bool isBurned) : NFT(tokenID, ledgerSequence, owner, {}, isBurned) { } @@ -230,7 +230,7 @@ struct NFT { */ struct NFTsAndCursor { std::vector nfts; - std::optional cursor; + std::optional cursor; }; /** @@ -238,7 +238,7 @@ struct NFTsAndCursor { */ struct MPTHoldersAndCursor { std::vector mptokens; - std::optional cursor; + std::optional cursor; }; /** @@ -257,7 +257,7 @@ struct LedgerRange { */ struct Amendment { std::string name; - ripple::uint256 feature; + xrpl::uint256 feature; bool isSupportedByXRPL = false; bool isSupportedByClio = false; bool isRetired = false; @@ -268,7 +268,7 @@ struct Amendment { * @param name The name of the amendment * @return The amendment Id as uint256 */ - static ripple::uint256 + static xrpl::uint256 getAmendmentId(std::string_view const name); /** @@ -304,7 +304,7 @@ struct AmendmentKey { operator std::string_view() const; /** @brief Conversion to uint256 */ - operator ripple::uint256() const; + operator xrpl::uint256() const; /** * @brief Comparison operators @@ -315,8 +315,8 @@ struct AmendmentKey { operator<=>(AmendmentKey const& other) const = default; }; -constexpr ripple::uint256 kFIRST_KEY{"0000000000000000000000000000000000000000000000000000000000000000"}; -constexpr ripple::uint256 kLAST_KEY{"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"}; -constexpr ripple::uint256 kHI192{"0000000000000000000000000000000000000000000000001111111111111111"}; +constexpr xrpl::uint256 kFIRST_KEY{"0000000000000000000000000000000000000000000000000000000000000000"}; +constexpr xrpl::uint256 kLAST_KEY{"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"}; +constexpr xrpl::uint256 kHI192{"0000000000000000000000000000000000000000000000001111111111111111"}; } // namespace data diff --git a/src/data/cassandra/CassandraBackendFamily.hpp b/src/data/cassandra/CassandraBackendFamily.hpp index ad917e129..042fcc112 100644 --- a/src/data/cassandra/CassandraBackendFamily.hpp +++ b/src/data/cassandra/CassandraBackendFamily.hpp @@ -148,7 +148,7 @@ public: TransactionsAndCursor fetchAccountTransactions( - ripple::AccountID const& account, + xrpl::AccountID const& account, std::uint32_t const limit, bool forward, std::optional const& txnCursor, @@ -169,14 +169,14 @@ public: auto cursor = txnCursor; if (cursor) { statement.bindAt(1, cursor->asTuple()); - LOG(log_.debug()) << "account = " << ripple::strHex(account) << " tuple = " << cursor->ledgerSequence + LOG(log_.debug()) << "account = " << xrpl::strHex(account) << " tuple = " << cursor->ledgerSequence << cursor->transactionIndex; } else { auto const seq = forward ? rng->minSequence : rng->maxSequence; auto const placeHolder = forward ? 0u : std::numeric_limits::max(); statement.bindAt(1, std::make_tuple(placeHolder, placeHolder)); - LOG(log_.debug()) << "account = " << ripple::strHex(account) << " idx = " << seq + LOG(log_.debug()) << "account = " << xrpl::strHex(account) << " idx = " << seq << " tuple = " << placeHolder; } @@ -191,11 +191,11 @@ public: return {}; } - std::vector hashes = {}; + std::vector hashes = {}; auto numRows = results.numRows(); LOG(log_.info()) << "num_rows = " << numRows; - for (auto [hash, data] : extract>(results)) { + for (auto [hash, data] : extract>(results)) { hashes.push_back(hash); if (--numRows == 0) { LOG(log_.debug()) << "Setting cursor"; @@ -221,7 +221,7 @@ public: } void - writeLedger(ripple::LedgerHeader const& ledgerHeader, std::string&& blob) override + writeLedger(xrpl::LedgerHeader const& ledgerHeader, std::string&& blob) override { executor_.write(schema_->insertLedgerHeader, ledgerHeader.seq, std::move(blob)); @@ -250,7 +250,7 @@ public: return std::nullopt; } - std::optional + std::optional fetchLedgerBySequence(std::uint32_t const sequence, boost::asio::yield_context yield) const override { if (auto const lock = ledgerCache_.get(); lock.has_value() && lock->seq == sequence) @@ -260,7 +260,7 @@ public: if (res) { if (auto const& result = res.value(); result) { if (auto const maybeValue = result.template get>(); maybeValue) { - auto const header = util::deserializeHeader(ripple::makeSlice(*maybeValue)); + auto const header = util::deserializeHeader(xrpl::makeSlice(*maybeValue)); ledgerCache_.put(FetchLedgerCache::CacheEntry{header, sequence}); return header; } @@ -277,8 +277,8 @@ public: return std::nullopt; } - std::optional - fetchLedgerByHash(ripple::uint256 const& hash, boost::asio::yield_context yield) const override + std::optional + fetchLedgerByHash(xrpl::uint256 const& hash, boost::asio::yield_context yield) const override { if (auto const res = executor_.read(yield, schema_->selectLedgerByHash, hash); res) { if (auto const& result = res.value(); result) { @@ -342,7 +342,7 @@ public: return fetchTransactions(hashes, yield); } - std::vector + std::vector fetchAllTransactionHashesInLedger( std::uint32_t const ledgerSequence, boost::asio::yield_context yield @@ -363,8 +363,8 @@ public: return {}; } - std::vector hashes; - for (auto [hash] : extract(result)) + std::vector hashes; + for (auto [hash] : extract(result)) hashes.push_back(std::move(hash)); auto end = std::chrono::system_clock::now(); @@ -377,7 +377,7 @@ public: std::optional fetchNFT( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const override @@ -386,7 +386,7 @@ public: if (not res) return std::nullopt; - if (auto const maybeRow = res->template get(); maybeRow) { + if (auto const maybeRow = res->template get(); maybeRow) { auto [seq, owner, isBurned] = *maybeRow; auto result = std::make_optional(tokenID, seq, owner, isBurned); @@ -403,7 +403,7 @@ public: // one. auto uriRes = executor_.read(yield, schema_->selectNFTURI, tokenID, ledgerSequence); if (uriRes) { - if (auto const maybeUri = uriRes->template get(); maybeUri) + if (auto const maybeUri = uriRes->template get(); maybeUri) result->uri = *maybeUri; } @@ -416,7 +416,7 @@ public: TransactionsAndCursor fetchNFTTransactions( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t const limit, bool const forward, std::optional const& cursorIn, @@ -437,14 +437,14 @@ public: auto cursor = cursorIn; if (cursor) { statement.bindAt(1, cursor->asTuple()); - LOG(log_.debug()) << "token_id = " << ripple::strHex(tokenID) << " tuple = " << cursor->ledgerSequence + LOG(log_.debug()) << "token_id = " << xrpl::strHex(tokenID) << " tuple = " << cursor->ledgerSequence << cursor->transactionIndex; } else { auto const seq = forward ? rng->minSequence : rng->maxSequence; auto const placeHolder = forward ? 0 : std::numeric_limits::max(); statement.bindAt(1, std::make_tuple(placeHolder, placeHolder)); - LOG(log_.debug()) << "token_id = " << ripple::strHex(tokenID) << " idx = " << seq + LOG(log_.debug()) << "token_id = " << xrpl::strHex(tokenID) << " idx = " << seq << " tuple = " << placeHolder; } @@ -457,11 +457,11 @@ public: return {}; } - std::vector hashes = {}; + std::vector hashes = {}; auto numRows = results.numRows(); LOG(log_.info()) << "num_rows = " << numRows; - for (auto [hash, data] : extract>(results)) { + for (auto [hash, data] : extract>(results)) { hashes.push_back(hash); if (--numRows == 0) { LOG(log_.debug()) << "Setting cursor"; @@ -487,15 +487,15 @@ public: MPTHoldersAndCursor fetchMPTHolders( - ripple::uint192 const& mptID, + xrpl::uint192 const& mptID, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const override { auto const holderEntries = executor_.read( - yield, schema_->selectMPTHolders, mptID, cursorIn.value_or(ripple::AccountID(0)), Limit{limit} + yield, schema_->selectMPTHolders, mptID, cursorIn.value_or(xrpl::AccountID(0)), Limit{limit} ); auto const& holderResults = holderEntries.value(); @@ -504,10 +504,10 @@ public: return {}; } - std::vector mptKeys; - std::optional cursor; - for (auto const [holder] : extract(holderResults)) { - mptKeys.push_back(ripple::keylet::mptoken(mptID, holder).key); + std::vector mptKeys; + std::optional cursor; + for (auto const [holder] : extract(holderResults)) { + mptKeys.push_back(xrpl::keylet::mptoken(mptID, holder).key); cursor = holder; } @@ -526,12 +526,12 @@ public: std::optional doFetchLedgerObject( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t const sequence, boost::asio::yield_context yield ) const override { - LOG(log_.debug()) << "Fetching ledger object for seq " << sequence << ", key = " << ripple::to_string(key); + LOG(log_.debug()) << "Fetching ledger object for seq " << sequence << ", key = " << xrpl::to_string(key); if (auto const res = executor_.read(yield, schema_->selectObject, key, sequence); res) { if (auto const result = res->template get(); result) { if (result->size()) @@ -548,12 +548,12 @@ public: std::optional doFetchLedgerObjectSeq( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t const sequence, boost::asio::yield_context yield ) const override { - LOG(log_.debug()) << "Fetching ledger object for seq " << sequence << ", key = " << ripple::to_string(key); + LOG(log_.debug()) << "Fetching ledger object for seq " << sequence << ", key = " << xrpl::to_string(key); if (auto const res = executor_.read(yield, schema_->selectObject, key, sequence); res) { if (auto const result = res->template get(); result) { auto [_, seq] = result.value(); @@ -568,7 +568,7 @@ public: } std::optional - fetchTransaction(ripple::uint256 const& hash, boost::asio::yield_context yield) const override + fetchTransaction(xrpl::uint256 const& hash, boost::asio::yield_context yield) const override { if (auto const res = executor_.read(yield, schema_->selectTransaction, hash); res) { if (auto const maybeValue = res->template get(); maybeValue) { @@ -584,15 +584,15 @@ public: return std::nullopt; } - std::optional + std::optional doFetchSuccessorKey( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const override { if (auto const res = executor_.read(yield, schema_->selectSuccessor, key, ledgerSequence); res) { - if (auto const result = res->template get(); result) { + if (auto const result = res->template get(); result) { if (*result == kLAST_KEY) return std::nullopt; return result; @@ -607,7 +607,7 @@ public: } std::vector - fetchTransactions(std::vector const& hashes, boost::asio::yield_context yield) const override + fetchTransactions(std::vector const& hashes, boost::asio::yield_context yield) const override { if (hashes.empty()) return {}; @@ -649,7 +649,7 @@ public: std::vector doFetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t const sequence, boost::asio::yield_context yield ) const override @@ -690,7 +690,7 @@ public: std::vector fetchLedgerDiff(std::uint32_t const ledgerSequence, boost::asio::yield_context yield) const override { - auto const [keys, timeDiff] = util::timed([this, &ledgerSequence, yield]() -> std::vector { + auto const [keys, timeDiff] = util::timed([this, &ledgerSequence, yield]() -> std::vector { auto const res = executor_.read(yield, schema_->selectDiff, ledgerSequence); if (not res) { LOG(log_.error()) << "Could not fetch ledger diff: " << res.error() << "; ledger = " << ledgerSequence; @@ -703,8 +703,8 @@ public: return {}; } - std::vector resultKeys; - for (auto [key] : extract(results)) + std::vector resultKeys; + for (auto [key] : extract(results)) resultKeys.push_back(key); return resultKeys; @@ -877,8 +877,8 @@ public: // to record the URI and link to the issuer_nf_tokens table. if (record.uri) { statements.push_back(schema_->insertIssuerNFT.bind( - ripple::nft::getIssuer(record.tokenID), - static_cast(ripple::nft::getTaxon(record.tokenID)), + xrpl::nft::getIssuer(record.tokenID), + static_cast(xrpl::nft::getTaxon(record.tokenID)), record.tokenID )); statements.push_back( diff --git a/src/data/cassandra/impl/Collection.hpp b/src/data/cassandra/impl/Collection.hpp index 8caa11fd4..8e058c3b5 100644 --- a/src/data/cassandra/impl/Collection.hpp +++ b/src/data/cassandra/impl/Collection.hpp @@ -77,14 +77,14 @@ public: } void - append(ripple::uint256 const& value) const + append(xrpl::uint256 const& value) const { auto const rc = cass_collection_append_bytes( *this, static_cast(static_cast(value.data())), - ripple::uint256::size() + xrpl::uint256::size() ); - throwErrorIfNeeded(rc, "Bind ripple::uint256"); + throwErrorIfNeeded(rc, "Bind xrpl::uint256"); } }; } // namespace data::cassandra::impl diff --git a/src/data/cassandra/impl/Result.hpp b/src/data/cassandra/impl/Result.hpp index 1926deb20..01b3a6009 100644 --- a/src/data/cassandra/impl/Result.hpp +++ b/src/data/cassandra/impl/Result.hpp @@ -62,18 +62,18 @@ extractColumn(CassRow const* row, std::size_t idx) using UintTupleType = std::tuple; using UCharVectorType = std::vector; - if constexpr (std::is_same_v) { + if constexpr (std::is_same_v) { cass_byte_t const* buf = nullptr; std::size_t bufSize = 0; auto const rc = cass_value_get_bytes(cass_row_get_column(row, idx), &buf, &bufSize); - throwErrorIfNeeded(rc, "Extract ripple::uint256"); - output = ripple::uint256::fromVoid(buf); - } else if constexpr (std::is_same_v) { + throwErrorIfNeeded(rc, "Extract xrpl::uint256"); + output = xrpl::uint256::fromVoid(buf); + } else if constexpr (std::is_same_v) { cass_byte_t const* buf = nullptr; std::size_t bufSize = 0; auto const rc = cass_value_get_bytes(cass_row_get_column(row, idx), &buf, &bufSize); - throwErrorIfNeeded(rc, "Extract ripple::AccountID"); - output = ripple::AccountID::fromVoid(buf); + throwErrorIfNeeded(rc, "Extract xrpl::AccountID"); + output = xrpl::AccountID::fromVoid(buf); } else if constexpr (std::is_same_v) { cass_byte_t const* buf = nullptr; std::size_t bufSize = 0; diff --git a/src/data/cassandra/impl/Statement.hpp b/src/data/cassandra/impl/Statement.hpp index 6998c741c..e32d1d0df 100644 --- a/src/data/cassandra/impl/Statement.hpp +++ b/src/data/cassandra/impl/Statement.hpp @@ -107,15 +107,15 @@ public: using DecayedType = std::decay_t; using UCharVectorType = std::vector; using UintTupleType = std::tuple; - using UintByteTupleType = std::tuple; - using ByteVectorType = std::vector; + using UintByteTupleType = std::tuple; + using ByteVectorType = std::vector; - if constexpr (std::is_same_v || std::is_same_v) { + if constexpr (std::is_same_v || std::is_same_v) { auto const rc = bindBytes(value.data(), value.size()); - throwErrorIfNeeded(rc, "Bind ripple::base_uint"); - } else if constexpr (std::is_same_v) { + throwErrorIfNeeded(rc, "Bind xrpl::BaseUInt"); + } else if constexpr (std::is_same_v) { auto const rc = bindBytes(value.data(), value.size()); - throwErrorIfNeeded(rc, "Bind ripple::AccountID"); + throwErrorIfNeeded(rc, "Bind xrpl::AccountID"); } else if constexpr (std::is_same_v) { auto const rc = bindBytes(value.data(), value.size()); throwErrorIfNeeded(rc, "Bind vector"); @@ -129,7 +129,7 @@ public: } else if constexpr (std::is_same_v || std::is_same_v) { auto const rc = cass_statement_bind_tuple(*this, idx, Tuple{std::forward(value)}); - throwErrorIfNeeded(rc, "Bind tuple or "); + throwErrorIfNeeded(rc, "Bind tuple or "); } else if constexpr (std::is_same_v) { auto const rc = cass_statement_bind_collection(*this, idx, Collection{std::forward(value)}); throwErrorIfNeeded(rc, "Bind collection"); diff --git a/src/data/cassandra/impl/Tuple.hpp b/src/data/cassandra/impl/Tuple.hpp index d498b924a..f47308e33 100644 --- a/src/data/cassandra/impl/Tuple.hpp +++ b/src/data/cassandra/impl/Tuple.hpp @@ -79,14 +79,14 @@ public: else if constexpr (std::is_convertible_v) { auto const rc = cass_tuple_set_int64(*this, idx, std::forward(value)); throwErrorIfNeeded(rc, "Bind int64"); - } else if constexpr (std::is_same_v) { + } else if constexpr (std::is_same_v) { auto const rc = cass_tuple_set_bytes( *this, idx, static_cast(static_cast(value.data())), value.size() ); - throwErrorIfNeeded(rc, "Bind ripple::uint256"); + throwErrorIfNeeded(rc, "Bind xrpl::uint256"); } else { // type not supported for binding static_assert(util::Unsupported); diff --git a/src/data/impl/InputFile.cpp b/src/data/impl/InputFile.cpp index 9d7fc1c7b..d03d7122b 100644 --- a/src/data/impl/InputFile.cpp +++ b/src/data/impl/InputFile.cpp @@ -48,7 +48,7 @@ InputFile::readRaw(char* data, size_t size) return not file_.fail(); } -ripple::uint256 +xrpl::uint256 InputFile::hash() const { auto sum = shasum_; diff --git a/src/data/impl/InputFile.hpp b/src/data/impl/InputFile.hpp index ff9ec82b8..4911ccd91 100644 --- a/src/data/impl/InputFile.hpp +++ b/src/data/impl/InputFile.hpp @@ -51,7 +51,7 @@ public: bool readRaw(char* data, size_t size); - ripple::uint256 + xrpl::uint256 hash() const; }; } // namespace data::impl diff --git a/src/data/impl/LedgerCacheFile.cpp b/src/data/impl/LedgerCacheFile.cpp index 34f7b71d0..221404510 100644 --- a/src/data/impl/LedgerCacheFile.cpp +++ b/src/data/impl/LedgerCacheFile.cpp @@ -36,17 +36,17 @@ namespace data::impl { -using Hash = ripple::uint256; +using Hash = xrpl::uint256; using Separator = std::array; static constexpr Separator kSEPARATOR = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; namespace { -std::expected, std::string> +std::expected, std::string> readCacheEntry(InputFile& file, size_t i) { - ripple::uint256 key; - if (not file.readRaw(reinterpret_cast(key.data()), ripple::base_uint<256>::bytes)) { + xrpl::uint256 key; + if (not file.readRaw(reinterpret_cast(key.data()), xrpl::BaseUInt<256>::kBytes)) { return std::unexpected(fmt::format("Failed to read key at index {}", i)); } @@ -98,7 +98,7 @@ LedgerCacheFile::write(DataView dataView) file.write(kSEPARATOR); for (auto const& [k, v] : dataView.map) { - file.write(k.data(), decltype(k)::bytes); + file.write(k.data(), decltype(k)::kBytes); file.write(v.seq); file.write(v.blob.size()); file.writeRaw(reinterpret_cast(v.blob.data()), v.blob.size()); @@ -106,14 +106,14 @@ LedgerCacheFile::write(DataView dataView) file.write(kSEPARATOR); for (auto const& [k, v] : dataView.deleted) { - file.write(k.data(), decltype(k)::bytes); + file.write(k.data(), decltype(k)::kBytes); file.write(v.seq); file.write(v.blob.size()); file.writeRaw(reinterpret_cast(v.blob.data()), v.blob.size()); } file.write(kSEPARATOR); auto const hash = file.hash(); - file.write(hash.data(), decltype(hash)::bytes); + file.write(hash.data(), decltype(hash)::kBytes); try { std::filesystem::rename(newFilePath, path_); @@ -190,8 +190,8 @@ LedgerCacheFile::read(uint32_t minLatestSequence) } auto const dataHash = file.hash(); - ripple::uint256 hashFromFile{}; - if (not file.readRaw(reinterpret_cast(hashFromFile.data()), decltype(hashFromFile)::bytes)) { + xrpl::uint256 hashFromFile{}; + if (not file.readRaw(reinterpret_cast(hashFromFile.data()), decltype(hashFromFile)::kBytes)) { return std::unexpected{"Error reading hash"}; } diff --git a/src/data/impl/OutputFile.cpp b/src/data/impl/OutputFile.cpp index e78379798..603c9678c 100644 --- a/src/data/impl/OutputFile.cpp +++ b/src/data/impl/OutputFile.cpp @@ -52,7 +52,7 @@ OutputFile::writeToFile(char const* data, size_t size) shasum_.update(data, size); } -ripple::uint256 +xrpl::uint256 OutputFile::hash() const { auto sum = shasum_; diff --git a/src/data/impl/OutputFile.hpp b/src/data/impl/OutputFile.hpp index f0e0c94f3..46d1a8f32 100644 --- a/src/data/impl/OutputFile.hpp +++ b/src/data/impl/OutputFile.hpp @@ -57,7 +57,7 @@ public: void writeRaw(char const* data, size_t size); - ripple::uint256 + xrpl::uint256 hash() const; private: diff --git a/src/etl/ETLHelpers.cpp b/src/etl/ETLHelpers.cpp index 18aa4751e..79dec1ed7 100644 --- a/src/etl/ETLHelpers.cpp +++ b/src/etl/ETLHelpers.cpp @@ -27,16 +27,16 @@ #include namespace etl { -std::vector +std::vector getMarkers(size_t numMarkers) { ASSERT(numMarkers <= 256, "Number of markers must be <= 256. Got: {}", numMarkers); unsigned char const incr = 256 / numMarkers; - std::vector markers; + std::vector markers; markers.reserve(numMarkers); - ripple::uint256 base{0}; + xrpl::uint256 base{0}; for (size_t i = 0; i < numMarkers; ++i) { markers.push_back(base); base.data()[0] += incr; diff --git a/src/etl/ETLHelpers.hpp b/src/etl/ETLHelpers.hpp index 5152292b9..e8ebd4f59 100644 --- a/src/etl/ETLHelpers.hpp +++ b/src/etl/ETLHelpers.hpp @@ -148,7 +148,7 @@ public: * @param numMarkers Total markers to partition for * @return The markers */ -std::vector +std::vector getMarkers(size_t numMarkers); } // namespace etl diff --git a/src/etl/ETLService.cpp b/src/etl/ETLService.cpp index 6f8c0d4ee..b5d7e97aa 100644 --- a/src/etl/ETLService.cpp +++ b/src/etl/ETLService.cpp @@ -303,7 +303,7 @@ ETLService::loadInitialLedgerIfNeeded() auto [ledger, timeDiff] = ::util::timed>([this, seq]() { return extractor_->extractLedgerOnly(seq).and_then( - [this, seq](auto&& data) -> std::optional { + [this, seq](auto&& data) -> std::optional { // TODO: loadInitialLedger in balancer should be called fetchEdgeKeys or similar auto res = balancer_->loadInitialLedger(seq, *initialLoadObserver_); if (not res.has_value() and res.error() == InitialLedgerLoadError::Cancelled) { diff --git a/src/etl/LoaderInterface.hpp b/src/etl/LoaderInterface.hpp index 2e9a1a164..007ae4da1 100644 --- a/src/etl/LoaderInterface.hpp +++ b/src/etl/LoaderInterface.hpp @@ -55,7 +55,7 @@ struct LoaderInterface { * @param data The data to load * @return Optional ledger header */ - [[nodiscard]] virtual std::optional + [[nodiscard]] virtual std::optional loadInitialLedger(model::LedgerData const& data) = 0; }; diff --git a/src/etl/MPTHelpers.cpp b/src/etl/MPTHelpers.cpp index 23767cbe8..72ccb0f46 100644 --- a/src/etl/MPTHelpers.cpp +++ b/src/etl/MPTHelpers.cpp @@ -20,17 +20,17 @@ #include "data/DBHelpers.hpp" #include "util/Assert.hpp" -#include -#include -#include #include #include #include +#include #include #include +#include #include #include #include +#include #include #include @@ -44,16 +44,16 @@ namespace etl { * @return MPT and holder account pair */ std::optional -getMPTokenAuthorize(ripple::TxMeta const& txMeta) +getMPTokenAuthorize(xrpl::TxMeta const& txMeta) { - for (ripple::STObject const& node : txMeta.getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltMPTOKEN) + for (xrpl::STObject const& node : txMeta.getNodes()) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltMPTOKEN) continue; - if (node.getFName() == ripple::sfCreatedNode) { - auto const& newMPT = node.peekAtField(ripple::sfNewFields).downcast(); + if (node.getFName() == xrpl::sfCreatedNode) { + auto const& newMPT = node.peekAtField(xrpl::sfNewFields).downcast(); return MPTHolderData{ - .mptID = newMPT[ripple::sfMPTokenIssuanceID], .holder = newMPT.getAccountID(ripple::sfAccount) + .mptID = newMPT[xrpl::sfMPTokenIssuanceID], .holder = newMPT.getAccountID(xrpl::sfAccount) }; } } @@ -61,9 +61,9 @@ getMPTokenAuthorize(ripple::TxMeta const& txMeta) } std::optional -getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getMPTHolderFromTx(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { - if (txMeta.getResultTER() != ripple::tesSUCCESS || sttx.getTxnType() != ripple::TxType::ttMPTOKEN_AUTHORIZE) + if (txMeta.getResultTER() != xrpl::tesSUCCESS || sttx.getTxnType() != xrpl::TxType::ttMPTOKEN_AUTHORIZE) return {}; return getMPTokenAuthorize(txMeta); @@ -73,16 +73,16 @@ std::optional getMPTHolderFromObj(std::string const& key, std::string const& blob) { // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0033-multi-purpose-tokens#2121-mptoken-ledger-identifier - ASSERT(key.size() == ripple::uint256::size(), "The size of the key is expected to fit uint256 exactly"); + ASSERT(key.size() == xrpl::uint256::size(), "The size of the key is expected to fit uint256 exactly"); - ripple::STLedgerEntry const sle = - ripple::STLedgerEntry(ripple::SerialIter{blob.data(), blob.size()}, ripple::uint256::fromVoid(key.data())); + xrpl::STLedgerEntry const sle = + xrpl::STLedgerEntry(xrpl::SerialIter{blob.data(), blob.size()}, xrpl::uint256::fromVoid(key.data())); - if (sle.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltMPTOKEN) + if (sle.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltMPTOKEN) return {}; - auto const mptIssuanceID = sle[ripple::sfMPTokenIssuanceID]; - auto const holder = sle.getAccountID(ripple::sfAccount); + auto const mptIssuanceID = sle[xrpl::sfMPTokenIssuanceID]; + auto const holder = sle.getAccountID(xrpl::sfAccount); return MPTHolderData{.mptID = mptIssuanceID, .holder = holder}; } diff --git a/src/etl/MPTHelpers.hpp b/src/etl/MPTHelpers.hpp index 2aabb99d7..78b51b881 100644 --- a/src/etl/MPTHelpers.hpp +++ b/src/etl/MPTHelpers.hpp @@ -22,8 +22,8 @@ #include "data/DBHelpers.hpp" -#include -#include +#include +#include namespace etl { @@ -35,7 +35,7 @@ namespace etl { * @return The MPTIssuanceID and holder pair as a optional */ std::optional -getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getMPTHolderFromTx(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Pull MPT data from ledger object via loadInitialLedger. diff --git a/src/etl/Models.hpp b/src/etl/Models.hpp index d91448e0e..f972103fa 100644 --- a/src/etl/Models.hpp +++ b/src/etl/Models.hpp @@ -47,7 +47,7 @@ namespace etl::model { * the Registry for its `onTransaction` and `onInitialTransaction` hooks. * It's a compilation error to list the same transaction type more than once. */ -template +template requires(util::hasNoDuplicates(Types...)) struct Spec { static constexpr bool kSPEC_TAG = true; @@ -59,7 +59,7 @@ struct Spec { * @return true if the transaction was requested; false otherwise */ [[nodiscard]] static constexpr bool - wants(ripple::TxType type) noexcept + wants(xrpl::TxType type) noexcept { return ((Types == type) || ...); } @@ -73,13 +73,13 @@ struct Transaction { std::string metaRaw; // unpacked blob and meta - ripple::STTx sttx; - ripple::TxMeta meta; + xrpl::STTx sttx; + xrpl::TxMeta meta; // commonly used stuff - ripple::uint256 id; + xrpl::uint256 id; std::string key; // key is the above id as a string of 32 characters - ripple::TxType type; + xrpl::TxType type; /** * @brief Compares Transaction objects to each other without considering sttx and meta fields @@ -113,9 +113,9 @@ struct Object { Deleted = 3, }; - ripple::uint256 key; + xrpl::uint256 key; std::string keyRaw; - ripple::Blob data; + xrpl::Blob data; std::string dataRaw; std::string successor; std::string predecessor; @@ -146,7 +146,7 @@ struct LedgerData { std::optional> successors; std::optional> edgeKeys; - ripple::LedgerHeader header; + xrpl::LedgerHeader header; std::string rawHeader; uint32_t seq; @@ -159,8 +159,8 @@ struct LedgerData { operator==(LedgerData const& other) const { auto const serialized = [](auto const& hdr) { - ripple::Serializer ser; - ripple::addRaw(hdr, ser); + xrpl::Serializer ser; + xrpl::addRaw(hdr, ser); return ser.getString(); }; diff --git a/src/etl/NFTHelpers.cpp b/src/etl/NFTHelpers.cpp index 0f36105d1..a2534d4cb 100644 --- a/src/etl/NFTHelpers.cpp +++ b/src/etl/NFTHelpers.cpp @@ -49,47 +49,47 @@ namespace etl { std::pair, std::optional> -getNftokenModifyData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getNftokenModifyData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { - auto const tokenID = sttx.getFieldH256(ripple::sfNFTokenID); + auto const tokenID = sttx.getFieldH256(xrpl::sfNFTokenID); // note: sfURI is optional, if it is absent, we will update the uri as empty string return { - {NFTTransactionsData(sttx.getFieldH256(ripple::sfNFTokenID), txMeta, sttx.getTransactionID())}, - NFTsData(tokenID, txMeta, sttx.getFieldVL(ripple::sfURI)) + {NFTTransactionsData(sttx.getFieldH256(xrpl::sfNFTokenID), txMeta, sttx.getTransactionID())}, + NFTsData(tokenID, txMeta, sttx.getFieldVL(xrpl::sfURI)) }; } std::pair, std::optional> -getNFTokenMintData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getNFTokenMintData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { // To find the minted token ID, we put all tokenIDs referenced in the // metadata from prior to the tx application into one vector, then all // tokenIDs referenced in the metadata from after the tx application into // another, then find the one tokenID that was added by this tx // application. - std::vector prevIDs; - std::vector finalIDs; + std::vector prevIDs; + std::vector finalIDs; // The owner is not necessarily the issuer, if using authorized minter // flow. Determine owner from the ledger object ID of the NFTokenPages // that were changed. - std::optional owner; + std::optional owner; - for (ripple::STObject const& node : txMeta.getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltNFTOKEN_PAGE) + for (xrpl::STObject const& node : txMeta.getNodes()) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltNFTOKEN_PAGE) continue; if (!owner) - owner = ripple::AccountID::fromVoid(node.getFieldH256(ripple::sfLedgerIndex).data()); + owner = xrpl::AccountID::fromVoid(node.getFieldH256(xrpl::sfLedgerIndex).data()); - if (node.getFName() == ripple::sfCreatedNode) { - ripple::STArray const& toAddNFTs = - node.peekAtField(ripple::sfNewFields).downcast().getFieldArray(ripple::sfNFTokens); + if (node.getFName() == xrpl::sfCreatedNode) { + xrpl::STArray const& toAddNFTs = + node.peekAtField(xrpl::sfNewFields).downcast().getFieldArray(xrpl::sfNFTokens); std::ranges::transform( toAddNFTs, std::back_inserter(finalIDs), - [](ripple::STObject const& nft) { return nft.getFieldH256(ripple::sfNFTokenID); } + [](xrpl::STObject const& nft) { return nft.getFieldH256(xrpl::sfNFTokenID); } ); } // Else it's modified, as there should never be a deleted NFToken page @@ -104,26 +104,25 @@ getNFTokenMintData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) // However, there will always be NFTs listed in the final fields, // as rippled outputs all fields in final fields even if they were // not changed. - ripple::STObject const& previousFields = - node.peekAtField(ripple::sfPreviousFields).downcast(); - if (!previousFields.isFieldPresent(ripple::sfNFTokens)) + xrpl::STObject const& previousFields = node.peekAtField(xrpl::sfPreviousFields).downcast(); + if (!previousFields.isFieldPresent(xrpl::sfNFTokens)) continue; - ripple::STArray const& toAddNFTs = previousFields.getFieldArray(ripple::sfNFTokens); + xrpl::STArray const& toAddNFTs = previousFields.getFieldArray(xrpl::sfNFTokens); std::ranges::transform( toAddNFTs, std::back_inserter(prevIDs), - [](ripple::STObject const& nft) { return nft.getFieldH256(ripple::sfNFTokenID); } + [](xrpl::STObject const& nft) { return nft.getFieldH256(xrpl::sfNFTokenID); } ); - ripple::STArray const& toAddFinalNFTs = - node.peekAtField(ripple::sfFinalFields).downcast().getFieldArray(ripple::sfNFTokens); + xrpl::STArray const& toAddFinalNFTs = + node.peekAtField(xrpl::sfFinalFields).downcast().getFieldArray(xrpl::sfNFTokens); std::ranges::transform( toAddFinalNFTs, std::back_inserter(finalIDs), - [](ripple::STObject const& nft) { return nft.getFieldH256(ripple::sfNFTokenID); } + [](xrpl::STObject const& nft) { return nft.getFieldH256(xrpl::sfNFTokenID); } ); } } @@ -146,22 +145,21 @@ getNFTokenMintData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) return { {NFTTransactionsData(*diff.first, txMeta, sttx.getTransactionID())}, - NFTsData(*diff.first, *owner, sttx.getFieldVL(ripple::sfURI), txMeta) + NFTsData(*diff.first, *owner, sttx.getFieldVL(xrpl::sfURI), txMeta) }; } std::pair, std::optional> -getNFTokenBurnData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getNFTokenBurnData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { - ripple::uint256 const tokenID = sttx.getFieldH256(ripple::sfNFTokenID); + xrpl::uint256 const tokenID = sttx.getFieldH256(xrpl::sfNFTokenID); std::vector const txs = {NFTTransactionsData(tokenID, txMeta, sttx.getTransactionID())}; // Determine who owned the token when it was burned by finding an // NFTokenPage that was deleted or modified that contains this // tokenID. - for (ripple::STObject const& node : txMeta.getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltNFTOKEN_PAGE || - node.getFName() == ripple::sfCreatedNode) + for (xrpl::STObject const& node : txMeta.getNodes()) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltNFTOKEN_PAGE || node.getFName() == xrpl::sfCreatedNode) continue; // NFT burn can result in an NFTokenPage being modified to no longer @@ -172,30 +170,27 @@ getNFTokenBurnData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) // deleted. In this case, we need to look in the PreviousFields. // Otherwise, the page was not modified prior to deleting and we // need to look in the FinalFields. - std::optional prevNFTs; + std::optional prevNFTs; - if (node.isFieldPresent(ripple::sfPreviousFields)) { - ripple::STObject const& previousFields = - node.peekAtField(ripple::sfPreviousFields).downcast(); - if (previousFields.isFieldPresent(ripple::sfNFTokens)) - prevNFTs = previousFields.getFieldArray(ripple::sfNFTokens); - } else if (node.getFName() == ripple::sfDeletedNode) { - prevNFTs = - node.peekAtField(ripple::sfFinalFields).downcast().getFieldArray(ripple::sfNFTokens); + if (node.isFieldPresent(xrpl::sfPreviousFields)) { + xrpl::STObject const& previousFields = node.peekAtField(xrpl::sfPreviousFields).downcast(); + if (previousFields.isFieldPresent(xrpl::sfNFTokens)) + prevNFTs = previousFields.getFieldArray(xrpl::sfNFTokens); + } else if (node.getFName() == xrpl::sfDeletedNode) { + prevNFTs = node.peekAtField(xrpl::sfFinalFields).downcast().getFieldArray(xrpl::sfNFTokens); } if (!prevNFTs) continue; - auto const nft = - std::find_if(prevNFTs->begin(), prevNFTs->end(), [&tokenID](ripple::STObject const& candidate) { - return candidate.getFieldH256(ripple::sfNFTokenID) == tokenID; - }); + auto const nft = std::find_if(prevNFTs->begin(), prevNFTs->end(), [&tokenID](xrpl::STObject const& candidate) { + return candidate.getFieldH256(xrpl::sfNFTokenID) == tokenID; + }); if (nft != prevNFTs->end()) { return std::make_pair( txs, NFTsData( - tokenID, ripple::AccountID::fromVoid(node.getFieldH256(ripple::sfLedgerIndex).data()), txMeta, true + tokenID, xrpl::AccountID::fromVoid(node.getFieldH256(xrpl::sfLedgerIndex).data()), txMeta, true ) ); } @@ -207,15 +202,15 @@ getNFTokenBurnData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) } std::pair, std::optional> -getNFTokenAcceptOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getNFTokenAcceptOfferData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { // If we have the buy offer from this tx, we can determine the owner // more easily by just looking at the owner of the accepted NFTokenOffer // object. - if (sttx.isFieldPresent(ripple::sfNFTokenBuyOffer)) { + if (sttx.isFieldPresent(xrpl::sfNFTokenBuyOffer)) { auto const affectedBuyOffer = - std::find_if(txMeta.getNodes().begin(), txMeta.getNodes().end(), [&sttx](ripple::STObject const& node) { - return node.getFieldH256(ripple::sfLedgerIndex) == sttx.getFieldH256(ripple::sfNFTokenBuyOffer); + std::find_if(txMeta.getNodes().begin(), txMeta.getNodes().end(), [&sttx](xrpl::STObject const& node) { + return node.getFieldH256(xrpl::sfLedgerIndex) == sttx.getFieldH256(xrpl::sfNFTokenBuyOffer); }); if (affectedBuyOffer == txMeta.getNodes().end()) { std::stringstream msg; @@ -223,13 +218,12 @@ getNFTokenAcceptOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx throw std::runtime_error(msg.str()); } - ripple::uint256 const tokenID = affectedBuyOffer->peekAtField(ripple::sfFinalFields) - .downcast() - .getFieldH256(ripple::sfNFTokenID); + xrpl::uint256 const tokenID = affectedBuyOffer->peekAtField(xrpl::sfFinalFields) + .downcast() + .getFieldH256(xrpl::sfNFTokenID); - ripple::AccountID const owner = affectedBuyOffer->peekAtField(ripple::sfFinalFields) - .downcast() - .getAccountID(ripple::sfOwner); + xrpl::AccountID const owner = + affectedBuyOffer->peekAtField(xrpl::sfFinalFields).downcast().getAccountID(xrpl::sfOwner); return { {NFTTransactionsData(tokenID, txMeta, sttx.getTransactionID())}, NFTsData(tokenID, owner, txMeta, false) }; @@ -237,8 +231,8 @@ getNFTokenAcceptOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx // Otherwise we have to infer the new owner from the affected nodes. auto const affectedSellOffer = - std::find_if(txMeta.getNodes().begin(), txMeta.getNodes().end(), [&sttx](ripple::STObject const& node) { - return node.getFieldH256(ripple::sfLedgerIndex) == sttx.getFieldH256(ripple::sfNFTokenSellOffer); + std::find_if(txMeta.getNodes().begin(), txMeta.getNodes().end(), [&sttx](xrpl::STObject const& node) { + return node.getFieldH256(xrpl::sfLedgerIndex) == sttx.getFieldH256(xrpl::sfNFTokenSellOffer); }); if (affectedSellOffer == txMeta.getNodes().end()) { std::stringstream msg; @@ -246,37 +240,29 @@ getNFTokenAcceptOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx throw std::runtime_error(msg.str()); } - ripple::uint256 const tokenID = affectedSellOffer->peekAtField(ripple::sfFinalFields) - .downcast() - .getFieldH256(ripple::sfNFTokenID); + xrpl::uint256 const tokenID = + affectedSellOffer->peekAtField(xrpl::sfFinalFields).downcast().getFieldH256(xrpl::sfNFTokenID); - ripple::AccountID const seller = affectedSellOffer->peekAtField(ripple::sfFinalFields) - .downcast() - .getAccountID(ripple::sfOwner); + xrpl::AccountID const seller = + affectedSellOffer->peekAtField(xrpl::sfFinalFields).downcast().getAccountID(xrpl::sfOwner); - for (ripple::STObject const& node : txMeta.getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltNFTOKEN_PAGE || - node.getFName() == ripple::sfDeletedNode) + for (xrpl::STObject const& node : txMeta.getNodes()) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltNFTOKEN_PAGE || node.getFName() == xrpl::sfDeletedNode) continue; - ripple::AccountID const nodeOwner = - ripple::AccountID::fromVoid(node.getFieldH256(ripple::sfLedgerIndex).data()); + xrpl::AccountID const nodeOwner = xrpl::AccountID::fromVoid(node.getFieldH256(xrpl::sfLedgerIndex).data()); if (nodeOwner == seller) continue; - ripple::STArray const& nfts = [&node] { - if (node.getFName() == ripple::sfCreatedNode) { - return node.peekAtField(ripple::sfNewFields) - .downcast() - .getFieldArray(ripple::sfNFTokens); + xrpl::STArray const& nfts = [&node] { + if (node.getFName() == xrpl::sfCreatedNode) { + return node.peekAtField(xrpl::sfNewFields).downcast().getFieldArray(xrpl::sfNFTokens); } - return node.peekAtField(ripple::sfFinalFields) - .downcast() - .getFieldArray(ripple::sfNFTokens); + return node.peekAtField(xrpl::sfFinalFields).downcast().getFieldArray(xrpl::sfNFTokens); }(); - auto const nft = std::ranges::find_if(nfts, [&tokenID](ripple::STObject const& candidate) { - return candidate.getFieldH256(ripple::sfNFTokenID) == tokenID; + auto const nft = std::ranges::find_if(nfts, [&tokenID](xrpl::STObject const& candidate) { + return candidate.getFieldH256(xrpl::sfNFTokenID) == tokenID; }); if (nft != nfts.end()) { return { @@ -296,15 +282,15 @@ getNFTokenAcceptOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx // transaction using this feature. This transaction also never returns an // NFTsData because it does not change the state of an NFT itself. std::pair, std::optional> -getNFTokenCancelOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getNFTokenCancelOfferData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { std::vector txs; - for (ripple::STObject const& node : txMeta.getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltNFTOKEN_OFFER) + for (xrpl::STObject const& node : txMeta.getNodes()) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltNFTOKEN_OFFER) continue; - ripple::uint256 const tokenID = - node.peekAtField(ripple::sfFinalFields).downcast().getFieldH256(ripple::sfNFTokenID); + xrpl::uint256 const tokenID = + node.peekAtField(xrpl::sfFinalFields).downcast().getFieldH256(xrpl::sfNFTokenID); txs.emplace_back(tokenID, txMeta, sttx.getTransactionID()); } @@ -322,34 +308,34 @@ getNFTokenCancelOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx // This transaction never returns an NFTokensData because it does not // change the state of an NFT itself. std::pair, std::optional> -getNFTokenCreateOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getNFTokenCreateOfferData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { - return {{NFTTransactionsData(sttx.getFieldH256(ripple::sfNFTokenID), txMeta, sttx.getTransactionID())}, {}}; + return {{NFTTransactionsData(sttx.getFieldH256(xrpl::sfNFTokenID), txMeta, sttx.getTransactionID())}, {}}; } std::pair, std::optional> -getNFTDataFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getNFTDataFromTx(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { - if (txMeta.getResultTER() != ripple::tesSUCCESS) + if (txMeta.getResultTER() != xrpl::tesSUCCESS) return {{}, {}}; switch (sttx.getTxnType()) { - case ripple::TxType::ttNFTOKEN_MINT: + case xrpl::TxType::ttNFTOKEN_MINT: return getNFTokenMintData(txMeta, sttx); - case ripple::TxType::ttNFTOKEN_BURN: + case xrpl::TxType::ttNFTOKEN_BURN: return getNFTokenBurnData(txMeta, sttx); - case ripple::TxType::ttNFTOKEN_ACCEPT_OFFER: + case xrpl::TxType::ttNFTOKEN_ACCEPT_OFFER: return getNFTokenAcceptOfferData(txMeta, sttx); - case ripple::TxType::ttNFTOKEN_CANCEL_OFFER: + case xrpl::TxType::ttNFTOKEN_CANCEL_OFFER: return getNFTokenCancelOfferData(txMeta, sttx); - case ripple::TxType::ttNFTOKEN_CREATE_OFFER: + case xrpl::TxType::ttNFTOKEN_CREATE_OFFER: return getNFTokenCreateOfferData(txMeta, sttx); - case ripple::TxType::ttNFTOKEN_MODIFY: + case xrpl::TxType::ttNFTOKEN_MODIFY: return getNftokenModifyData(txMeta, sttx); default: @@ -361,19 +347,19 @@ std::vector getNFTDataFromObj(std::uint32_t const seq, std::string const& key, std::string const& blob) { // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0020-non-fungible-tokens#tokenpage-id-format - ASSERT(key.size() == ripple::uint256::size(), "The size of the key (token) is expected to fit uint256 exactly"); + ASSERT(key.size() == xrpl::uint256::size(), "The size of the key (token) is expected to fit uint256 exactly"); auto const sle = - ripple::STLedgerEntry(ripple::SerialIter{blob.data(), blob.size()}, ripple::uint256::fromVoid(key.data())); + xrpl::STLedgerEntry(xrpl::SerialIter{blob.data(), blob.size()}, xrpl::uint256::fromVoid(key.data())); - if (sle.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltNFTOKEN_PAGE) + if (sle.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltNFTOKEN_PAGE) return {}; - auto const owner = ripple::AccountID::fromVoid(key.data()); + auto const owner = xrpl::AccountID::fromVoid(key.data()); std::vector nfts; - for (ripple::STObject const& node : sle.getFieldArray(ripple::sfNFTokens)) - nfts.emplace_back(node.getFieldH256(ripple::sfNFTokenID), seq, owner, node.getFieldVL(ripple::sfURI)); + for (xrpl::STObject const& node : sle.getFieldArray(xrpl::sfNFTokens)) + nfts.emplace_back(node.getFieldH256(xrpl::sfNFTokenID), seq, owner, node.getFieldVL(xrpl::sfURI)); return nfts; } diff --git a/src/etl/NFTHelpers.hpp b/src/etl/NFTHelpers.hpp index ef8cdb74b..6c49a48a1 100644 --- a/src/etl/NFTHelpers.hpp +++ b/src/etl/NFTHelpers.hpp @@ -41,7 +41,7 @@ namespace etl { * @return NFT URI change data as a pair of transactions and optional NFTsData */ std::pair, std::optional> -getNftokenModifyData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getNftokenModifyData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Get the NFT Token mint data from a transaction @@ -51,7 +51,7 @@ getNftokenModifyData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); * @return NFT Token mint data as a pair of transactions and optional NFTsData */ std::pair, std::optional> -getNFTokenMintData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getNFTokenMintData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Get the NFT Token burn data from a transaction @@ -61,7 +61,7 @@ getNFTokenMintData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); * @return NFT Token burn data as a pair of transactions and optional NFTsData */ std::pair, std::optional> -getNFTokenBurnData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getNFTokenBurnData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Get the NFT Token accept offer data from a transaction @@ -71,7 +71,7 @@ getNFTokenBurnData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); * @return NFT Token accept offer data as a pair of transactions and optional NFTsData */ std::pair, std::optional> -getNFTokenAcceptOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getNFTokenAcceptOfferData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Get the NFT Token cancel offer data from a transaction @@ -81,7 +81,7 @@ getNFTokenAcceptOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx * @return NFT Token cancel offer data as a pair of transactions and optional NFTsData */ std::pair, std::optional> -getNFTokenCancelOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getNFTokenCancelOfferData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Get the NFT Token create offer data from a transaction @@ -91,7 +91,7 @@ getNFTokenCancelOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx * @return NFT Token create offer data as a pair of transactions and optional NFTsData */ std::pair, std::optional> -getNFTokenCreateOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getNFTokenCreateOfferData(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Pull NFT data from TX via ETLService. @@ -101,7 +101,7 @@ getNFTokenCreateOfferData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx * @return NFT transactions data as a pair of transactions and optional NFTsData */ std::pair, std::optional> -getNFTDataFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getNFTDataFromTx(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Pull NFT data from ledger object via loadInitialLedger. diff --git a/src/etl/RegistryInterface.hpp b/src/etl/RegistryInterface.hpp index 0b46e5857..ecf0f07ca 100644 --- a/src/etl/RegistryInterface.hpp +++ b/src/etl/RegistryInterface.hpp @@ -58,11 +58,11 @@ namespace etl { * @code{.cpp} * struct Ext { * using spec = etl::model::Spec< - * ripple::TxType::ttNFTOKEN_BURN, - * ripple::TxType::ttNFTOKEN_ACCEPT_OFFER, - * ripple::TxType::ttNFTOKEN_CREATE_OFFER, - * ripple::TxType::ttNFTOKEN_CANCEL_OFFER, - * ripple::TxType::ttNFTOKEN_MINT>; + * xrpl::TxType::ttNFTOKEN_BURN, + * xrpl::TxType::ttNFTOKEN_ACCEPT_OFFER, + * xrpl::TxType::ttNFTOKEN_CREATE_OFFER, + * xrpl::TxType::ttNFTOKEN_CANCEL_OFFER, + * xrpl::TxType::ttNFTOKEN_MINT>; * * static void * onInitialTransaction(uint32_t, etl::model::Transaction const&); diff --git a/src/etl/impl/AsyncGrpcCall.cpp b/src/etl/impl/AsyncGrpcCall.cpp index 7e34dd571..a57673749 100644 --- a/src/etl/impl/AsyncGrpcCall.cpp +++ b/src/etl/impl/AsyncGrpcCall.cpp @@ -43,24 +43,20 @@ namespace etl::impl { -AsyncGrpcCall::AsyncGrpcCall( - uint32_t seq, - ripple::uint256 const& marker, - std::optional const& nextMarker -) +AsyncGrpcCall::AsyncGrpcCall(uint32_t seq, xrpl::uint256 const& marker, std::optional const& nextMarker) { request_.set_user("ETL"); request_.mutable_ledger()->set_sequence(seq); if (marker.isNonZero()) - request_.set_marker(marker.data(), ripple::uint256::size()); + request_.set_marker(marker.data(), xrpl::uint256::size()); nextPrefix_ = nextMarker ? nextMarker->data()[0] : 0x00; auto const prefix = marker.data()[0]; - LOG(log_.debug()) << "Setting up AsyncGrpcCall. marker = " << ripple::strHex(marker) - << ". prefix = " << ripple::strHex(std::string(1, prefix)) - << ". nextPrefix_ = " << ripple::strHex(std::string(1, nextPrefix_)); + LOG(log_.debug()) << "Setting up AsyncGrpcCall. marker = " << xrpl::strHex(marker) + << ". prefix = " << xrpl::strHex(std::string(1, prefix)) + << ". nextPrefix_ = " << xrpl::strHex(std::string(1, nextPrefix_)); ASSERT( nextPrefix_ > prefix or nextPrefix_ == 0x00, @@ -157,7 +153,7 @@ AsyncGrpcCall::call(std::unique_ptrmarker().empty() ? std::string{} : ripple::strHex(std::string{next_->marker().data()[0]}); + return next_->marker().empty() ? std::string{} : xrpl::strHex(std::string{next_->marker().data()[0]}); } // this is used to generate edgeKeys - keys that were the last one in the onInitialObjects list diff --git a/src/etl/impl/AsyncGrpcCall.hpp b/src/etl/impl/AsyncGrpcCall.hpp index 4d54fe3e6..3eaaadfe1 100644 --- a/src/etl/impl/AsyncGrpcCall.hpp +++ b/src/etl/impl/AsyncGrpcCall.hpp @@ -59,7 +59,7 @@ private: std::optional predecessorKey_; public: - AsyncGrpcCall(uint32_t seq, ripple::uint256 const& marker, std::optional const& nextMarker); + AsyncGrpcCall(uint32_t seq, xrpl::uint256 const& marker, std::optional const& nextMarker); static std::vector makeAsyncCalls(uint32_t const sequence, uint32_t const numMarkers); diff --git a/src/etl/impl/BaseCursorProvider.hpp b/src/etl/impl/BaseCursorProvider.hpp index 0006c5830..86a731417 100644 --- a/src/etl/impl/BaseCursorProvider.hpp +++ b/src/etl/impl/BaseCursorProvider.hpp @@ -26,8 +26,8 @@ namespace etl::impl { struct CursorPair { - ripple::uint256 start; - ripple::uint256 end; + xrpl::uint256 start; + xrpl::uint256 end; }; struct BaseCursorProvider { diff --git a/src/etl/impl/CacheLoader.hpp b/src/etl/impl/CacheLoader.hpp index 6aab058a5..74b23d9d0 100644 --- a/src/etl/impl/CacheLoader.hpp +++ b/src/etl/impl/CacheLoader.hpp @@ -120,7 +120,7 @@ private: } auto [start, end] = cursor.value(); - LOG(log_.debug()) << "Starting a cursor: " << ripple::strHex(start); + LOG(log_.debug()) << "Starting a cursor: " << xrpl::strHex(start); while (not token.isStopRequested() and not cache_.get().isDisabled()) { auto res = data::retryOnTimeout([this, seq, cachePageFetchSize, &start, token]() { diff --git a/src/etl/impl/CursorFromAccountProvider.hpp b/src/etl/impl/CursorFromAccountProvider.hpp index 0ae6d8a77..4d2188855 100644 --- a/src/etl/impl/CursorFromAccountProvider.hpp +++ b/src/etl/impl/CursorFromAccountProvider.hpp @@ -58,7 +58,7 @@ public: }(); rg::sort(accountRoots); - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFIRST_KEY}; rg::copy(accountRoots.begin(), accountRoots.end(), std::back_inserter(cursors)); rg::sort(cursors); cursors.push_back(data::kLAST_KEY); diff --git a/src/etl/impl/CursorFromDiffProvider.hpp b/src/etl/impl/CursorFromDiffProvider.hpp index e5f091c13..d715e1ee0 100644 --- a/src/etl/impl/CursorFromDiffProvider.hpp +++ b/src/etl/impl/CursorFromDiffProvider.hpp @@ -62,8 +62,8 @@ public: auto const range = backend_->fetchLedgerRange(); ASSERT(range.has_value(), "Ledger range is not available when cache is loading"); - std::set liveCursors; - std::set deletedCursors; + std::set liveCursors; + std::set deletedCursors; auto i = 0; while (liveCursors.size() < numCursors_ and seq - i >= range->minSequence) { auto diffs = fetchDiff(i++); @@ -85,7 +85,7 @@ public: ); } - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFIRST_KEY}; rg::copy(liveCursors | vs::take(std::min(liveCursors.size(), numCursors_)), std::back_inserter(cursors)); rg::sort(cursors); cursors.push_back(data::kLAST_KEY); diff --git a/src/etl/impl/CursorFromFixDiffNumProvider.hpp b/src/etl/impl/CursorFromFixDiffNumProvider.hpp index 5daac00b8..3a3b105e4 100644 --- a/src/etl/impl/CursorFromFixDiffNumProvider.hpp +++ b/src/etl/impl/CursorFromFixDiffNumProvider.hpp @@ -74,7 +74,7 @@ public: rg::unique(diffs, [](auto const& a, auto const& b) { return a.key == b.key; }); diffs.erase(removalCursor, last); - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFIRST_KEY}; rg::copy( diffs // | vs::filter([](auto const& obj) { return not obj.blob.empty(); }) // diff --git a/src/etl/impl/Extraction.cpp b/src/etl/impl/Extraction.cpp index b048a4510..5bd8865f7 100644 --- a/src/etl/impl/Extraction.cpp +++ b/src/etl/impl/Extraction.cpp @@ -29,6 +29,7 @@ #include "util/Profiler.hpp" #include "util/log/Logger.hpp" +#include #include #include #include @@ -72,9 +73,10 @@ model::Transaction extractTx(PBTxType tx, uint32_t seq) { auto raw = std::move(*tx.mutable_transaction_blob()); - ripple::SerialIter it{raw.data(), raw.size()}; - ripple::STTx const sttx{it}; - ripple::TxMeta meta{sttx.getTransactionID(), seq, tx.metadata_blob()}; + xrpl::SerialIter it{raw.data(), raw.size()}; + xrpl::STTx const sttx{it}; + auto const& metaBlob = tx.metadata_blob(); + xrpl::TxMeta meta{sttx.getTransactionID(), seq, xrpl::Blob{metaBlob.begin(), metaBlob.end()}}; return { .raw = std::move(raw), @@ -104,7 +106,7 @@ extractTxs(PBTxListType transactions, uint32_t seq) model::Object extractObj(PBObjType obj) { - auto const key = ripple::uint256::fromVoidChecked(obj.key()); + auto const key = xrpl::uint256::fromVoidChecked(obj.key()); ASSERT(key.has_value(), "Failed to deserialize key from void"); auto const valueOr = [](std::string const& maybe, std::string fallback) -> std::string { @@ -171,7 +173,7 @@ auto Extractor::unpack() { return [](auto&& data) { - auto header = ::util::deserializeHeader(ripple::makeSlice(data.ledger_header())); + auto header = ::util::deserializeHeader(xrpl::makeSlice(data.ledger_header())); return std::make_optional({ .transactions = diff --git a/src/etl/impl/LedgerPublisher.hpp b/src/etl/impl/LedgerPublisher.hpp index 0b48ca3f6..8d9d076c5 100644 --- a/src/etl/impl/LedgerPublisher.hpp +++ b/src/etl/impl/LedgerPublisher.hpp @@ -80,7 +80,7 @@ class LedgerPublisher : public LedgerPublisherInterface { std::shared_ptr subscriptions_; std::reference_wrapper state_; // shared state for ETL - util::Mutex, std::shared_mutex> lastCloseTime_; + util::Mutex, std::shared_mutex> lastCloseTime_; std::reference_wrapper lastPublishSeconds_ = PrometheusService::counterInt( "etl_last_publish_seconds", @@ -161,7 +161,7 @@ public: * @param lgrInfo the ledger to publish */ void - publish(ripple::LedgerHeader const& lgrInfo) + publish(xrpl::LedgerHeader const& lgrInfo) { publishStrand_.submit([this, lgrInfo = lgrInfo] { LOG(log_.info()) << "Publishing ledger " << std::to_string(lgrInfo.seq); @@ -172,7 +172,7 @@ public: // if the ledger closed over MAX_LEDGER_AGE_SECONDS ago, assume we are still catching up and don't publish static constexpr std::uint32_t kMAX_LEDGER_AGE_SECONDS = 600; if (age < kMAX_LEDGER_AGE_SECONDS) { - std::optional fees = data::synchronousAndRetryOnTimeout([&](auto yield) { + std::optional fees = data::synchronousAndRetryOnTimeout([&](auto yield) { return backend_->fetchFees(lgrInfo.seq, yield); }); ASSERT(fees.has_value(), "Fees must exist for ledger {}", lgrInfo.seq); @@ -189,12 +189,12 @@ public: // order with transaction index std::ranges::sort(transactions, [](auto const& t1, auto const& t2) { - ripple::SerialIter iter1{t1.metadata.data(), t1.metadata.size()}; - ripple::STObject const object1(iter1, ripple::sfMetadata); - ripple::SerialIter iter2{t2.metadata.data(), t2.metadata.size()}; - ripple::STObject const object2(iter2, ripple::sfMetadata); - return object1.getFieldU32(ripple::sfTransactionIndex) < - object2.getFieldU32(ripple::sfTransactionIndex); + xrpl::SerialIter iter1{t1.metadata.data(), t1.metadata.size()}; + xrpl::STObject const object1(iter1, xrpl::sfMetadata); + xrpl::SerialIter iter2{t2.metadata.data(), t2.metadata.size()}; + xrpl::STObject const object2(iter2, xrpl::sfMetadata); + return object1.getFieldU32(xrpl::sfTransactionIndex) < + object2.getFieldU32(xrpl::sfTransactionIndex); }); for (auto const& txAndMeta : transactions) @@ -260,7 +260,7 @@ public: private: void - setLastClose(std::chrono::time_point lastCloseTime) + setLastClose(std::chrono::time_point lastCloseTime) { auto closeTime = lastCloseTime_.lock(); *closeTime = lastCloseTime; diff --git a/src/etl/impl/Loading.cpp b/src/etl/impl/Loading.cpp index 59d2d0a9c..2f82cbef7 100644 --- a/src/etl/impl/Loading.cpp +++ b/src/etl/impl/Loading.cpp @@ -128,7 +128,7 @@ Loader::onInitialLoadGotMoreObjects( } } -std::optional +std::optional Loader::loadInitialLedger(model::LedgerData const& data) { try { diff --git a/src/etl/impl/Loading.hpp b/src/etl/impl/Loading.hpp index bacc08205..06d6285be 100644 --- a/src/etl/impl/Loading.hpp +++ b/src/etl/impl/Loading.hpp @@ -86,7 +86,7 @@ public: std::optional lastKey ) override; - std::optional + std::optional loadInitialLedger(model::LedgerData const& data) override; }; diff --git a/src/etl/impl/ext/MPT.cpp b/src/etl/impl/ext/MPT.cpp index e88c01f1f..61474a2a4 100644 --- a/src/etl/impl/ext/MPT.cpp +++ b/src/etl/impl/ext/MPT.cpp @@ -49,7 +49,7 @@ MPTExt::onLedgerData(model::LedgerData const& data) void MPTExt::onInitialObject(uint32_t, model::Object const& obj) { - LOG(log_.trace()) << "got initial object with key: " << ripple::strHex(obj.key); + LOG(log_.trace()) << "got initial object with key: " << xrpl::strHex(obj.key); if (auto const mptHolder = getMPTHolderFromObj(obj.keyRaw, obj.dataRaw); mptHolder.has_value()) backend_->writeMPTHolders({*mptHolder}); } diff --git a/src/etl/impl/ext/Successor.cpp b/src/etl/impl/ext/Successor.cpp index ff0092170..7956b9d4f 100644 --- a/src/etl/impl/ext/Successor.cpp +++ b/src/etl/impl/ext/Successor.cpp @@ -144,7 +144,7 @@ SuccessorExt::updateSuccessorFromCache(uint32_t seq, model::Object const& obj) c if (isDeleted) { auto const old = cache_.get().getDeleted(obj.key, seq - 1); - ASSERT(old.has_value(), "Deleted object {} must be in cache", ripple::strHex(obj.key)); + ASSERT(old.has_value(), "Deleted object {} must be in cache", xrpl::strHex(obj.key)); checkBookBase = isBookDir(obj.key, *old); } else { @@ -172,7 +172,7 @@ void SuccessorExt::updateBookSuccessor( std::optional const& maybeSuccessor, auto seq, - ripple::uint256 const& bookBase + xrpl::uint256 const& bookBase ) const { if (maybeSuccessor.has_value()) { @@ -185,7 +185,7 @@ SuccessorExt::updateBookSuccessor( void SuccessorExt::writeSuccessors(uint32_t seq) const { - ripple::uint256 prev = data::kFIRST_KEY; + xrpl::uint256 prev = data::kFIRST_KEY; while (auto cur = cache_.get().getSuccessor(prev, seq)) { if (prev == data::kFIRST_KEY) backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(cur->key)); @@ -196,7 +196,7 @@ SuccessorExt::writeSuccessors(uint32_t seq) const // make sure the base is not an actual object if (not cache_.get().get(base, seq)) { auto succ = cache_.get().getSuccessor(base, seq); - ASSERT(succ.has_value(), "Book base {} must have a successor", ripple::strHex(base)); + ASSERT(succ.has_value(), "Book base {} must have a successor", xrpl::strHex(base)); if (succ->key == cur->key) backend_->writeSuccessor(uint256ToString(base), seq, uint256ToString(cur->key)); @@ -213,7 +213,7 @@ void SuccessorExt::writeEdgeKeys(std::uint32_t seq, auto const& edgeKeys) const { for (auto const& key : edgeKeys) { - auto succ = cache_.get().getSuccessor(*ripple::uint256::fromVoidChecked(key), seq); + auto succ = cache_.get().getSuccessor(*xrpl::uint256::fromVoidChecked(key), seq); if (succ) backend_->writeSuccessor(auto{key}, seq, uint256ToString(succ->key)); } diff --git a/src/etl/impl/ext/Successor.hpp b/src/etl/impl/ext/Successor.hpp index 7b86951de..47dba47b7 100644 --- a/src/etl/impl/ext/Successor.hpp +++ b/src/etl/impl/ext/Successor.hpp @@ -69,7 +69,7 @@ private: updateBookSuccessor( std::optional const& maybeSuccessor, auto seq, - ripple::uint256 const& bookBase + xrpl::uint256 const& bookBase ) const; void diff --git a/src/feed/SubscriptionManager.cpp b/src/feed/SubscriptionManager.cpp index c8fc59caa..d2c6b73f7 100644 --- a/src/feed/SubscriptionManager.cpp +++ b/src/feed/SubscriptionManager.cpp @@ -48,7 +48,7 @@ SubscriptionManager::unsubBookChanges(SubscriberSharedPtr const& subscriber) void SubscriptionManager::pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) { @@ -72,7 +72,7 @@ SubscriptionManager::unsubProposedTransactions(SubscriberSharedPtr const& subscr } void -SubscriptionManager::subProposedAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +SubscriptionManager::subProposedAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { proposedTransactionFeed_.sub(account, subscriber); // Same as proposed_transactions subscribers, proposed_account subscribers also subscribe to the transaction feed to @@ -81,7 +81,7 @@ SubscriptionManager::subProposedAccount(ripple::AccountID const& account, Subscr } void -SubscriptionManager::unsubProposedAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +SubscriptionManager::unsubProposedAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { proposedTransactionFeed_.unsub(account, subscriber); transactionFeed_.unsubProposed(account, subscriber); @@ -107,8 +107,8 @@ SubscriptionManager::unsubLedger(SubscriberSharedPtr const& subscriber) void SubscriptionManager::pubLedger( - ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, std::uint32_t const txnCount ) @@ -165,31 +165,31 @@ SubscriptionManager::unsubTransactions(SubscriberSharedPtr const& subscriber) } void -SubscriptionManager::subAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +SubscriptionManager::subAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { transactionFeed_.sub(account, subscriber); } void -SubscriptionManager::unsubAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +SubscriptionManager::unsubAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { transactionFeed_.unsub(account, subscriber); } void -SubscriptionManager::subBook(ripple::Book const& book, SubscriberSharedPtr const& subscriber) +SubscriptionManager::subBook(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) { transactionFeed_.sub(book, subscriber); } void -SubscriptionManager::unsubBook(ripple::Book const& book, SubscriberSharedPtr const& subscriber) +SubscriptionManager::unsubBook(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) { transactionFeed_.unsub(book, subscriber); } void -SubscriptionManager::pubTransaction(data::TransactionAndMetadata const& txMeta, ripple::LedgerHeader const& lgrInfo) +SubscriptionManager::pubTransaction(data::TransactionAndMetadata const& txMeta, xrpl::LedgerHeader const& lgrInfo) { transactionFeed_.pub(txMeta, lgrInfo, backend_, amendmentCenter_, networkID_); } diff --git a/src/feed/SubscriptionManager.hpp b/src/feed/SubscriptionManager.hpp index 26fa630e2..baf78c5b4 100644 --- a/src/feed/SubscriptionManager.hpp +++ b/src/feed/SubscriptionManager.hpp @@ -160,7 +160,7 @@ public: */ void pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) final; @@ -184,7 +184,7 @@ public: * @param subscriber */ void - subProposedAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) final; + subProposedAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) final; /** * @brief Unsubscribe to the proposed transactions feed for particular account. @@ -192,7 +192,7 @@ public: * @param subscriber */ void - unsubProposedAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) final; + unsubProposedAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) final; /** * @brief Forward the proposed transactions feed. @@ -226,8 +226,8 @@ public: */ void pubLedger( - ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, std::uint32_t txnCount ) final; @@ -294,7 +294,7 @@ public: * @param subscriber */ void - subAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) final; + subAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) final; /** * @brief Unsubscribe to the transactions feed for particular account. @@ -302,7 +302,7 @@ public: * @param subscriber The subscriber to unsubscribe */ void - unsubAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) final; + unsubAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) final; /** * @brief Subscribe to the transactions feed, only receive feed when particular order book is affected. @@ -310,7 +310,7 @@ public: * @param subscriber */ void - subBook(ripple::Book const& book, SubscriberSharedPtr const& subscriber) final; + subBook(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) final; /** * @brief Unsubscribe to the transactions feed for particular order book. @@ -318,7 +318,7 @@ public: * @param subscriber */ void - unsubBook(ripple::Book const& book, SubscriberSharedPtr const& subscriber) final; + unsubBook(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) final; /** * @brief Forward the transactions feed. @@ -326,7 +326,7 @@ public: * @param lgrInfo The ledger header. */ void - pubTransaction(data::TransactionAndMetadata const& txMeta, ripple::LedgerHeader const& lgrInfo) final; + pubTransaction(data::TransactionAndMetadata const& txMeta, xrpl::LedgerHeader const& lgrInfo) final; /** * @brief Get the number of subscribers. diff --git a/src/feed/SubscriptionManagerInterface.hpp b/src/feed/SubscriptionManagerInterface.hpp index 8303fb693..f0c8864e8 100644 --- a/src/feed/SubscriptionManagerInterface.hpp +++ b/src/feed/SubscriptionManagerInterface.hpp @@ -72,7 +72,7 @@ public: */ virtual void pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) = 0; @@ -96,7 +96,7 @@ public: * @param subscriber */ virtual void - subProposedAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; + subProposedAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; /** * @brief Unsubscribe to the proposed transactions feed for particular account. @@ -104,7 +104,7 @@ public: * @param subscriber */ virtual void - unsubProposedAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; + unsubProposedAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; /** * @brief Forward the proposed transactions feed. @@ -139,8 +139,8 @@ public: */ virtual void pubLedger( - ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, std::uint32_t txnCount ) = 0; @@ -207,7 +207,7 @@ public: * @param subscriber */ virtual void - subAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; + subAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; /** * @brief Unsubscribe to the transactions feed for particular account. @@ -215,7 +215,7 @@ public: * @param subscriber The subscriber to unsubscribe */ virtual void - unsubAccount(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; + unsubAccount(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) = 0; /** * @brief Subscribe to the transactions feed, only receive feed when particular order book is affected. @@ -223,7 +223,7 @@ public: * @param subscriber */ virtual void - subBook(ripple::Book const& book, SubscriberSharedPtr const& subscriber) = 0; + subBook(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) = 0; /** * @brief Unsubscribe to the transactions feed for particular order book. @@ -231,7 +231,7 @@ public: * @param subscriber */ virtual void - unsubBook(ripple::Book const& book, SubscriberSharedPtr const& subscriber) = 0; + unsubBook(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) = 0; /** * @brief Forward the transactions feed. @@ -239,7 +239,7 @@ public: * @param lgrInfo The ledger header. */ virtual void - pubTransaction(data::TransactionAndMetadata const& txMeta, ripple::LedgerHeader const& lgrInfo) = 0; + pubTransaction(data::TransactionAndMetadata const& txMeta, xrpl::LedgerHeader const& lgrInfo) = 0; /** * @brief Get the number of subscribers. diff --git a/src/feed/impl/BookChangesFeed.hpp b/src/feed/impl/BookChangesFeed.hpp index 4d2693959..a9803055d 100644 --- a/src/feed/impl/BookChangesFeed.hpp +++ b/src/feed/impl/BookChangesFeed.hpp @@ -48,7 +48,7 @@ struct BookChangesFeed : public SingleFeedBase { * @param transactions The transactions that were included in the ledger. */ void - pub(ripple::LedgerHeader const& lgrInfo, std::vector const& transactions) + pub(xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions) { SingleFeedBase::pub(boost::json::serialize(rpc::computeBookChanges(lgrInfo, transactions))); } diff --git a/src/feed/impl/LedgerFeed.cpp b/src/feed/impl/LedgerFeed.cpp index a726c307a..752351cd9 100644 --- a/src/feed/impl/LedgerFeed.cpp +++ b/src/feed/impl/LedgerFeed.cpp @@ -41,8 +41,8 @@ namespace feed::impl { boost::json::object LedgerFeed::makeLedgerPubMessage( - ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, uint32_t const txnCount, uint32_t const networkID @@ -93,8 +93,8 @@ LedgerFeed::sub( void LedgerFeed::pub( - ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, uint32_t const txnCount, uint32_t const networkID diff --git a/src/feed/impl/LedgerFeed.hpp b/src/feed/impl/LedgerFeed.hpp index f8e93cd02..7cc66956d 100644 --- a/src/feed/impl/LedgerFeed.hpp +++ b/src/feed/impl/LedgerFeed.hpp @@ -77,8 +77,8 @@ public: * @param networkID The network ID. */ void - pub(ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + pub(xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, uint32_t txnCount, uint32_t networkID); @@ -86,8 +86,8 @@ public: private: static boost::json::object makeLedgerPubMessage( - ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, uint32_t txnCount, uint32_t networkID diff --git a/src/feed/impl/ProposedTransactionFeed.cpp b/src/feed/impl/ProposedTransactionFeed.cpp index 6e305a8cb..b5fe15bef 100644 --- a/src/feed/impl/ProposedTransactionFeed.cpp +++ b/src/feed/impl/ProposedTransactionFeed.cpp @@ -53,7 +53,7 @@ ProposedTransactionFeed::sub(SubscriberSharedPtr const& subscriber) } void -ProposedTransactionFeed::sub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +ProposedTransactionFeed::sub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { auto const weakPtr = std::weak_ptr(subscriber); auto const added = accountSignal_.connectTrackableSlot( @@ -82,7 +82,7 @@ ProposedTransactionFeed::unsub(SubscriberSharedPtr const& subscriber) } void -ProposedTransactionFeed::unsub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +ProposedTransactionFeed::unsub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { unsubInternal(account, subscriber.get()); } @@ -94,7 +94,7 @@ ProposedTransactionFeed::pub(boost::json::object const& receivedTxJson) auto const transaction = receivedTxJson.at("transaction").as_object(); auto const accounts = rpc::getAccountsFromTransaction(transaction); - auto affectedAccounts = std::unordered_set(accounts.cbegin(), accounts.cend()); + auto affectedAccounts = std::unordered_set(accounts.cbegin(), accounts.cend()); [[maybe_unused]] auto task = strand_.execute([this, pubMsg = std::move(pubMsg), affectedAccounts = std::move(affectedAccounts)]() { @@ -132,7 +132,7 @@ ProposedTransactionFeed::unsubInternal(SubscriberPtr subscriber) } void -ProposedTransactionFeed::unsubInternal(ripple::AccountID const& account, SubscriberPtr subscriber) +ProposedTransactionFeed::unsubInternal(xrpl::AccountID const& account, SubscriberPtr subscriber) { if (accountSignal_.disconnect(subscriber, account)) { LOG(logger_.info()) << subscriber->tag() << "Unsubscribed accounts_proposed " << account; diff --git a/src/feed/impl/ProposedTransactionFeed.hpp b/src/feed/impl/ProposedTransactionFeed.hpp index 9d2a74367..9d4a0cd24 100644 --- a/src/feed/impl/ProposedTransactionFeed.hpp +++ b/src/feed/impl/ProposedTransactionFeed.hpp @@ -57,7 +57,7 @@ class ProposedTransactionFeed { std::reference_wrapper subAllCount_; std::reference_wrapper subAccountCount_; - TrackableSignalMap> accountSignal_; + TrackableSignalMap> accountSignal_; TrackableSignal> signal_; public: @@ -86,7 +86,7 @@ public: * @param account The account to watch. */ void - sub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber); + sub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber); /** * @brief Unsubscribe to the proposed transaction feed. @@ -101,7 +101,7 @@ public: * @param account The account to unsubscribe. */ void - unsub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber); + unsub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber); /** * @brief Publishes the proposed transaction feed. @@ -127,6 +127,6 @@ private: unsubInternal(SubscriberPtr subscriber); void - unsubInternal(ripple::AccountID const& account, SubscriberPtr subscriber); + unsubInternal(xrpl::AccountID const& account, SubscriberPtr subscriber); }; } // namespace feed::impl diff --git a/src/feed/impl/TransactionFeed.cpp b/src/feed/impl/TransactionFeed.cpp index be79956b6..790339647 100644 --- a/src/feed/impl/TransactionFeed.cpp +++ b/src/feed/impl/TransactionFeed.cpp @@ -37,6 +37,7 @@ #include #include #include +#include #include #include #include @@ -85,7 +86,7 @@ TransactionFeed::sub(SubscriberSharedPtr const& subscriber) } void -TransactionFeed::sub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +TransactionFeed::sub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { auto const added = accountSignal_.connectTrackableSlot(subscriber, account, TransactionSlot(*this, subscriber)); if (added) { @@ -105,7 +106,7 @@ TransactionFeed::subProposed(SubscriberSharedPtr const& subscriber) } void -TransactionFeed::subProposed(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +TransactionFeed::subProposed(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { auto const added = accountProposedSignal_.connectTrackableSlot(subscriber, account, TransactionSlot(*this, subscriber)); @@ -117,7 +118,7 @@ TransactionFeed::subProposed(ripple::AccountID const& account, SubscriberSharedP } void -TransactionFeed::sub(ripple::Book const& book, SubscriberSharedPtr const& subscriber) +TransactionFeed::sub(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) { auto const added = bookSignal_.connectTrackableSlot(subscriber, book, TransactionSlot(*this, subscriber)); if (added) { @@ -134,7 +135,7 @@ TransactionFeed::unsub(SubscriberSharedPtr const& subscriber) } void -TransactionFeed::unsub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +TransactionFeed::unsub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { unsubInternal(account, subscriber.get()); } @@ -146,13 +147,13 @@ TransactionFeed::unsubProposed(SubscriberSharedPtr const& subscriber) } void -TransactionFeed::unsubProposed(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber) +TransactionFeed::unsubProposed(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber) { unsubProposedInternal(account, subscriber.get()); } void -TransactionFeed::unsub(ripple::Book const& book, SubscriberSharedPtr const& subscriber) +TransactionFeed::unsub(xrpl::Book const& book, SubscriberSharedPtr const& subscriber) { unsubInternal(book, subscriber.get()); } @@ -178,7 +179,7 @@ TransactionFeed::bookSubCount() const void TransactionFeed::pub( data::TransactionAndMetadata const& txMeta, - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::shared_ptr const& backend, std::shared_ptr const& amendmentCenter, uint32_t const networkID @@ -186,12 +187,12 @@ TransactionFeed::pub( { auto [tx, meta] = rpc::deserializeTxPlusMeta(txMeta, lgrInfo.seq); - std::optional ownerFunds; + std::optional ownerFunds; - if (tx->getTxnType() == ripple::ttOFFER_CREATE) { - auto const account = tx->getAccountID(ripple::sfAccount); - auto const amount = tx->getFieldAmount(ripple::sfTakerGets); - if (account != amount.issue().account) { + if (tx->getTxnType() == xrpl::ttOFFER_CREATE) { + auto const account = tx->getAccountID(xrpl::sfAccount); + auto const amount = tx->getFieldAmount(xrpl::sfTakerGets); + if (account != amount.get().account) { auto fetchFundsSynchronous = [&]() { data::synchronous([&](boost::asio::yield_context yield) { ownerFunds = rpc::accountFunds(*backend, *amendmentCenter, lgrInfo.seq, amount, account, yield); @@ -213,8 +214,8 @@ TransactionFeed::pub( rpc::insertDeliverMaxAlias(txnPubobj, version); rpc::insertMPTIssuanceID(txnPubobj, tx, metaPubobj, meta); - Json::Value nftJson; - ripple::RPC::insertNFTSyntheticInJson(nftJson, tx, *meta); + json::Value nftJson; + xrpl::RPC::insertNFTSyntheticInJson(nftJson, tx, *meta); auto const nftBoostJson = rpc::toBoostJson(nftJson).as_object(); if (nftBoostJson.contains(JS(meta)) && nftBoostJson.at(JS(meta)).is_object()) { auto& metaObjInPub = pubObj.at(JS(meta)).as_object(); @@ -235,10 +236,10 @@ TransactionFeed::pub( pubObj[JS(type)] = "transaction"; pubObj[JS(validated)] = true; pubObj[JS(status)] = "closed"; - pubObj[JS(close_time_iso)] = ripple::to_string_iso(lgrInfo.closeTime); + pubObj[JS(close_time_iso)] = xrpl::toStringIso(lgrInfo.closeTime); pubObj[JS(ledger_index)] = lgrInfo.seq; - pubObj[JS(ledger_hash)] = ripple::strHex(lgrInfo.hash); + pubObj[JS(ledger_hash)] = xrpl::strHex(lgrInfo.hash); if (version >= 2u) { if (pubObj[txKey].as_object().contains(JS(hash))) { pubObj[JS(hash)] = pubObj[txKey].as_object()[JS(hash)]; @@ -250,7 +251,7 @@ TransactionFeed::pub( pubObj[JS(engine_result_code)] = meta->getResult(); std::string token; std::string human; - ripple::transResultInfo(meta->getResultTER(), token, human); + xrpl::transResultInfo(meta->getResultTER(), token, human); pubObj[JS(engine_result)] = token; pubObj[JS(engine_result_message)] = human; @@ -267,34 +268,34 @@ TransactionFeed::pub( auto const affectedAccountsFlat = meta->getAffectedAccounts(); auto affectedAccounts = - std::unordered_set(affectedAccountsFlat.cbegin(), affectedAccountsFlat.cend()); + std::unordered_set(affectedAccountsFlat.cbegin(), affectedAccountsFlat.cend()); - std::unordered_set affectedBooks; + std::unordered_set affectedBooks; for (auto const& node : meta->getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) == ripple::ltOFFER) { - ripple::SField const* field = nullptr; + if (node.getFieldU16(xrpl::sfLedgerEntryType) == xrpl::ltOFFER) { + xrpl::SField const* field = nullptr; // We need a field that contains the TakerGets and TakerPays // parameters. - if (node.getFName() == ripple::sfModifiedNode) { - field = &ripple::sfPreviousFields; - } else if (node.getFName() == ripple::sfCreatedNode) { - field = &ripple::sfNewFields; - } else if (node.getFName() == ripple::sfDeletedNode) { - field = &ripple::sfFinalFields; + if (node.getFName() == xrpl::sfModifiedNode) { + field = &xrpl::sfPreviousFields; + } else if (node.getFName() == xrpl::sfCreatedNode) { + field = &xrpl::sfNewFields; + } else if (node.getFName() == xrpl::sfDeletedNode) { + field = &xrpl::sfFinalFields; } if (field != nullptr) { - auto const data = dynamic_cast(node.peekAtPField(*field)); + auto const data = dynamic_cast(node.peekAtPField(*field)); - if ((data != nullptr) && data->isFieldPresent(ripple::sfTakerPays) && - data->isFieldPresent(ripple::sfTakerGets)) { + if ((data != nullptr) && data->isFieldPresent(xrpl::sfTakerPays) && + data->isFieldPresent(xrpl::sfTakerGets)) { // determine the OrderBook - ripple::Book const book{ - data->getFieldAmount(ripple::sfTakerGets).issue(), - data->getFieldAmount(ripple::sfTakerPays).issue(), - (*data)[~ripple::sfDomainID] + xrpl::Book const book{ + data->getFieldAmount(xrpl::sfTakerGets).get(), + data->getFieldAmount(xrpl::sfTakerPays).get(), + (*data)[~xrpl::sfDomainID] }; if (!affectedBooks.contains(book)) { affectedBooks.insert(book); @@ -340,7 +341,7 @@ TransactionFeed::unsubInternal(SubscriberPtr subscriber) } void -TransactionFeed::unsubInternal(ripple::AccountID const& account, SubscriberPtr subscriber) +TransactionFeed::unsubInternal(xrpl::AccountID const& account, SubscriberPtr subscriber) { if (accountSignal_.disconnect(subscriber, account)) { LOG(logger_.info()) << subscriber->tag() << "Unsubscribed account " << account; @@ -355,13 +356,13 @@ TransactionFeed::unsubProposedInternal(SubscriberPtr subscriber) } void -TransactionFeed::unsubProposedInternal(ripple::AccountID const& account, SubscriberPtr subscriber) +TransactionFeed::unsubProposedInternal(xrpl::AccountID const& account, SubscriberPtr subscriber) { accountProposedSignal_.disconnect(subscriber, account); } void -TransactionFeed::unsubInternal(ripple::Book const& book, SubscriberPtr subscriber) +TransactionFeed::unsubInternal(xrpl::Book const& book, SubscriberPtr subscriber) { if (bookSignal_.disconnect(subscriber, book)) { LOG(logger_.info()) << subscriber->tag() << "Unsubscribed book " << book; diff --git a/src/feed/impl/TransactionFeed.hpp b/src/feed/impl/TransactionFeed.hpp index 8b2021298..4bbe3ece6 100644 --- a/src/feed/impl/TransactionFeed.hpp +++ b/src/feed/impl/TransactionFeed.hpp @@ -71,12 +71,12 @@ class TransactionFeed { std::reference_wrapper subAccountCount_; std::reference_wrapper subBookCount_; - TrackableSignalMap accountSignal_; - TrackableSignalMap bookSignal_; + TrackableSignalMap accountSignal_; + TrackableSignalMap bookSignal_; TrackableSignal signal_; // Signals for proposed tx subscribers - TrackableSignalMap accountProposedSignal_; + TrackableSignalMap accountProposedSignal_; TrackableSignal txProposedSignal_; std::unordered_set @@ -113,7 +113,7 @@ public: * @param account The account to watch. */ void - sub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber); + sub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber); /** * @brief Subscribe to the transaction feed, only receive the feed when particular order book is affected. @@ -121,7 +121,7 @@ public: * @param book The order book to watch. */ void - sub(ripple::Book const& book, SubscriberSharedPtr const& subscriber); + sub(xrpl::Book const& book, SubscriberSharedPtr const& subscriber); /** * @brief Subscribe to the transaction feed for proposed transaction stream. @@ -137,7 +137,7 @@ public: * @param account The account to watch. */ void - subProposed(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber); + subProposed(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber); /** * @brief Unsubscribe to the transaction feed. @@ -152,7 +152,7 @@ public: * @param account The account to unsubscribe. */ void - unsub(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber); + unsub(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber); /** * @brief Unsubscribe to the transaction feed for proposed transaction stream. @@ -167,7 +167,7 @@ public: * @param account The account to unsubscribe. */ void - unsubProposed(ripple::AccountID const& account, SubscriberSharedPtr const& subscriber); + unsubProposed(xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber); /** * @brief Unsubscribe to the transaction feed for particular order book. @@ -175,7 +175,7 @@ public: * @param book The book to unsubscribe. */ void - unsub(ripple::Book const& book, SubscriberSharedPtr const& subscriber); + unsub(xrpl::Book const& book, SubscriberSharedPtr const& subscriber); /** * @brief Publishes the transaction feed. @@ -186,7 +186,7 @@ public: */ void pub(data::TransactionAndMetadata const& txMeta, - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::shared_ptr const& backend, std::shared_ptr const& amendmentCenter, uint32_t networkID); @@ -214,15 +214,15 @@ private: unsubInternal(SubscriberPtr subscriber); void - unsubInternal(ripple::AccountID const& account, SubscriberPtr subscriber); + unsubInternal(xrpl::AccountID const& account, SubscriberPtr subscriber); void unsubProposedInternal(SubscriberPtr subscriber); void - unsubProposedInternal(ripple::AccountID const& account, SubscriberPtr subscriber); + unsubProposedInternal(xrpl::AccountID const& account, SubscriberPtr subscriber); void - unsubInternal(ripple::Book const& book, SubscriberPtr subscriber); + unsubInternal(xrpl::Book const& book, SubscriberPtr subscriber); }; } // namespace feed::impl diff --git a/src/migration/cassandra/impl/ObjectsAdapter.cpp b/src/migration/cassandra/impl/ObjectsAdapter.cpp index d7d60abbb..4dceb8285 100644 --- a/src/migration/cassandra/impl/ObjectsAdapter.cpp +++ b/src/migration/cassandra/impl/ObjectsAdapter.cpp @@ -36,7 +36,7 @@ ObjectsAdapter::onRowRead(TableObjectsDesc::Row const& row) onStateRead_(ledgerSeq, std::nullopt); return; } - ripple::SLE sle{ripple::SerialIter{blob.data(), blob.size()}, key}; + xrpl::SLE sle{xrpl::SerialIter{blob.data(), blob.size()}, key}; onStateRead_(ledgerSeq, std::make_optional(std::move(sle))); } diff --git a/src/migration/cassandra/impl/ObjectsAdapter.hpp b/src/migration/cassandra/impl/ObjectsAdapter.hpp index 6d4362588..42feb5ad7 100644 --- a/src/migration/cassandra/impl/ObjectsAdapter.hpp +++ b/src/migration/cassandra/impl/ObjectsAdapter.hpp @@ -41,7 +41,7 @@ namespace migration::cassandra::impl { * @brief The description of the objects table. It has to be a TableSpec. */ struct TableObjectsDesc { - using Row = std::tuple; + using Row = std::tuple; static constexpr char const* kPARTITION_KEY = "key"; static constexpr char const* kTABLE_NAME = "objects"; }; @@ -52,7 +52,7 @@ struct TableObjectsDesc { */ class ObjectsAdapter : public impl::FullTableScannerAdapterBase { public: - using OnStateRead = std::function)>; + using OnStateRead = std::function)>; /** * @brief Construct a new Objects Adapter object diff --git a/src/migration/cassandra/impl/TransactionsAdapter.cpp b/src/migration/cassandra/impl/TransactionsAdapter.cpp index 9aa9915b7..4fe6e2c9b 100644 --- a/src/migration/cassandra/impl/TransactionsAdapter.cpp +++ b/src/migration/cassandra/impl/TransactionsAdapter.cpp @@ -30,9 +30,9 @@ TransactionsAdapter::onRowRead(TableTransactionsDesc::Row const& row) { auto const& [txHash, date, ledgerSeq, metaBlob, txBlob] = row; - ripple::SerialIter it{txBlob.data(), txBlob.size()}; - ripple::STTx const sttx{it}; - ripple::TxMeta const txMeta{sttx.getTransactionID(), ledgerSeq, metaBlob}; + xrpl::SerialIter it{txBlob.data(), txBlob.size()}; + xrpl::STTx const sttx{it}; + xrpl::TxMeta const txMeta{sttx.getTransactionID(), ledgerSeq, metaBlob}; onTransactionRead_(sttx, txMeta); } } // namespace migration::cassandra::impl diff --git a/src/migration/cassandra/impl/TransactionsAdapter.hpp b/src/migration/cassandra/impl/TransactionsAdapter.hpp index ed1b92b2d..0c05c62b0 100644 --- a/src/migration/cassandra/impl/TransactionsAdapter.hpp +++ b/src/migration/cassandra/impl/TransactionsAdapter.hpp @@ -41,7 +41,7 @@ namespace migration::cassandra::impl { */ struct TableTransactionsDesc { // hash, date, ledger_seq, metadata, transaction - using Row = std::tuple; + using Row = std::tuple; static constexpr char const* kPARTITION_KEY = "hash"; static constexpr char const* kTABLE_NAME = "transactions"; }; @@ -52,7 +52,7 @@ struct TableTransactionsDesc { */ class TransactionsAdapter : public impl::FullTableScannerAdapterBase { public: - using OnTransactionRead = std::function; + using OnTransactionRead = std::function; /** * @brief Construct a new Transactions Adapter object diff --git a/src/rpc/AMMHelpers.cpp b/src/rpc/AMMHelpers.cpp index 5cb5cf71e..80e09899b 100644 --- a/src/rpc/AMMHelpers.cpp +++ b/src/rpc/AMMHelpers.cpp @@ -36,14 +36,14 @@ namespace rpc { -std::pair +std::pair getAmmPoolHolds( BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t sequence, - ripple::AccountID const& ammAccountID, - ripple::Issue const& issue1, - ripple::Issue const& issue2, + xrpl::AccountID const& ammAccountID, + xrpl::Issue const& issue1, + xrpl::Issue const& issue2, bool freezeHandling, boost::asio::yield_context yield ) @@ -57,38 +57,38 @@ getAmmPoolHolds( return std::make_pair(assetInBalance, assetOutBalance); } -ripple::STAmount +xrpl::STAmount getAmmLpHolds( BackendInterface const& backend, std::uint32_t sequence, - ripple::Currency const& cur1, - ripple::Currency const& cur2, - ripple::AccountID const& ammAccount, - ripple::AccountID const& lpAccount, + xrpl::Issue const& iss1, + xrpl::Issue const& iss2, + xrpl::AccountID const& ammAccount, + xrpl::AccountID const& lpAccount, boost::asio::yield_context yield ) { - auto const lptCurrency = ammLPTCurrency(cur1, cur2); + auto const lptCurrency = ammLPTCurrency(iss1, iss2); // not using accountHolds because we don't need to check if the associated tokens of the LP are frozen return ammAccountHolds(backend, sequence, lpAccount, lptCurrency, ammAccount, true, yield); } -ripple::STAmount +xrpl::STAmount getAmmLpHolds( BackendInterface const& backend, std::uint32_t sequence, - ripple::SLE const& ammSle, - ripple::AccountID const& lpAccount, + xrpl::SLE const& ammSle, + xrpl::AccountID const& lpAccount, boost::asio::yield_context yield ) { return getAmmLpHolds( backend, sequence, - ammSle[ripple::sfAsset].get().currency, - ammSle[ripple::sfAsset2].get().currency, - ammSle[ripple::sfAccount], + ammSle[xrpl::sfAsset].get(), + ammSle[xrpl::sfAsset2].get(), + ammSle[xrpl::sfAccount], lpAccount, yield ); diff --git a/src/rpc/AMMHelpers.hpp b/src/rpc/AMMHelpers.hpp index 286d37645..40a4dbb84 100644 --- a/src/rpc/AMMHelpers.hpp +++ b/src/rpc/AMMHelpers.hpp @@ -47,14 +47,14 @@ namespace rpc { * @param yield The coroutine context * @return The balances of the amm asset pair */ -std::pair +std::pair getAmmPoolHolds( BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t sequence, - ripple::AccountID const& ammAccountID, - ripple::Issue const& issue1, - ripple::Issue const& issue2, + xrpl::AccountID const& ammAccountID, + xrpl::Issue const& issue1, + xrpl::Issue const& issue2, bool freezeHandling, boost::asio::yield_context yield ); @@ -64,21 +64,21 @@ getAmmPoolHolds( * * @param backend The backend to use * @param sequence The sequence number to use - * @param cur1 The first currency - * @param cur2 The second currency + * @param iss1 The first issue + * @param iss2 The second issue * @param ammAccount The amm account * @param lpAccount The lp account * @param yield The coroutine context * @return The lp token balance */ -ripple::STAmount +xrpl::STAmount getAmmLpHolds( BackendInterface const& backend, std::uint32_t sequence, - ripple::Currency const& cur1, - ripple::Currency const& cur2, - ripple::AccountID const& ammAccount, - ripple::AccountID const& lpAccount, + xrpl::Issue const& iss1, + xrpl::Issue const& iss2, + xrpl::AccountID const& ammAccount, + xrpl::AccountID const& lpAccount, boost::asio::yield_context yield ); @@ -92,12 +92,12 @@ getAmmLpHolds( * @param yield The coroutine context * @return The lp token balance */ -ripple::STAmount +xrpl::STAmount getAmmLpHolds( BackendInterface const& backend, std::uint32_t sequence, - ripple::SLE const& ammSle, - ripple::AccountID const& lpAccount, + xrpl::SLE const& ammSle, + xrpl::AccountID const& lpAccount, boost::asio::yield_context yield ); diff --git a/src/rpc/BookChangesHelper.hpp b/src/rpc/BookChangesHelper.hpp index ec4198567..abfecec95 100644 --- a/src/rpc/BookChangesHelper.hpp +++ b/src/rpc/BookChangesHelper.hpp @@ -56,13 +56,13 @@ namespace rpc { * @brief Represents an entry in the book_changes' changes array. */ struct BookChange { - ripple::STAmount sideAVolume; - ripple::STAmount sideBVolume; - ripple::STAmount highRate; - ripple::STAmount lowRate; - ripple::STAmount openRate; - ripple::STAmount closeRate; - std::optional domain; + xrpl::STAmount sideAVolume; + xrpl::STAmount sideBVolume; + xrpl::STAmount highRate; + xrpl::STAmount lowRate; + xrpl::STAmount openRate; + xrpl::STAmount closeRate; + std::optional domain; }; /** @@ -109,55 +109,54 @@ private: private: void - handleAffectedNode(ripple::STObject const& node) + handleAffectedNode(xrpl::STObject const& node) { auto const& metaType = node.getFName(); - auto const nodeType = node.getFieldU16(ripple::sfLedgerEntryType); + auto const nodeType = node.getFieldU16(xrpl::sfLedgerEntryType); - // we only care about ripple::ltOFFER objects being modified or + // we only care about xrpl::ltOFFER objects being modified or // deleted - if (nodeType != ripple::ltOFFER || metaType == ripple::sfCreatedNode) + if (nodeType != xrpl::ltOFFER || metaType == xrpl::sfCreatedNode) return; // if either FF or PF are missing we can't compute // but generally these are cancelled rather than crossed // so skipping them is consistent - if (!node.isFieldPresent(ripple::sfFinalFields) || !node.isFieldPresent(ripple::sfPreviousFields)) + if (!node.isFieldPresent(xrpl::sfFinalFields) || !node.isFieldPresent(xrpl::sfPreviousFields)) return; - auto const& finalFields = node.peekAtField(ripple::sfFinalFields).downcast(); - auto const& previousFields = node.peekAtField(ripple::sfPreviousFields).downcast(); + auto const& finalFields = node.peekAtField(xrpl::sfFinalFields).downcast(); + auto const& previousFields = node.peekAtField(xrpl::sfPreviousFields).downcast(); // defensive case that should never be hit - if (!finalFields.isFieldPresent(ripple::sfTakerGets) || !finalFields.isFieldPresent(ripple::sfTakerPays) || - !previousFields.isFieldPresent(ripple::sfTakerGets) || - !previousFields.isFieldPresent(ripple::sfTakerPays)) + if (!finalFields.isFieldPresent(xrpl::sfTakerGets) || !finalFields.isFieldPresent(xrpl::sfTakerPays) || + !previousFields.isFieldPresent(xrpl::sfTakerGets) || !previousFields.isFieldPresent(xrpl::sfTakerPays)) return; // filter out any offers deleted by explicit offer cancels - if (metaType == ripple::sfDeletedNode && offerCancel_ && - finalFields.getFieldU32(ripple::sfSequence) == *offerCancel_) + if (metaType == xrpl::sfDeletedNode && offerCancel_ && + finalFields.getFieldU32(xrpl::sfSequence) == *offerCancel_) return; // compute the difference in gets and pays actually // affected onto the offer auto const deltaGets = - finalFields.getFieldAmount(ripple::sfTakerGets) - previousFields.getFieldAmount(ripple::sfTakerGets); + finalFields.getFieldAmount(xrpl::sfTakerGets) - previousFields.getFieldAmount(xrpl::sfTakerGets); auto const deltaPays = - finalFields.getFieldAmount(ripple::sfTakerPays) - previousFields.getFieldAmount(ripple::sfTakerPays); + finalFields.getFieldAmount(xrpl::sfTakerPays) - previousFields.getFieldAmount(xrpl::sfTakerPays); - transformAndStore(deltaGets, deltaPays, finalFields[~ripple::sfDomainID]); + transformAndStore(deltaGets, deltaPays, finalFields[~xrpl::sfDomainID]); } void transformAndStore( - ripple::STAmount const& deltaGets, - ripple::STAmount const& deltaPays, - std::optional const& domain + xrpl::STAmount const& deltaGets, + xrpl::STAmount const& deltaPays, + std::optional const& domain ) { - auto const g = to_string(deltaGets.issue()); - auto const p = to_string(deltaPays.issue()); + auto const g = to_string(deltaGets.get()); + auto const p = to_string(deltaPays.get()); auto const noswap = [&]() { if (isXRP(deltaGets)) @@ -169,15 +168,15 @@ private: auto second = noswap ? deltaPays : deltaGets; // defensively programmed, should (probably) never happen - if (second == beast::zero) + if (second == beast::kZero) return; - auto const rate = divide(first, second, ripple::noIssue()); + auto const rate = divide(first, second, xrpl::noIssue()); - if (first < beast::zero) + if (first < beast::kZero) first = -first; - if (second < beast::zero) + if (second < beast::kZero) second = -second; auto const key = noswap ? (g + '|' + p) : (p + '|' + g); @@ -212,24 +211,24 @@ private: handleBookChange(data::TransactionAndMetadata const& blob) { auto const [tx, meta] = rpc::deserializeTxPlusMeta(blob); - if (!tx || !meta || !tx->isFieldPresent(ripple::sfTransactionType)) + if (!tx || !meta || !tx->isFieldPresent(xrpl::sfTransactionType)) return; offerCancel_ = shouldCancelOffer(tx); - for (auto const& node : meta->getFieldArray(ripple::sfAffectedNodes)) + for (auto const& node : meta->getFieldArray(xrpl::sfAffectedNodes)) handleAffectedNode(node); } static std::optional - shouldCancelOffer(std::shared_ptr const& tx) + shouldCancelOffer(std::shared_ptr const& tx) { - switch (tx->getFieldU16(ripple::sfTransactionType)) { + switch (tx->getFieldU16(xrpl::sfTransactionType)) { // in future if any other ways emerge to cancel an offer // this switch makes them easy to add - case ripple::ttOFFER_CANCEL: - case ripple::ttOFFER_CREATE: - if (tx->isFieldPresent(ripple::sfOfferSequence)) - return tx->getFieldU32(ripple::sfOfferSequence); + case xrpl::ttOFFER_CANCEL: + case xrpl::ttOFFER_CREATE: + if (tx->isFieldPresent(xrpl::sfOfferSequence)) + return tx->getFieldU32(xrpl::sfOfferSequence); [[fallthrough]]; default: return std::nullopt; @@ -247,12 +246,12 @@ private: inline void tag_invoke(boost::json::value_from_tag, boost::json::value& jv, BookChange const& change) { - auto amountStr = [](ripple::STAmount const& amount) -> std::string { + auto amountStr = [](xrpl::STAmount const& amount) -> std::string { return isXRP(amount) ? to_string(amount.xrp()) : to_string(amount.iou()); }; - auto currencyStr = [](ripple::STAmount const& amount) -> std::string { - return isXRP(amount) ? "XRP_drops" : to_string(amount.issue()); + auto currencyStr = [](xrpl::STAmount const& amount) -> std::string { + return isXRP(amount) ? "XRP_drops" : to_string(amount.get()); }; jv = { @@ -267,7 +266,7 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, BookChange const }; if (change.domain.has_value()) - jv.as_object()[JS(domain)] = ripple::to_string(*change.domain); + jv.as_object()[JS(domain)] = xrpl::to_string(*change.domain); } /** @@ -278,6 +277,6 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, BookChange const * @return The book changes */ [[nodiscard]] boost::json::object -computeBookChanges(ripple::LedgerHeader const& lgrInfo, std::vector const& transactions); +computeBookChanges(xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions); } // namespace rpc diff --git a/src/rpc/CredentialHelpers.cpp b/src/rpc/CredentialHelpers.cpp index bbea85ca7..207be78b1 100644 --- a/src/rpc/CredentialHelpers.cpp +++ b/src/rpc/CredentialHelpers.cpp @@ -53,37 +53,36 @@ namespace rpc::credentials { bool -checkExpired(ripple::SLE const& sleCred, ripple::LedgerHeader const& ledger) +checkExpired(xrpl::SLE const& sleCred, xrpl::LedgerHeader const& ledger) { - if (sleCred.isFieldPresent(ripple::sfExpiration)) { - std::uint32_t const exp = sleCred.getFieldU32(ripple::sfExpiration); + if (sleCred.isFieldPresent(xrpl::sfExpiration)) { + std::uint32_t const exp = sleCred.getFieldU32(xrpl::sfExpiration); std::uint32_t const now = ledger.parentCloseTime.time_since_epoch().count(); return now > exp; } return false; } -std::set> -createAuthCredentials(ripple::STArray const& in) +std::set> +createAuthCredentials(xrpl::STArray const& in) { - std::set> out; + std::set> out; for (auto const& cred : in) - out.insert({cred[ripple::sfIssuer], cred[ripple::sfCredentialType]}); + out.insert({cred[xrpl::sfIssuer], cred[xrpl::sfCredentialType]}); return out; } -ripple::STArray +xrpl::STArray parseAuthorizeCredentials(boost::json::array const& jv) { - ripple::STArray arr; + xrpl::STArray arr; for (auto const& jo : jv) { ASSERT( jo.at(JS(issuer)).is_string(), "issuer must be string, should already be checked in AuthorizeCredentialValidator" ); - auto const issuer = - ripple::parseBase58(static_cast(jo.at(JS(issuer)).as_string())); + auto const issuer = xrpl::parseBase58(static_cast(jo.at(JS(issuer)).as_string())); ASSERT( issuer.has_value(), "issuer must be present, should already be checked in AuthorizeCredentialValidator." ); @@ -92,66 +91,66 @@ parseAuthorizeCredentials(boost::json::array const& jv) jo.at(JS(credential_type)).is_string(), "credential_type must be string, should already be checked in AuthorizeCredentialValidator" ); - auto const credentialType = ripple::strUnHex(static_cast(jo.at(JS(credential_type)).as_string())); + auto const credentialType = xrpl::strUnHex(static_cast(jo.at(JS(credential_type)).as_string())); ASSERT( credentialType.has_value(), "credential_type must be present, should already be checked in AuthorizeCredentialValidator." ); - auto credential = ripple::STObject::makeInnerObject(ripple::sfCredential); - credential.setAccountID(ripple::sfIssuer, *issuer); - credential.setFieldVL(ripple::sfCredentialType, *credentialType); + auto credential = xrpl::STObject::makeInnerObject(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, *issuer); + credential.setFieldVL(xrpl::sfCredentialType, *credentialType); arr.push_back(std::move(credential)); } return arr; } -std::expected +std::expected fetchCredentialArray( std::optional const& credID, - ripple::AccountID const& srcAcc, + xrpl::AccountID const& srcAcc, BackendInterface const& backend, - ripple::LedgerHeader const& info, + xrpl::LedgerHeader const& info, boost::asio::yield_context const& yield ) { - ripple::STArray authCreds; + xrpl::STArray authCreds; std::unordered_set elems; for (auto const& elem : credID.value()) { ASSERT(elem.is_string(), "should already be checked in validators.hpp that elem is a string."); if (elems.contains(elem.as_string())) - return Error{Status{RippledError::rpcBAD_CREDENTIALS, "duplicates in credentials."}}; + return Error{Status{RippledError::RpcBadCredentials, "duplicates in credentials."}}; elems.insert(elem.as_string()); - ripple::uint256 credHash; + xrpl::uint256 credHash; ASSERT( credHash.parseHex(boost::json::value_to(elem)), "should already be checked in validators.hpp that elem is a uint256 hex" ); - auto const credKeylet = ripple::keylet::credential(credHash).key; + auto const credKeylet = xrpl::keylet::credential(credHash).key; auto const credLedgerObject = backend.fetchLedgerObject(credKeylet, info.seq, yield); if (!credLedgerObject) - return Error{Status{RippledError::rpcBAD_CREDENTIALS, "credentials don't exist."}}; + return Error{Status{RippledError::RpcBadCredentials, "credentials don't exist."}}; - auto credIt = ripple::SerialIter{credLedgerObject->data(), credLedgerObject->size()}; - auto const sleCred = ripple::SLE{credIt, credKeylet}; + auto credIt = xrpl::SerialIter{credLedgerObject->data(), credLedgerObject->size()}; + auto const sleCred = xrpl::SLE{credIt, credKeylet}; - if ((sleCred.getType() != ripple::ltCREDENTIAL) || - ((sleCred.getFieldU32(ripple::sfFlags) & ripple::lsfAccepted) == 0u)) - return Error{Status{RippledError::rpcBAD_CREDENTIALS, "credentials aren't accepted"}}; + if ((sleCred.getType() != xrpl::ltCREDENTIAL) || + ((sleCred.getFieldU32(xrpl::sfFlags) & xrpl::lsfAccepted) == 0u)) + return Error{Status{RippledError::RpcBadCredentials, "credentials aren't accepted"}}; if (credentials::checkExpired(sleCred, info)) - return Error{Status{RippledError::rpcBAD_CREDENTIALS, "credentials are expired"}}; + return Error{Status{RippledError::RpcBadCredentials, "credentials are expired"}}; - if (sleCred.getAccountID(ripple::sfSubject) != srcAcc) - return Error{Status{RippledError::rpcBAD_CREDENTIALS, "credentials don't belong to the root account"}}; + if (sleCred.getAccountID(xrpl::sfSubject) != srcAcc) + return Error{Status{RippledError::RpcBadCredentials, "credentials don't belong to the root account"}}; - auto credential = ripple::STObject::makeInnerObject(ripple::sfCredential); - credential.setAccountID(ripple::sfIssuer, sleCred.getAccountID(ripple::sfIssuer)); - credential.setFieldVL(ripple::sfCredentialType, sleCred.getFieldVL(ripple::sfCredentialType)); + auto credential = xrpl::STObject::makeInnerObject(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, sleCred.getAccountID(xrpl::sfIssuer)); + credential.setFieldVL(xrpl::sfCredentialType, sleCred.getFieldVL(xrpl::sfCredentialType)); authCreds.push_back(std::move(credential)); } diff --git a/src/rpc/CredentialHelpers.hpp b/src/rpc/CredentialHelpers.hpp index d4b84bb37..66fdcca21 100644 --- a/src/rpc/CredentialHelpers.hpp +++ b/src/rpc/CredentialHelpers.hpp @@ -47,7 +47,7 @@ namespace rpc::credentials { * @return true if credential not expired, false otherwise */ bool -checkExpired(ripple::SLE const& sleCred, ripple::LedgerHeader const& ledger); +checkExpired(xrpl::SLE const& sleCred, xrpl::LedgerHeader const& ledger); /** * @brief Creates authentication credential field (which is a set of pairs of AccountID and Credential ID) @@ -55,8 +55,8 @@ checkExpired(ripple::SLE const& sleCred, ripple::LedgerHeader const& ledger); * @param in The array of Credential objects to check * @return Auth Credential array */ -std::set> -createAuthCredentials(ripple::STArray const& in); +std::set> +createAuthCredentials(xrpl::STArray const& in); /** * @brief Parses each credential object and makes sure the credential type and values are correct @@ -64,7 +64,7 @@ createAuthCredentials(ripple::STArray const& in); * @param jv The boost json array of credentials to parse * @return Array of credentials after parsing */ -ripple::STArray +xrpl::STArray parseAuthorizeCredentials(boost::json::array const& jv); /** @@ -77,12 +77,12 @@ parseAuthorizeCredentials(boost::json::array const& jv); * @param yield The coroutine context * @return Array of credential objects, error if failed otherwise */ -std::expected +std::expected fetchCredentialArray( std::optional const& credID, - ripple::AccountID const& srcAcc, + xrpl::AccountID const& srcAcc, BackendInterface const& backend, - ripple::LedgerHeader const& info, + xrpl::LedgerHeader const& info, boost::asio::yield_context const& yield ); diff --git a/src/rpc/Errors.cpp b/src/rpc/Errors.cpp index aa0be8fdb..c4236caee 100644 --- a/src/rpc/Errors.cpp +++ b/src/rpc/Errors.cpp @@ -53,7 +53,7 @@ operator<<(std::ostream& stream, Status const& status) if (!status.message.empty()) { stream << ", Message: " << status.message; } else { - stream << ", Message: " << ripple::RPC::get_error_info(err).message; + stream << ", Message: " << xrpl::RPC::getErrorInfo(err).message; } }, [&stream, &status](ClioError err) { @@ -157,11 +157,11 @@ boost::json::object makeError(RippledError err, std::optional customError, std::optional customMessage) { boost::json::object json; - auto const& info = ripple::RPC::get_error_info(err); + auto const& info = xrpl::RPC::getErrorInfo(err); - json["error"] = customError.value_or(info.token.c_str()).data(); + json["error"] = customError.value_or(info.token.cStr()).data(); json["error_code"] = static_cast(err); - json["error_message"] = customMessage.value_or(info.message.c_str()).data(); + json["error_message"] = customMessage.value_or(info.message.cStr()).data(); json["status"] = "error"; json["type"] = "response"; @@ -191,7 +191,7 @@ makeError(Status const& status) auto res = visit( util::OverloadSet{ [&status, &wrapOptional](RippledError err) { - if (err == ripple::rpcUNKNOWN) + if (err == xrpl::RpcUnknown) return boost::json::object{{"error", status.message}, {"type", "response"}, {"status", "error"}}; return makeError(err, wrapOptional(status.error), wrapOptional(status.message)); diff --git a/src/rpc/Errors.hpp b/src/rpc/Errors.hpp index 0aaa78308..658f4e401 100644 --- a/src/rpc/Errors.hpp +++ b/src/rpc/Errors.hpp @@ -69,7 +69,7 @@ struct ClioErrorInfo { }; /** @brief Clio uses compatible Rippled error codes for most RPC errors. */ -using RippledError = ripple::error_code_i; +using RippledError = xrpl::ErrorCodeI; /** * @brief Clio operates on a combination of Rippled and Custom Clio error codes. @@ -81,7 +81,7 @@ using CombinedError = std::variant; /** @brief A status returned from any RPC handler. */ struct Status { - CombinedError code = RippledError::rpcSUCCESS; + CombinedError code = RippledError::RpcSuccess; std::string error; std::string message; std::optional extraInfo; @@ -111,7 +111,7 @@ struct Status { * * @param message The message */ - explicit Status(std::string message) : code(ripple::rpcUNKNOWN), message(std::move(message)) + explicit Status(std::string message) : code(xrpl::RpcUnknown), message(std::move(message)) { } @@ -148,7 +148,7 @@ struct Status { operator bool() const { if (auto err = std::get_if(&code)) - return *err != RippledError::rpcSUCCESS; + return *err != RippledError::RpcSuccess; return true; } diff --git a/src/rpc/Factories.cpp b/src/rpc/Factories.cpp index a4b2bf2cb..7453a765b 100644 --- a/src/rpc/Factories.cpp +++ b/src/rpc/Factories.cpp @@ -96,7 +96,7 @@ makeHttpContext( auto const command = boost::json::value_to(request.at("method")); if (command == "subscribe" || command == "unsubscribe") - return Error{{RippledError::rpcBAD_SYNTAX, "Subscribe and unsubscribe are only allowed for websocket."}}; + return Error{{RippledError::RpcBadSyntax, "Subscribe and unsubscribe are only allowed for websocket."}}; if (!request.at("params").is_array()) return Error{{ClioError::RpcParamsUnparsable, "Missing params array."}}; diff --git a/src/rpc/JS.hpp b/src/rpc/JS.hpp index decd477ce..26d32e1ab 100644 --- a/src/rpc/JS.hpp +++ b/src/rpc/JS.hpp @@ -21,11 +21,11 @@ #include -/** @brief Helper macro for borrowing from ripple::jss static (J)son (S)trings. */ -#define JS(x) ripple::jss::x.c_str() +/** @brief Helper macro for borrowing from xrpl::jss static (J)son (S)trings. */ +#define JS(x) xrpl::jss::x.cStr() /** @brief Access the lower case copy of a static (J)son (S)tring. */ #define JSL(x) util::toLower(JS(x)) /** @brief Provides access to (SF)ield name (S)trings. */ -#define SFS(x) ripple::x.jsonName.c_str() +#define SFS(x) xrpl::x.jsonName.cStr() diff --git a/src/rpc/RPCEngine.hpp b/src/rpc/RPCEngine.hpp index 2af5d3e19..25a8e584e 100644 --- a/src/rpc/RPCEngine.hpp +++ b/src/rpc/RPCEngine.hpp @@ -152,7 +152,7 @@ public: if (forwardingProxy_.shouldForward(ctx)) { // Disallow forwarding of the admin api, only user api is allowed for security reasons. if (isAdminCmd(ctx.method, ctx.params)) - return Result{Status{RippledError::rpcNO_PERMISSION}}; + return Result{Status{RippledError::RpcNoPermission}}; return forwardingProxy_.forward(ctx); } @@ -165,13 +165,13 @@ public: if (backend_->isTooBusy()) { LOG(log_.error()) << "Database is too busy. Rejecting request"; notifyTooBusy(); // TODO: should we add ctx.method if we have it? - return Result{Status{RippledError::rpcTOO_BUSY}}; + return Result{Status{RippledError::RpcTooBusy}}; } auto const method = handlerProvider_->getHandler(ctx.method); if (!method) { notifyUnknownCommand(); - return Result{Status{RippledError::rpcUNKNOWN_COMMAND}}; + return Result{Status{RippledError::RpcUnknownCommand}}; } try { @@ -199,12 +199,12 @@ public: LOG(log_.error()) << "Database timeout"; notifyTooBusy(); - return Result{Status{RippledError::rpcTOO_BUSY}}; + return Result{Status{RippledError::RpcTooBusy}}; } catch (std::exception const& ex) { LOG(log_.error()) << ctx.tag() << "Caught exception: " << ex.what(); notifyInternalError(); - return Result{Status{RippledError::rpcINTERNAL}}; + return Result{Status{RippledError::RpcInternal}}; } } @@ -325,13 +325,13 @@ private: if (backend_->isTooBusy()) { LOG(log_.error()) << "Database is too busy. Rejecting request"; notifyTooBusy(); // TODO: should we add ctx.method if we have it? - return Result{Status{RippledError::rpcTOO_BUSY}}; + return Result{Status{RippledError::RpcTooBusy}}; } auto const method = handlerProvider_->getHandler(ctx.method); if (!method) { notifyUnknownCommand(); - return Result{Status{RippledError::rpcUNKNOWN_COMMAND}}; + return Result{Status{RippledError::RpcUnknownCommand}}; } try { @@ -357,12 +357,12 @@ private: LOG(log_.error()) << "Database timeout"; notifyTooBusy(); - return Result{Status{RippledError::rpcTOO_BUSY}}; + return Result{Status{RippledError::RpcTooBusy}}; } catch (std::exception const& ex) { LOG(log_.error()) << ctx.tag() << "Caught exception: " << ex.what(); notifyInternalError(); - return Result{Status{RippledError::rpcINTERNAL}}; + return Result{Status{RippledError::RpcInternal}}; } } }; diff --git a/src/rpc/RPCHelpers.cpp b/src/rpc/RPCHelpers.cpp index 72a6555ff..de5545577 100644 --- a/src/rpc/RPCHelpers.cpp +++ b/src/rpc/RPCHelpers.cpp @@ -107,7 +107,7 @@ namespace rpc { std::optional parseAccountCursor(std::optional jsonCursor) { - ripple::uint256 cursorIndex = beast::zero; + xrpl::uint256 cursorIndex = beast::kZero; std::uint64_t startHint = 0; if (!jsonCursor) @@ -135,17 +135,17 @@ parseAccountCursor(std::optional jsonCursor) return AccountCursor({.index = cursorIndex, .hint = startHint}); } -std::optional +std::optional getDeliveredAmount( - std::shared_ptr const& txn, - std::shared_ptr const& meta, + std::shared_ptr const& txn, + std::shared_ptr const& meta, std::uint32_t const ledgerSequence, uint32_t date ) { - if (meta->hasDeliveredAmount()) - return meta->getDeliveredAmount(); - if (txn->isFieldPresent(ripple::sfAmount)) { + if (auto const delivered = meta->getDeliveredAmount(); delivered.has_value()) + return delivered; + if (txn->isFieldPresent(xrpl::sfAmount)) { // Ledger 4594095 is the first ledger in which the DeliveredAmount field // was present when a partial payment was made and its absence indicates // that the amount delivered is listed in the Amount field. @@ -157,61 +157,58 @@ getDeliveredAmount( static constexpr std::uint32_t kFIRST_LEDGER_WITH_DELIVERED_AMOUNT = 4594095; static constexpr std::uint32_t kDELIVERED_AMOUNT_LIVE_DATE = 446000000; if (ledgerSequence >= kFIRST_LEDGER_WITH_DELIVERED_AMOUNT || date > kDELIVERED_AMOUNT_LIVE_DATE) { - return txn->getFieldAmount(ripple::sfAmount); + return txn->getFieldAmount(xrpl::sfAmount); } } return {}; } bool -canHaveDeliveredAmount( - std::shared_ptr const& txn, - std::shared_ptr const& meta -) +canHaveDeliveredAmount(std::shared_ptr const& txn, std::shared_ptr const& meta) { - ripple::TxType const tt{txn->getTxnType()}; - if (tt != ripple::ttPAYMENT && tt != ripple::ttCHECK_CASH && tt != ripple::ttACCOUNT_DELETE) + xrpl::TxType const tt{txn->getTxnType()}; + if (tt != xrpl::ttPAYMENT && tt != xrpl::ttCHECK_CASH && tt != xrpl::ttACCOUNT_DELETE) return false; - return meta->getResultTER() == ripple::tesSUCCESS; + return meta->getResultTER() == xrpl::tesSUCCESS; } -std::optional +std::optional accountFromStringStrict(std::string const& account) { - auto blob = ripple::strUnHex(account); + auto blob = xrpl::strUnHex(account); - std::optional publicKey = {}; - if (blob && ripple::publicKeyType(ripple::makeSlice(*blob))) { - publicKey = ripple::PublicKey(ripple::Slice{blob->data(), blob->size()}); + std::optional publicKey = {}; + if (blob && xrpl::publicKeyType(xrpl::makeSlice(*blob))) { + publicKey = xrpl::PublicKey(xrpl::Slice{blob->data(), blob->size()}); } else { - publicKey = util::parseBase58Wrapper(ripple::TokenType::AccountPublic, account); + publicKey = util::parseBase58Wrapper(xrpl::TokenType::AccountPublic, account); } - std::optional result; + std::optional result; if (publicKey) { - result = ripple::calcAccountID(*publicKey); + result = xrpl::calcAccountID(*publicKey); } else { - result = util::parseBase58Wrapper(account); + result = util::parseBase58Wrapper(account); } return result; } -std::pair, std::shared_ptr> +std::pair, std::shared_ptr> deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs) { static util::Logger const log{"RPC"}; // NOLINT(readability-identifier-naming) try { - std::pair, std::shared_ptr> result; + std::pair, std::shared_ptr> result; { - ripple::SerialIter s{blobs.transaction.data(), blobs.transaction.size()}; - result.first = std::make_shared(s); + xrpl::SerialIter s{blobs.transaction.data(), blobs.transaction.size()}; + result.first = std::make_shared(s); } { - ripple::SerialIter s{blobs.metadata.data(), blobs.metadata.size()}; - result.second = std::make_shared(s, ripple::sfMetadata); + xrpl::SerialIter s{blobs.metadata.data(), blobs.metadata.size()}; + result.second = std::make_shared(s, xrpl::sfMetadata); } return result; } catch (std::exception const& e) { @@ -226,20 +223,20 @@ deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs) } } -std::pair, std::shared_ptr> +std::pair, std::shared_ptr> deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs, std::uint32_t seq) { auto [tx, meta] = deserializeTxPlusMeta(blobs); - std::shared_ptr const m = std::make_shared(tx->getTransactionID(), seq, *meta); + std::shared_ptr const m = std::make_shared(tx->getTransactionID(), seq, *meta); return {tx, m}; } boost::json::object -toJson(ripple::STBase const& obj) +toJson(xrpl::STBase const& obj) { - boost::json::value value = boost::json::parse(obj.getJson(ripple::JsonOptions::none).toStyledString()); + boost::json::value value = boost::json::parse(obj.getJson(xrpl::JsonOptions::Values::None).toStyledString()); return value.as_object(); } @@ -253,15 +250,15 @@ toExpandedJson( ) { auto [txn, meta] = deserializeTxPlusMeta(blobs, blobs.ledgerSequence); - auto txnJson = toJson(*txn); - auto metaJson = toJson(*meta); + auto txnJson = rpc::toJson(*txn); + auto metaJson = rpc::toJson(*meta); insertDeliveredAmount(metaJson, txn, meta, blobs.date); insertDeliverMaxAlias(txnJson, apiVersion); insertMPTIssuanceID(txnJson, txn, metaJson, meta); if (nftEnabled == NFTokenjson::ENABLE) { - Json::Value nftJson; - ripple::RPC::insertNFTSyntheticInJson(nftJson, txn, *meta); + json::Value nftJson; + xrpl::RPC::insertNFTSyntheticInJson(nftJson, txn, *meta); // if there is no nft fields, the nftJson will be {"meta":null} auto const nftBoostJson = toBoostJson(nftJson).as_object(); if (nftBoostJson.contains(JS(meta)) and nftBoostJson.at(JS(meta)).is_object()) { @@ -300,14 +297,14 @@ encodeCTID(uint32_t ledgerSeq, uint16_t txnIndex, uint16_t networkId) noexcept bool insertDeliveredAmount( boost::json::object& metaJson, - std::shared_ptr const& txn, - std::shared_ptr const& meta, + std::shared_ptr const& txn, + std::shared_ptr const& meta, uint32_t date ) { if (canHaveDeliveredAmount(txn, meta)) { if (auto amt = getDeliveredAmount(txn, meta, meta->getLgrSeq(), date)) { - metaJson["delivered_amount"] = toBoostJson(amt->getJson(ripple::JsonOptions::include_date)); + metaJson["delivered_amount"] = toBoostJson(amt->getJson(xrpl::JsonOptions::Values::IncludeDate)); } else { metaJson["delivered_amount"] = "unavailable"; } @@ -322,18 +319,18 @@ insertDeliveredAmount( * @param meta The metadata * @return The mpt_issuance_id or std::nullopt if not available */ -static std::optional -getMPTIssuanceID(std::shared_ptr const& meta) +static std::optional +getMPTIssuanceID(std::shared_ptr const& meta) { - ripple::TxMeta const& transactionMeta = *meta; + xrpl::TxMeta const& transactionMeta = *meta; - for (ripple::STObject const& node : transactionMeta.getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltMPTOKEN_ISSUANCE || - node.getFName() != ripple::sfCreatedNode) + for (xrpl::STObject const& node : transactionMeta.getNodes()) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltMPTOKEN_ISSUANCE || + node.getFName() != xrpl::sfCreatedNode) continue; - auto const& mptNode = node.peekAtField(ripple::sfNewFields).downcast(); - return ripple::makeMptID(mptNode[ripple::sfSequence], mptNode[ripple::sfIssuer]); + auto const& mptNode = node.peekAtField(xrpl::sfNewFields).downcast(); + return xrpl::makeMptID(mptNode[xrpl::sfSequence], mptNode[xrpl::sfIssuer]); } return {}; @@ -347,20 +344,20 @@ getMPTIssuanceID(std::shared_ptr const& meta) * @return true if the transaction can have a mpt_issuance_id */ static bool -canHaveMPTIssuanceID(std::shared_ptr const& txn, std::shared_ptr const& meta) +canHaveMPTIssuanceID(std::shared_ptr const& txn, std::shared_ptr const& meta) { - if (txn->getTxnType() != ripple::ttMPTOKEN_ISSUANCE_CREATE) + if (txn->getTxnType() != xrpl::ttMPTOKEN_ISSUANCE_CREATE) return false; - return (meta->getResultTER() == ripple::tesSUCCESS); + return (meta->getResultTER() == xrpl::tesSUCCESS); } bool insertMPTIssuanceID( boost::json::object& txnJson, - std::shared_ptr const& txn, + std::shared_ptr const& txn, boost::json::object& metaJson, - std::shared_ptr const& meta + std::shared_ptr const& meta ) { if (!canHaveMPTIssuanceID(txn, meta)) @@ -373,9 +370,9 @@ insertMPTIssuanceID( // Otherwise, add it to txn json if (txnJson.contains(JS(TransactionType)) && txnJson.at(JS(TransactionType)).is_string() and txnJson.at(JS(TransactionType)).as_string() == JS(MPTokenIssuanceCreate)) { - metaJson[JS(mpt_issuance_id)] = ripple::to_string(*id); + metaJson[JS(mpt_issuance_id)] = xrpl::to_string(*id); } else { - txnJson[JS(mpt_issuance_id)] = ripple::to_string(*id); + txnJson[JS(mpt_issuance_id)] = xrpl::to_string(*id); } return true; @@ -393,15 +390,15 @@ insertDeliverMaxAlias(boost::json::object& txJson, std::uint32_t const apiVersio } boost::json::object -toJson(ripple::TxMeta const& meta) +toJson(xrpl::TxMeta const& meta) { - boost::json::value value = boost::json::parse(meta.getJson(ripple::JsonOptions::none).toStyledString()); + boost::json::value value = boost::json::parse(meta.getJson(xrpl::JsonOptions::Values::None).toStyledString()); return value.as_object(); } boost::json::value -toBoostJson(Json::Value const& value) +toBoostJson(json::Value const& value) { boost::json::value boostValue = boost::json::parse(value.toStyledString()); @@ -409,12 +406,12 @@ toBoostJson(Json::Value const& value) } boost::json::object -toJson(ripple::SLE const& sle) +toJson(xrpl::SLE const& sle) { - boost::json::value value = boost::json::parse(sle.getJson(ripple::JsonOptions::none).toStyledString()); - if (sle.getType() == ripple::ltACCOUNT_ROOT) { - if (sle.isFieldPresent(ripple::sfEmailHash)) { - auto const& hash = sle.getFieldH128(ripple::sfEmailHash); + boost::json::value value = boost::json::parse(sle.getJson(xrpl::JsonOptions::Values::None).toStyledString()); + if (sle.getType() == xrpl::ltACCOUNT_ROOT) { + if (sle.isFieldPresent(xrpl::sfEmailHash)) { + auto const& hash = sle.getFieldH128(xrpl::sfEmailHash); std::string md5 = strHex(hash); boost::algorithm::to_lower(md5); value.as_object()["urlgravatar"] = str(boost::format("http://www.gravatar.com/avatar/%s") % md5); @@ -424,23 +421,23 @@ toJson(ripple::SLE const& sle) } boost::json::object -toJson(ripple::LedgerHeader const& lgrInfo, bool const binary, std::uint32_t const apiVersion) +toJson(xrpl::LedgerHeader const& lgrInfo, bool const binary, std::uint32_t const apiVersion) { boost::json::object header; if (binary) { - header[JS(ledger_data)] = ripple::strHex(ledgerHeaderToBlob(lgrInfo)); + header[JS(ledger_data)] = xrpl::strHex(ledgerHeaderToBlob(lgrInfo)); } else { - header[JS(account_hash)] = ripple::strHex(lgrInfo.accountHash); + header[JS(account_hash)] = xrpl::strHex(lgrInfo.accountHash); header[JS(close_flags)] = lgrInfo.closeFlags; header[JS(close_time)] = lgrInfo.closeTime.time_since_epoch().count(); - header[JS(close_time_human)] = ripple::to_string(lgrInfo.closeTime); + header[JS(close_time_human)] = xrpl::to_string(lgrInfo.closeTime); header[JS(close_time_resolution)] = lgrInfo.closeTimeResolution.count(); - header[JS(close_time_iso)] = ripple::to_string_iso(lgrInfo.closeTime); - header[JS(ledger_hash)] = ripple::strHex(lgrInfo.hash); + header[JS(close_time_iso)] = xrpl::toStringIso(lgrInfo.closeTime); + header[JS(ledger_hash)] = xrpl::strHex(lgrInfo.hash); header[JS(parent_close_time)] = lgrInfo.parentCloseTime.time_since_epoch().count(); - header[JS(parent_hash)] = ripple::strHex(lgrInfo.parentHash); - header[JS(total_coins)] = ripple::to_string(lgrInfo.drops); - header[JS(transaction_hash)] = ripple::strHex(lgrInfo.txHash); + header[JS(parent_hash)] = xrpl::strHex(lgrInfo.parentHash); + header[JS(total_coins)] = xrpl::to_string(lgrInfo.drops); + header[JS(transaction_hash)] = xrpl::strHex(lgrInfo.txHash); if (apiVersion < 2u) { header[JS(ledger_index)] = std::to_string(lgrInfo.seq); @@ -465,23 +462,23 @@ parseStringAsUInt(std::string const& value) return index; } -std::expected +std::expected ledgerHeaderFromRequest(std::shared_ptr const& backend, web::Context const& ctx) { auto hashValue = ctx.params.contains("ledger_hash") ? ctx.params.at("ledger_hash") : nullptr; if (!hashValue.is_null()) { if (!hashValue.is_string()) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "ledgerHashNotString"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "ledgerHashNotString"}}; - ripple::uint256 ledgerHash; + xrpl::uint256 ledgerHash; if (!ledgerHash.parseHex(boost::json::value_to(hashValue))) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "ledgerHashMalformed"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "ledgerHashMalformed"}}; auto lgrInfo = backend->fetchLedgerByHash(ledgerHash, ctx.yield); if (!lgrInfo || lgrInfo->seq > ctx.range.maxSequence) - return std::unexpected{Status{RippledError::rpcLGR_NOT_FOUND, "ledgerNotFound"}}; + return std::unexpected{Status{RippledError::RpcLgrNotFound, "ledgerNotFound"}}; return *lgrInfo; } @@ -505,18 +502,18 @@ ledgerHeaderFromRequest(std::shared_ptr const& bac } if (!ledgerSequence) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "ledgerIndexMalformed"}}; auto lgrInfo = backend->fetchLedgerBySequence(*ledgerSequence, ctx.yield); if (!lgrInfo || lgrInfo->seq > ctx.range.maxSequence) - return std::unexpected{Status{RippledError::rpcLGR_NOT_FOUND, "ledgerNotFound"}}; + return std::unexpected{Status{RippledError::RpcLgrNotFound, "ledgerNotFound"}}; return *lgrInfo; } // extract ledgerHeaderFromRequest's parameter from context -std::expected +std::expected getLedgerHeaderFromHashOrSeq( BackendInterface const& backend, boost::asio::yield_context yield, @@ -525,12 +522,12 @@ getLedgerHeaderFromHashOrSeq( uint32_t maxSeq ) { - std::optional lgrInfo; - auto const err = std::unexpected{Status{RippledError::rpcLGR_NOT_FOUND, "ledgerNotFound"}}; + std::optional lgrInfo; + auto const err = std::unexpected{Status{RippledError::RpcLgrNotFound, "ledgerNotFound"}}; if (ledgerHash) { // invoke uint256's constructor to parse the hex string , instead of // copying buffer - ripple::uint256 const ledgerHash256{std::string_view(*ledgerHash)}; + xrpl::uint256 const ledgerHash256{std::string_view(*ledgerHash)}; lgrInfo = backend.fetchLedgerByHash(ledgerHash256, yield); if (!lgrInfo || lgrInfo->seq > maxSeq) return err; @@ -550,9 +547,9 @@ getLedgerHeaderFromHashOrSeq( } std::vector -ledgerHeaderToBlob(ripple::LedgerHeader const& info, bool includeHash) +ledgerHeaderToBlob(xrpl::LedgerHeader const& info, bool includeHash) { - ripple::Serializer s; + xrpl::Serializer s; s.add32(info.seq); s.add64(info.drops.drops()); s.addBitString(info.parentHash); @@ -568,20 +565,20 @@ ledgerHeaderToBlob(ripple::LedgerHeader const& info, bool includeHash) } std::uint64_t -getStartHint(ripple::SLE const& sle, ripple::AccountID const& accountID) +getStartHint(xrpl::SLE const& sle, xrpl::AccountID const& accountID) { - if (sle.getType() == ripple::ltRIPPLE_STATE) { - if (sle.getFieldAmount(ripple::sfLowLimit).getIssuer() == accountID) { - return sle.getFieldU64(ripple::sfLowNode); + if (sle.getType() == xrpl::ltRIPPLE_STATE) { + if (sle.getFieldAmount(xrpl::sfLowLimit).getIssuer() == accountID) { + return sle.getFieldU64(xrpl::sfLowNode); } - if (sle.getFieldAmount(ripple::sfHighLimit).getIssuer() == accountID) - return sle.getFieldU64(ripple::sfHighNode); + if (sle.getFieldAmount(xrpl::sfHighLimit).getIssuer() == accountID) + return sle.getFieldU64(xrpl::sfHighNode); } - if (!sle.isFieldPresent(ripple::sfOwnerNode)) + if (!sle.isFieldPresent(xrpl::sfOwnerNode)) return 0; - return sle.getFieldU64(ripple::sfOwnerNode); + return sle.getFieldU64(xrpl::sfOwnerNode); } // traverse account's nfts @@ -591,76 +588,76 @@ std::expected traverseNFTObjects( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& accountID, - ripple::uint256 nextPage, + xrpl::AccountID const& accountID, + xrpl::uint256 nextPage, std::uint32_t limit, boost::asio::yield_context yield, - std::function atOwnedNode + std::function atOwnedNode ) { - auto const firstNFTPage = ripple::keylet::nftpage_min(accountID); - auto const lastNFTPage = ripple::keylet::nftpage_max(accountID); + auto const firstNFTPage = xrpl::keylet::nftpageMin(accountID); + auto const lastNFTPage = xrpl::keylet::nftpageMax(accountID); // check if nextPage is valid - if (nextPage != beast::zero and firstNFTPage.key != (nextPage & ~ripple::nft::pageMask)) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "Invalid marker."}}; + if (nextPage != beast::kZero and firstNFTPage.key != (nextPage & ~xrpl::nft::kPageMask)) + return std::unexpected{Status{RippledError::RpcInvalidParams, "Invalid marker."}}; // no marker, start from the last page - ripple::uint256 const currentPage = nextPage == beast::zero ? lastNFTPage.key : nextPage; + xrpl::uint256 const currentPage = nextPage == beast::kZero ? lastNFTPage.key : nextPage; // read the current page auto page = backend.fetchLedgerObject(currentPage, sequence, yield); if (!page) { - if (nextPage == beast::zero) { // no nft objects in lastNFTPage - return AccountCursor{.index = beast::zero, .hint = 0}; + if (nextPage == beast::kZero) { // no nft objects in lastNFTPage + return AccountCursor{.index = beast::kZero, .hint = 0}; } // marker is in the right range, but still invalid - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "Invalid marker."}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "Invalid marker."}}; } // the object exists and the key is in right range, must be nft page - ripple::SLE pageSLE{ripple::SerialIter{page->data(), page->size()}, currentPage}; + xrpl::SLE pageSLE{xrpl::SerialIter{page->data(), page->size()}, currentPage}; auto count = 0u; // traverse the nft page linked list until the start of the list or reach the limit while (true) { - auto const nftPreviousPage = pageSLE.getFieldH256(ripple::sfPreviousPageMin); + auto const nftPreviousPage = pageSLE.getFieldH256(xrpl::sfPreviousPageMin); atOwnedNode(std::move(pageSLE)); count++; - if (count == limit or nftPreviousPage == beast::zero) + if (count == limit or nftPreviousPage == beast::kZero) return AccountCursor{.index = nftPreviousPage, .hint = count}; page = backend.fetchLedgerObject(nftPreviousPage, sequence, yield); - pageSLE = ripple::SLE{ripple::SerialIter{page->data(), page->size()}, nftPreviousPage}; + pageSLE = xrpl::SLE{xrpl::SerialIter{page->data(), page->size()}, nftPreviousPage}; } - return AccountCursor{.index = beast::zero, .hint = 0}; + return AccountCursor{.index = beast::kZero, .hint = 0}; } std::expected traverseOwnedNodes( BackendInterface const& backend, - ripple::AccountID const& accountID, + xrpl::AccountID const& accountID, std::uint32_t sequence, std::uint32_t limit, std::optional jsonCursor, boost::asio::yield_context yield, - std::function atOwnedNode, + std::function atOwnedNode, bool nftIncluded ) { auto const maybeCursor = parseAccountCursor(jsonCursor); if (!maybeCursor) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "Malformed cursor."}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "Malformed cursor."}}; // the format is checked in RPC framework level auto [hexCursor, startHint] = *maybeCursor; - auto const isNftMarkerNonZero = startHint == std::numeric_limits::max() and hexCursor != beast::zero; - auto const isNftMarkerZero = startHint == std::numeric_limits::max() and hexCursor == beast::zero; + auto const isNftMarkerNonZero = startHint == std::numeric_limits::max() and hexCursor != beast::kZero; + auto const isNftMarkerZero = startHint == std::numeric_limits::max() and hexCursor == beast::kZero; // if we need to traverse nft objects and this is the first request -> traverse nft objects // if we need to traverse nft objects and the marker is still in nft page -> traverse nft objects // if we need to traverse nft objects and the marker is still in nft page but next page is zero -> owned nodes @@ -679,39 +676,39 @@ traverseOwnedNodes( // adjust limit ,continue traversing owned nodes limit -= nftsCount; - hexCursor = beast::zero; + hexCursor = beast::kZero; startHint = 0; } else if (nftIncluded and isNftMarkerZero) { // the last request happen to fetch all the nft, adjust marker to continue traversing owned nodes - hexCursor = beast::zero; + hexCursor = beast::kZero; startHint = 0; } return traverseOwnedNodes( - backend, ripple::keylet::ownerDir(accountID), hexCursor, startHint, sequence, limit, yield, atOwnedNode + backend, xrpl::keylet::ownerDir(accountID), hexCursor, startHint, sequence, limit, yield, atOwnedNode ); } std::expected traverseOwnedNodes( BackendInterface const& backend, - ripple::Keylet const& owner, - ripple::uint256 const& hexMarker, + xrpl::Keylet const& owner, + xrpl::uint256 const& hexMarker, std::uint32_t const startHint, std::uint32_t sequence, std::uint32_t limit, boost::asio::yield_context yield, - std::function atOwnedNode + std::function atOwnedNode ) { - auto cursor = AccountCursor({.index = beast::zero, .hint = 0}); + auto cursor = AccountCursor({.index = beast::kZero, .hint = 0}); auto const rootIndex = owner; auto currentIndex = rootIndex; // track the current page we are accessing, will return it as the next hint auto currentPage = startHint; - std::vector keys; + std::vector keys; // Only reserve 2048 nodes when fetching all owned ledger objects. If there // are more, then keys will allocate more memory, which is suboptimal, but // should only occur occasionally. @@ -722,19 +719,19 @@ traverseOwnedNodes( // If startAfter is not zero try jumping to that page using the hint if (hexMarker.isNonZero()) { - auto const hintIndex = ripple::keylet::page(rootIndex, startHint); + auto const hintIndex = xrpl::keylet::page(rootIndex, startHint); auto hintDir = backend.fetchLedgerObject(hintIndex.key, sequence, yield); if (!hintDir) - return std::unexpected{Status(ripple::rpcINVALID_PARAMS, "Invalid marker.")}; + return std::unexpected{Status(xrpl::RpcInvalidParams, "Invalid marker.")}; - ripple::SerialIter hintDirIt{hintDir->data(), hintDir->size()}; - ripple::SLE const hintDirSle{hintDirIt, hintIndex.key}; + xrpl::SerialIter hintDirIt{hintDir->data(), hintDir->size()}; + xrpl::SLE const hintDirSle{hintDirIt, hintIndex.key}; - if (auto const& indexes = hintDirSle.getFieldV256(ripple::sfIndexes); + if (auto const& indexes = hintDirSle.getFieldV256(xrpl::sfIndexes); std::ranges::find(indexes, hexMarker) == std::end(indexes)) { // the index specified by marker is not in the page specified by marker - return std::unexpected{Status(ripple::rpcINVALID_PARAMS, "Invalid marker.")}; + return std::unexpected{Status(xrpl::RpcInvalidParams, "Invalid marker.")}; } currentIndex = hintIndex; @@ -743,12 +740,12 @@ traverseOwnedNodes( auto const ownerDir = backend.fetchLedgerObject(currentIndex.key, sequence, yield); if (!ownerDir) - return std::unexpected{Status(ripple::rpcINVALID_PARAMS, "Owner directory not found.")}; + return std::unexpected{Status(xrpl::RpcInvalidParams, "Owner directory not found.")}; - ripple::SerialIter ownedDirIt{ownerDir->data(), ownerDir->size()}; - ripple::SLE const ownedDirSle{ownedDirIt, currentIndex.key}; + xrpl::SerialIter ownedDirIt{ownerDir->data(), ownerDir->size()}; + xrpl::SLE const ownedDirSle{ownedDirIt, currentIndex.key}; - for (auto const& key : ownedDirSle.getFieldV256(ripple::sfIndexes)) { + for (auto const& key : ownedDirSle.getFieldV256(xrpl::sfIndexes)) { if (!found) { if (key == hexMarker) found = true; @@ -766,11 +763,11 @@ traverseOwnedNodes( break; } // the next page - auto const uNodeNext = ownedDirSle.getFieldU64(ripple::sfIndexNext); + auto const uNodeNext = ownedDirSle.getFieldU64(xrpl::sfIndexNext); if (uNodeNext == 0) break; - currentIndex = ripple::keylet::page(rootIndex, uNodeNext); + currentIndex = xrpl::keylet::page(rootIndex, uNodeNext); currentPage = uNodeNext; } } else { @@ -780,10 +777,10 @@ traverseOwnedNodes( if (!ownerDir) break; - ripple::SerialIter ownedDirIt{ownerDir->data(), ownerDir->size()}; - ripple::SLE const ownedDirSle{ownedDirIt, currentIndex.key}; + xrpl::SerialIter ownedDirIt{ownerDir->data(), ownerDir->size()}; + xrpl::SLE const ownedDirSle{ownedDirIt, currentIndex.key}; - for (auto const& key : ownedDirSle.getFieldV256(ripple::sfIndexes)) { + for (auto const& key : ownedDirSle.getFieldV256(xrpl::sfIndexes)) { keys.push_back(key); if (--limit == 0) @@ -795,11 +792,11 @@ traverseOwnedNodes( break; } - auto const uNodeNext = ownedDirSle.getFieldU64(ripple::sfIndexNext); + auto const uNodeNext = ownedDirSle.getFieldU64(xrpl::sfIndexNext); if (uNodeNext == 0) break; - currentIndex = ripple::keylet::page(rootIndex, uNodeNext); + currentIndex = xrpl::keylet::page(rootIndex, uNodeNext); currentPage = uNodeNext; } } @@ -818,32 +815,32 @@ traverseOwnedNodes( LOG(log.debug()) << "Time loading owned entries: " << timeDiff << " milliseconds"; for (auto i = 0u; i < objects.size(); ++i) { - ripple::SerialIter it{objects[i].data(), objects[i].size()}; - atOwnedNode(ripple::SLE{it, keys[i]}); + xrpl::SerialIter it{objects[i].data(), objects[i].size()}; + atOwnedNode(xrpl::SLE{it, keys[i]}); } if (limit == 0) return cursor; - return AccountCursor({.index = beast::zero, .hint = 0}); + return AccountCursor({.index = beast::kZero, .hint = 0}); } -std::shared_ptr +std::shared_ptr read( std::shared_ptr const& backend, - ripple::Keylet const& keylet, - ripple::LedgerHeader const& lgrInfo, + xrpl::Keylet const& keylet, + xrpl::LedgerHeader const& lgrInfo, web::Context const& context ) { if (auto const blob = backend->fetchLedgerObject(keylet.key, lgrInfo.seq, context.yield); blob) { - return std::make_shared(ripple::SerialIter{blob->data(), blob->size()}, keylet.key); + return std::make_shared(xrpl::SerialIter{blob->data(), blob->size()}, keylet.key); } return nullptr; } -std::optional +std::optional parseRippleLibSeed(boost::json::value const& value) { // ripple-lib encodes seed used to generate an Ed25519 wallet in a @@ -852,27 +849,27 @@ parseRippleLibSeed(boost::json::value const& value) if (!value.is_string()) return {}; - auto const result = ripple::decodeBase58Token(boost::json::value_to(value), ripple::TokenType::None); + auto const result = xrpl::decodeBase58Token(boost::json::value_to(value), xrpl::TokenType::None); static constexpr std::size_t kSEED_SIZE = 18; static constexpr std::array kSEED_PREFIX = {0xE1, 0x4B}; if (result.size() == kSEED_SIZE && static_cast(result[0]) == kSEED_PREFIX[0] && static_cast(result[1]) == kSEED_PREFIX[1]) - return ripple::Seed(ripple::makeSlice(result.substr(2))); + return xrpl::Seed(xrpl::makeSlice(result.substr(2))); return {}; } -std::vector +std::vector getAccountsFromTransaction(boost::json::object const& transaction) { - std::vector accounts = {}; + std::vector accounts = {}; for (auto const& [key, value] : transaction) { if (value.is_object()) { auto inObject = getAccountsFromTransaction(value.as_object()); accounts.insert(accounts.end(), inObject.begin(), inObject.end()); } else if (value.is_string()) { - auto const account = util::parseBase58Wrapper(boost::json::value_to(value)); + auto const account = util::parseBase58Wrapper(boost::json::value_to(value)); if (account) { accounts.push_back(*account); } @@ -886,30 +883,30 @@ bool isGlobalFrozen( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ) { - if (ripple::isXRP(issuer)) + if (xrpl::isXRP(issuer)) return false; - auto key = ripple::keylet::account(issuer).key; + auto key = xrpl::keylet::account(issuer).key; auto blob = backend.fetchLedgerObject(key, sequence, yield); if (!blob) return false; - ripple::SerialIter it{blob->data(), blob->size()}; - ripple::SLE const sle{it, key}; + xrpl::SerialIter it{blob->data(), blob->size()}; + xrpl::SLE const sle{it, key}; - return sle.isFlag(ripple::lsfGlobalFreeze); + return sle.isFlag(xrpl::lsfGlobalFreeze); } bool fetchAndCheckAnyFlagsExists( BackendInterface const& backend, std::uint32_t sequence, - ripple::Keylet const& keylet, + xrpl::Keylet const& keylet, std::vector const& flags, boost::asio::yield_context yield ) @@ -919,8 +916,8 @@ fetchAndCheckAnyFlagsExists( if (!blob) return false; - ripple::SerialIter it{blob->data(), blob->size()}; - ripple::SLE const sle{it, keylet.key}; + xrpl::SerialIter it{blob->data(), blob->size()}; + xrpl::SLE const sle{it, keylet.key}; return std::ranges::any_of(flags, [sle](std::uint32_t flag) { return sle.isFlag(flag); }); } @@ -929,27 +926,25 @@ bool isFrozen( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ) { - if (ripple::isXRP(currency)) + if (xrpl::isXRP(currency)) return false; - if (fetchAndCheckAnyFlagsExists( - backend, sequence, ripple::keylet::account(issuer), {ripple::lsfGlobalFreeze}, yield - )) + if (fetchAndCheckAnyFlagsExists(backend, sequence, xrpl::keylet::account(issuer), {xrpl::lsfGlobalFreeze}, yield)) return true; - auto const trustLineKeylet = ripple::keylet::line(account, issuer, currency); + auto const trustLineKeylet = xrpl::keylet::line(account, issuer, currency); return issuer != account && fetchAndCheckAnyFlagsExists( backend, sequence, trustLineKeylet, - {(issuer > account) ? ripple::lsfHighFreeze : ripple::lsfLowFreeze}, + {(issuer > account) ? xrpl::lsfHighFreeze : xrpl::lsfLowFreeze}, yield ); } @@ -958,22 +953,22 @@ bool isDeepFrozen( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ) { - if (ripple::isXRP(currency)) + if (xrpl::isXRP(currency)) return false; if (issuer == account) return false; - auto const trustLineKeylet = ripple::keylet::line(account, issuer, currency); + auto const trustLineKeylet = xrpl::keylet::line(account, issuer, currency); return fetchAndCheckAnyFlagsExists( - backend, sequence, trustLineKeylet, {ripple::lsfHighDeepFreeze, ripple::lsfLowDeepFreeze}, yield + backend, sequence, trustLineKeylet, {xrpl::lsfHighDeepFreeze, xrpl::lsfLowDeepFreeze}, yield ); } @@ -981,9 +976,9 @@ bool isLPTokenFrozen( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Issue const& asset, - ripple::Issue const& asset2, + xrpl::AccountID const& account, + xrpl::Issue const& asset, + xrpl::Issue const& asset2, boost::asio::yield_context yield ) { @@ -991,33 +986,33 @@ isLPTokenFrozen( isFrozen(backend, sequence, account, asset2.currency, asset2.account, yield); } -ripple::XRPAmount +xrpl::XRPAmount xrpLiquid( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& id, + xrpl::AccountID const& id, boost::asio::yield_context yield ) { - auto const key = ripple::keylet::account(id).key; + auto const key = xrpl::keylet::account(id).key; auto blob = backend.fetchLedgerObject(key, sequence, yield); if (!blob) - return beast::zero; + return beast::kZero; - ripple::SerialIter it{blob->data(), blob->size()}; - ripple::SLE const sle{it, key}; + xrpl::SerialIter it{blob->data(), blob->size()}; + xrpl::SLE const sle{it, key}; - std::uint32_t const ownerCount = sle.getFieldU32(ripple::sfOwnerCount); + std::uint32_t const ownerCount = sle.getFieldU32(xrpl::sfOwnerCount); - auto balance = sle.getFieldAmount(ripple::sfBalance); + auto balance = sle.getFieldAmount(xrpl::sfBalance); - ripple::STAmount const amount = [&]() { + xrpl::STAmount const amount = [&]() { // AMM doesn't require the reserves - if ((sle.getFlags() & ripple::lsfAMMNode) != 0u) + if ((sle.getFlags() & xrpl::lsfAMMNode) != 0u) return balance; auto const reserve = backend.fetchFees(sequence, yield)->accountReserve(ownerCount); - ripple::STAmount amount = balance - reserve; + xrpl::STAmount amount = balance - reserve; if (balance < reserve) amount.clear(); return amount; @@ -1026,13 +1021,13 @@ xrpLiquid( return amount.xrp(); } -ripple::STAmount +xrpl::STAmount accountFunds( BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t const sequence, - ripple::STAmount const& amount, - ripple::AccountID const& id, + xrpl::STAmount const& amount, + xrpl::AccountID const& id, boost::asio::yield_context yield ) { @@ -1040,75 +1035,77 @@ accountFunds( return amount; } - return accountHolds(backend, amendmentCenter, sequence, id, amount.getCurrency(), amount.getIssuer(), true, yield); + return accountHolds( + backend, amendmentCenter, sequence, id, amount.get().currency, amount.getIssuer(), true, yield + ); } -ripple::STAmount +xrpl::STAmount ammAccountHolds( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, bool const zeroIfFrozen, boost::asio::yield_context yield ) { - ripple::STAmount amount; - ASSERT(!ripple::isXRP(currency), "LPToken currency can never be XRP"); - if (ripple::isXRP(currency)) + xrpl::STAmount amount; + ASSERT(!xrpl::isXRP(currency), "LPToken currency can never be XRP"); + if (xrpl::isXRP(currency)) return {xrpLiquid(backend, sequence, account, yield)}; - auto const key = ripple::keylet::line(account, issuer, currency).key; + auto const key = xrpl::keylet::line(account, issuer, currency).key; auto const blob = backend.fetchLedgerObject(key, sequence, yield); if (!blob) { - amount.setIssue(ripple::Issue(currency, issuer)); + amount.setIssue(xrpl::Issue(currency, issuer)); amount.clear(); return amount; } - ripple::SerialIter it{blob->data(), blob->size()}; - ripple::SLE const sle{it, key}; + xrpl::SerialIter it{blob->data(), blob->size()}; + xrpl::SLE const sle{it, key}; if (zeroIfFrozen && (isFrozen(backend, sequence, account, currency, issuer, yield) || isDeepFrozen(backend, sequence, account, currency, issuer, yield))) { - amount.setIssue(ripple::Issue(currency, issuer)); + amount.setIssue(xrpl::Issue(currency, issuer)); amount.clear(); } else { - amount = sle.getFieldAmount(ripple::sfBalance); + amount = sle.getFieldAmount(xrpl::sfBalance); if (account > issuer) { // Put balance in account terms. amount.negate(); } - amount.setIssuer(issuer); + amount.setIssue(xrpl::Issue{amount.get().currency, issuer}); } return amount; } -ripple::STAmount +xrpl::STAmount accountHolds( BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, bool const zeroIfFrozen, boost::asio::yield_context yield ) { - ripple::STAmount amount; - if (ripple::isXRP(currency)) + xrpl::STAmount amount; + if (xrpl::isXRP(currency)) return {xrpLiquid(backend, sequence, account, yield)}; - auto const key = ripple::keylet::line(account, issuer, currency).key; + auto const key = xrpl::keylet::line(account, issuer, currency).key; auto const blob = backend.fetchLedgerObject(key, sequence, yield); if (!blob) { - amount.setIssue(ripple::Issue(currency, issuer)); + amount.setIssue(xrpl::Issue(currency, issuer)); amount.clear(); return amount; } @@ -1121,32 +1118,32 @@ accountHolds( return false; if (amendmentCenter.isEnabled(yield, data::Amendments::fixFrozenLPTokenTransfer, sequence)) { - auto const issuerBlob = backend.fetchLedgerObject(ripple::keylet::account(issuer).key, sequence, yield); + auto const issuerBlob = backend.fetchLedgerObject(xrpl::keylet::account(issuer).key, sequence, yield); if (!issuerBlob) return false; - ripple::SLE const issuerSle{ - ripple::SerialIter{issuerBlob->data(), issuerBlob->size()}, ripple::keylet::account(issuer).key + xrpl::SLE const issuerSle{ + xrpl::SerialIter{issuerBlob->data(), issuerBlob->size()}, xrpl::keylet::account(issuer).key }; // if the issuer is an amm account, then currency is lptoken, so we will need to check if the // assets in the pool are frozen as well - if (issuerSle.isFieldPresent(ripple::sfAMMID)) { - auto const ammKeylet = ripple::keylet::amm(issuerSle[ripple::sfAMMID]); + if (issuerSle.isFieldPresent(xrpl::sfAMMID)) { + auto const ammKeylet = xrpl::keylet::amm(issuerSle[xrpl::sfAMMID]); auto const ammBlob = backend.fetchLedgerObject(ammKeylet.key, sequence, yield); if (!ammBlob) return false; - ripple::SLE const ammSle{ripple::SerialIter{ammBlob->data(), ammBlob->size()}, ammKeylet.key}; + xrpl::SLE const ammSle{xrpl::SerialIter{ammBlob->data(), ammBlob->size()}, ammKeylet.key}; return !isLPTokenFrozen( backend, sequence, account, - ammSle[ripple::sfAsset].get(), - ammSle[ripple::sfAsset2].get(), + ammSle[xrpl::sfAsset].get(), + ammSle[xrpl::sfAsset2].get(), yield ); } @@ -1156,50 +1153,50 @@ accountHolds( }(); if (allowBalance) { - ripple::SerialIter it{blob->data(), blob->size()}; - ripple::SLE const sle{it, key}; + xrpl::SerialIter it{blob->data(), blob->size()}; + xrpl::SLE const sle{it, key}; - amount = sle.getFieldAmount(ripple::sfBalance); + amount = sle.getFieldAmount(xrpl::sfBalance); if (account > issuer) { // Put balance in account terms. amount.negate(); } - amount.setIssuer(issuer); + amount.setIssue(xrpl::Issue{amount.get().currency, issuer}); } else { - amount.setIssue(ripple::Issue(currency, issuer)); + amount.setIssue(xrpl::Issue(currency, issuer)); amount.clear(); } return amount; } -ripple::Rate +xrpl::Rate transferRate( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ) { - auto key = ripple::keylet::account(issuer).key; + auto key = xrpl::keylet::account(issuer).key; auto blob = backend.fetchLedgerObject(key, sequence, yield); if (blob) { - ripple::SerialIter it{blob->data(), blob->size()}; - ripple::SLE const sle{it, key}; + xrpl::SerialIter it{blob->data(), blob->size()}; + xrpl::SLE const sle{it, key}; - if (sle.isFieldPresent(ripple::sfTransferRate)) - return ripple::Rate{sle.getFieldU32(ripple::sfTransferRate)}; + if (sle.isFieldPresent(xrpl::sfTransferRate)) + return xrpl::Rate{sle.getFieldU32(xrpl::sfTransferRate)}; } - return ripple::parityRate; + return xrpl::kParityRate; } boost::json::array postProcessOrderBook( std::vector const& offers, - ripple::Book const& book, - ripple::AccountID const& takerID, + xrpl::Book const& book, + xrpl::AccountID const& takerID, data::BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t const ledgerSequence, @@ -1208,26 +1205,26 @@ postProcessOrderBook( { boost::json::array jsonOffers; - std::map umBalance; + std::map umBalance; - bool const globalFreeze = isGlobalFrozen(backend, ledgerSequence, book.out.account, yield) || - isGlobalFrozen(backend, ledgerSequence, book.in.account, yield); + bool const globalFreeze = isGlobalFrozen(backend, ledgerSequence, book.out.getIssuer(), yield) || + isGlobalFrozen(backend, ledgerSequence, book.in.getIssuer(), yield); - auto rate = transferRate(backend, ledgerSequence, book.out.account, yield); + auto rate = transferRate(backend, ledgerSequence, book.out.getIssuer(), yield); for (auto const& obj : offers) { try { - ripple::SerialIter it{obj.blob.data(), obj.blob.size()}; - ripple::SLE const offer{it, obj.key}; - ripple::uint256 const bookDir = offer.getFieldH256(ripple::sfBookDirectory); + xrpl::SerialIter it{obj.blob.data(), obj.blob.size()}; + xrpl::SLE const offer{it, obj.key}; + xrpl::uint256 const bookDir = offer.getFieldH256(xrpl::sfBookDirectory); - auto const uOfferOwnerID = offer.getAccountID(ripple::sfAccount); - auto const& saTakerGets = offer.getFieldAmount(ripple::sfTakerGets); - auto const& saTakerPays = offer.getFieldAmount(ripple::sfTakerPays); - ripple::STAmount saOwnerFunds; + auto const uOfferOwnerID = offer.getAccountID(xrpl::sfAccount); + auto const& saTakerGets = offer.getFieldAmount(xrpl::sfTakerGets); + auto const& saTakerPays = offer.getFieldAmount(xrpl::sfTakerPays); + xrpl::STAmount saOwnerFunds; bool firstOwnerOffer = true; - if (book.out.account == uOfferOwnerID) { + if (book.out.getIssuer() == uOfferOwnerID) { // If an offer is selling issuer's own IOUs, it is fully // funded. saOwnerFunds = saTakerGets; @@ -1248,34 +1245,34 @@ postProcessOrderBook( amendmentCenter, ledgerSequence, uOfferOwnerID, - book.out.currency, - book.out.account, + book.out.get().currency, + book.out.getIssuer(), true, yield ); - if (saOwnerFunds < beast::zero) + if (saOwnerFunds < beast::kZero) saOwnerFunds.clear(); } } boost::json::object offerJson = toJson(offer); - ripple::STAmount saTakerGetsFunded; - ripple::STAmount saOwnerFundsLimit = saOwnerFunds; - ripple::Rate offerRate = ripple::parityRate; - ripple::STAmount const dirRate = ripple::amountFromQuality(getQuality(bookDir)); + xrpl::STAmount saTakerGetsFunded; + xrpl::STAmount saOwnerFundsLimit = saOwnerFunds; + xrpl::Rate offerRate = xrpl::kParityRate; + xrpl::STAmount const dirRate = xrpl::amountFromQuality(getQuality(bookDir)); - if (rate != ripple::parityRate + if (rate != xrpl::kParityRate // Have a transfer fee. - && takerID != book.out.account + && takerID != book.out.getIssuer() // Not taking offers of own IOUs. - && book.out.account != uOfferOwnerID) + && book.out.getIssuer() != uOfferOwnerID) // Offer owner not issuing ownfunds { // Need to charge a transfer fee to offer owner. offerRate = rate; - saOwnerFundsLimit = ripple::divide(saOwnerFunds, offerRate); + saOwnerFundsLimit = xrpl::divide(saOwnerFunds, offerRate); } if (saOwnerFundsLimit >= saTakerGets) { @@ -1283,16 +1280,17 @@ postProcessOrderBook( saTakerGetsFunded = saTakerGets; } else { saTakerGetsFunded = saOwnerFundsLimit; - offerJson["taker_gets_funded"] = toBoostJson(saTakerGetsFunded.getJson(ripple::JsonOptions::none)); + offerJson["taker_gets_funded"] = + toBoostJson(saTakerGetsFunded.getJson(xrpl::JsonOptions::Values::None)); offerJson["taker_pays_funded"] = toBoostJson( - std::min(saTakerPays, ripple::multiply(saTakerGetsFunded, dirRate, saTakerPays.issue())) - .getJson(ripple::JsonOptions::none) + std::min(saTakerPays, xrpl::multiply(saTakerGetsFunded, dirRate, saTakerPays.get())) + .getJson(xrpl::JsonOptions::Values::None) ); } - ripple::STAmount const saOwnerPays = (ripple::parityRate == offerRate) + xrpl::STAmount const saOwnerPays = (xrpl::kParityRate == offerRate) ? saTakerGetsFunded - : std::min(saOwnerFunds, ripple::multiply(saTakerGetsFunded, offerRate)); + : std::min(saOwnerFunds, xrpl::multiply(saTakerGetsFunded, offerRate)); umBalance[uOfferOwnerID] = saOwnerFunds - saOwnerPays; @@ -1311,196 +1309,196 @@ postProcessOrderBook( } // get book via currency type -std::expected +std::expected parseBook( - ripple::Currency pays, - ripple::AccountID payIssuer, - ripple::Currency gets, - ripple::AccountID getIssuer, + xrpl::Currency pays, + xrpl::AccountID payIssuer, + xrpl::Currency gets, + xrpl::AccountID getIssuer, std::optional const& domain ) { if (isXRP(pays) && !isXRP(payIssuer)) { return std::unexpected{Status{ - RippledError::rpcSRC_ISR_MALFORMED, "Unneeded field 'taker_pays.issuer' for XRP currency specification." + RippledError::RpcSrcIsrMalformed, "Unneeded field 'taker_pays.issuer' for XRP currency specification." }}; } if (!isXRP(pays) && isXRP(payIssuer)) { return std::unexpected{ - Status{RippledError::rpcSRC_ISR_MALFORMED, "Invalid field 'taker_pays.issuer', expected non-XRP issuer."} + Status{RippledError::RpcSrcIsrMalformed, "Invalid field 'taker_pays.issuer', expected non-XRP issuer."} }; } - if (ripple::isXRP(gets) && !ripple::isXRP(getIssuer)) { + if (xrpl::isXRP(gets) && !xrpl::isXRP(getIssuer)) { return std::unexpected{Status{ - RippledError::rpcDST_ISR_MALFORMED, "Unneeded field 'taker_gets.issuer' for XRP currency specification." + RippledError::RpcDstIsrMalformed, "Unneeded field 'taker_gets.issuer' for XRP currency specification." }}; } - if (!ripple::isXRP(gets) && ripple::isXRP(getIssuer)) { + if (!xrpl::isXRP(gets) && xrpl::isXRP(getIssuer)) { return std::unexpected{ - Status{RippledError::rpcDST_ISR_MALFORMED, "Invalid field 'taker_gets.issuer', expected non-XRP issuer."} + Status{RippledError::RpcDstIsrMalformed, "Invalid field 'taker_gets.issuer', expected non-XRP issuer."} }; } if (pays == gets && payIssuer == getIssuer) - return std::unexpected{Status{RippledError::rpcBAD_MARKET, "badMarket"}}; + return std::unexpected{Status{RippledError::RpcBadMarket, "badMarket"}}; - std::optional domainID = std::nullopt; + std::optional domainID = std::nullopt; if (domain.has_value()) { - ripple::uint256 dom; + xrpl::uint256 dom; if (!dom.parseHex(*domain)) - return std::unexpected{Status{RippledError::rpcDOMAIN_MALFORMED}}; + return std::unexpected{Status{RippledError::RpcDomainMalformed}}; domainID = dom; } - return ripple::Book{{pays, payIssuer}, {gets, getIssuer}, domainID}; + return xrpl::Book{xrpl::Issue{pays, payIssuer}, xrpl::Issue{gets, getIssuer}, domainID}; } -std::expected +std::expected parseBook(boost::json::object const& request) { if (!request.contains("taker_pays")) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "Missing field 'taker_pays'"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "Missing field 'taker_pays'"}}; if (!request.contains("taker_gets")) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "Missing field 'taker_gets'"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "Missing field 'taker_gets'"}}; if (!request.at("taker_pays").is_object()) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "Field 'taker_pays' is not an object"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "Field 'taker_pays' is not an object"}}; if (!request.at("taker_gets").is_object()) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "Field 'taker_gets' is not an object"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "Field 'taker_gets' is not an object"}}; auto takerPays = request.at("taker_pays").as_object(); if (!takerPays.contains("currency")) - return std::unexpected{Status{RippledError::rpcSRC_CUR_MALFORMED}}; + return std::unexpected{Status{RippledError::RpcSrcCurMalformed}}; if (!takerPays.at("currency").is_string()) - return std::unexpected{Status{RippledError::rpcSRC_CUR_MALFORMED}}; + return std::unexpected{Status{RippledError::RpcSrcCurMalformed}}; auto takerGets = request.at("taker_gets").as_object(); if (!takerGets.contains("currency")) - return std::unexpected{Status{RippledError::rpcDST_AMT_MALFORMED}}; + return std::unexpected{Status{RippledError::RpcDstAmtMalformed}}; if (!takerGets.at("currency").is_string()) { return std::unexpected{Status{ - RippledError::rpcDST_AMT_MALFORMED, + RippledError::RpcDstAmtMalformed, }}; } if (request.contains("domain") && !request.at("domain").is_string()) - return std::unexpected{Status{RippledError::rpcDOMAIN_MALFORMED}}; + return std::unexpected{Status{RippledError::RpcDomainMalformed}}; - ripple::Currency payCurrency; - if (!ripple::to_currency(payCurrency, boost::json::value_to(takerPays.at("currency")))) - return std::unexpected{Status{RippledError::rpcSRC_CUR_MALFORMED}}; + xrpl::Currency payCurrency; + if (!xrpl::toCurrency(payCurrency, boost::json::value_to(takerPays.at("currency")))) + return std::unexpected{Status{RippledError::RpcSrcCurMalformed}}; - ripple::Currency getCurrency; - if (!ripple::to_currency(getCurrency, boost::json::value_to(takerGets["currency"]))) - return std::unexpected{Status{RippledError::rpcDST_AMT_MALFORMED}}; + xrpl::Currency getCurrency; + if (!xrpl::toCurrency(getCurrency, boost::json::value_to(takerGets["currency"]))) + return std::unexpected{Status{RippledError::RpcDstAmtMalformed}}; - ripple::AccountID payIssuer; + xrpl::AccountID payIssuer; if (takerPays.contains("issuer")) { if (!takerPays.at("issuer").is_string()) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "takerPaysIssuerNotString"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "takerPaysIssuerNotString"}}; - if (!ripple::to_issuer(payIssuer, boost::json::value_to(takerPays.at("issuer")))) - return std::unexpected{Status{RippledError::rpcSRC_ISR_MALFORMED}}; + if (!xrpl::toIssuer(payIssuer, boost::json::value_to(takerPays.at("issuer")))) + return std::unexpected{Status{RippledError::RpcSrcIsrMalformed}}; - if (payIssuer == ripple::noAccount()) - return std::unexpected{Status{RippledError::rpcSRC_ISR_MALFORMED}}; + if (payIssuer == xrpl::noAccount()) + return std::unexpected{Status{RippledError::RpcSrcIsrMalformed}}; } else { - payIssuer = ripple::xrpAccount(); + payIssuer = xrpl::xrpAccount(); } if (isXRP(payCurrency) && !isXRP(payIssuer)) { return std::unexpected{Status{ - RippledError::rpcSRC_ISR_MALFORMED, "Unneeded field 'taker_pays.issuer' for XRP currency specification." + RippledError::RpcSrcIsrMalformed, "Unneeded field 'taker_pays.issuer' for XRP currency specification." }}; } if (!isXRP(payCurrency) && isXRP(payIssuer)) { return std::unexpected{ - Status{RippledError::rpcSRC_ISR_MALFORMED, "Invalid field 'taker_pays.issuer', expected non-XRP issuer."} + Status{RippledError::RpcSrcIsrMalformed, "Invalid field 'taker_pays.issuer', expected non-XRP issuer."} }; } if ((!isXRP(payCurrency)) && (!takerPays.contains("issuer"))) - return std::unexpected{Status{RippledError::rpcSRC_ISR_MALFORMED, "Missing non-XRP issuer."}}; + return std::unexpected{Status{RippledError::RpcSrcIsrMalformed, "Missing non-XRP issuer."}}; - ripple::AccountID getIssuer; + xrpl::AccountID getIssuer; if (takerGets.contains("issuer")) { if (!takerGets["issuer"].is_string()) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "taker_gets.issuer should be string"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "taker_gets.issuer should be string"}}; - if (!ripple::to_issuer(getIssuer, boost::json::value_to(takerGets.at("issuer")))) { + if (!xrpl::toIssuer(getIssuer, boost::json::value_to(takerGets.at("issuer")))) { return std::unexpected{ - Status{RippledError::rpcDST_ISR_MALFORMED, "Invalid field 'taker_gets.issuer', bad issuer."} + Status{RippledError::RpcDstIsrMalformed, "Invalid field 'taker_gets.issuer', bad issuer."} }; } - if (getIssuer == ripple::noAccount()) { + if (getIssuer == xrpl::noAccount()) { return std::unexpected{ - Status{RippledError::rpcDST_ISR_MALFORMED, "Invalid field 'taker_gets.issuer', bad issuer account one."} + Status{RippledError::RpcDstIsrMalformed, "Invalid field 'taker_gets.issuer', bad issuer account one."} }; } } else { - getIssuer = ripple::xrpAccount(); + getIssuer = xrpl::xrpAccount(); } - if (ripple::isXRP(getCurrency) && !ripple::isXRP(getIssuer)) { + if (xrpl::isXRP(getCurrency) && !xrpl::isXRP(getIssuer)) { return std::unexpected{Status{ - RippledError::rpcDST_ISR_MALFORMED, "Unneeded field 'taker_gets.issuer' for XRP currency specification." + RippledError::RpcDstIsrMalformed, "Unneeded field 'taker_gets.issuer' for XRP currency specification." }}; } - if (!ripple::isXRP(getCurrency) && ripple::isXRP(getIssuer)) { + if (!xrpl::isXRP(getCurrency) && xrpl::isXRP(getIssuer)) { return std::unexpected{ - Status{RippledError::rpcDST_ISR_MALFORMED, "Invalid field 'taker_gets.issuer', expected non-XRP issuer."} + Status{RippledError::RpcDstIsrMalformed, "Invalid field 'taker_gets.issuer', expected non-XRP issuer."} }; } if (payCurrency == getCurrency && payIssuer == getIssuer) - return std::unexpected{Status{RippledError::rpcBAD_MARKET, "badMarket"}}; + return std::unexpected{Status{RippledError::RpcBadMarket, "badMarket"}}; - std::optional domainID; + std::optional domainID; if (request.contains("domain")) { - ripple::uint256 dom; + xrpl::uint256 dom; if (!dom.parseHex(boost::json::value_to(request.at("domain")))) - return std::unexpected{Status{RippledError::rpcDOMAIN_MALFORMED}}; + return std::unexpected{Status{RippledError::RpcDomainMalformed}}; domainID = dom; } - return ripple::Book{{payCurrency, payIssuer}, {getCurrency, getIssuer}, domainID}; + return xrpl::Book{xrpl::Issue{payCurrency, payIssuer}, xrpl::Issue{getCurrency, getIssuer}, domainID}; } -std::expected +std::expected parseTaker(boost::json::value const& taker) { - std::optional takerID = {}; + std::optional takerID = {}; if (!taker.is_string()) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "takerNotString"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "takerNotString"}}; takerID = accountFromStringStrict(boost::json::value_to(taker)); if (!takerID) - return std::unexpected{Status{RippledError::rpcBAD_ISSUER, "invalidTakerAccount"}}; + return std::unexpected{Status{RippledError::RpcBadIssuer, "invalidTakerAccount"}}; return *takerID; } -ripple::Issue +xrpl::Issue parseIssue(boost::json::object const& issue) { - Json::Value jv; + json::Value jv; if (issue.contains(JS(issuer)) && issue.at(JS(issuer)).is_string()) jv["issuer"] = boost::json::value_to(issue.at(JS(issuer))); if (issue.contains(JS(currency)) && issue.at(JS(currency)).is_string()) jv["currency"] = boost::json::value_to(issue.at(JS(currency))); - return ripple::issueFromJson(jv); + return xrpl::issueFromJson(jv); } bool @@ -1521,8 +1519,8 @@ isAdminCmd(std::string const& method, boost::json::object const& request) { if (method == JS(ledger)) { auto const requestStr = boost::json::serialize(request); - Json::Value jv; - Json::Reader{}.parse(requestStr, jv); + json::Value jv; + json::Reader{}.parse(requestStr, jv); // rippled considers string/non-zero int/non-empty array/ non-empty json as true. // Use rippled's API asBool to get the same result. // https://github.com/XRPLF/rippled/issues/5119 @@ -1541,18 +1539,18 @@ isAdminCmd(std::string const& method, boost::json::object const& request) return false; } -std::expected +std::expected getNFTID(boost::json::object const& request) { if (!request.contains(JS(nft_id))) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "missingTokenID"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "missingTokenID"}}; if (!request.at(JS(nft_id)).is_string()) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "tokenIDNotString"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "tokenIDNotString"}}; - ripple::uint256 tokenid; + xrpl::uint256 tokenid; if (!tokenid.parseHex(boost::json::value_to(request.at(JS(nft_id))))) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "malformedTokenID"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "malformedTokenID"}}; return tokenid; } @@ -1562,8 +1560,8 @@ toJsonWithBinaryTx(data::TransactionAndMetadata const& txnPlusMeta, std::uint32_ { boost::json::object obj{}; auto const metaKey = apiVersion > 1 ? JS(meta_blob) : JS(meta); - obj[metaKey] = ripple::strHex(txnPlusMeta.metadata); - obj[JS(tx_blob)] = ripple::strHex(txnPlusMeta.transaction); + obj[metaKey] = xrpl::strHex(txnPlusMeta.metadata); + obj[JS(tx_blob)] = xrpl::strHex(txnPlusMeta.transaction); return obj; } diff --git a/src/rpc/RPCHelpers.hpp b/src/rpc/RPCHelpers.hpp index 5d3f9bb99..9bf25ce59 100644 --- a/src/rpc/RPCHelpers.hpp +++ b/src/rpc/RPCHelpers.hpp @@ -88,12 +88,12 @@ namespace rpc { enum class NFTokenjson { ENABLE, DISABLE }; /** - * @brief Get a ripple::AccountID from its string representation + * @brief Get a xrpl::AccountID from its string representation * * @param account The string representation of the account * @return The account ID or std::nullopt if the string is not a valid account */ -std::optional +std::optional accountFromStringStrict(std::string const& account); /** @@ -104,7 +104,7 @@ accountFromStringStrict(std::string const& account); * @return true if the SLE is owned by the account */ bool -isOwnedByAccount(ripple::SLE const& sle, ripple::AccountID const& accountID); +isOwnedByAccount(xrpl::SLE const& sle, xrpl::AccountID const& accountID); /** * @brief Get the start hint for the account @@ -114,7 +114,7 @@ isOwnedByAccount(ripple::SLE const& sle, ripple::AccountID const& accountID); * @return The start hint */ std::uint64_t -getStartHint(ripple::SLE const& sle, ripple::AccountID const& accountID); +getStartHint(xrpl::SLE const& sle, xrpl::AccountID const& accountID); /** * @brief Parse the account cursor from the JSON @@ -132,7 +132,7 @@ parseAccountCursor(std::optional jsonCursor); * @param blobs The TransactionAndMetadata to deserialize * @return The deserialized objects */ -std::pair, std::shared_ptr> +std::pair, std::shared_ptr> deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs); // TODO this function should probably be in a different file and namespace @@ -143,7 +143,7 @@ deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs); * @param seq The sequence number to set * @return The deserialized objects */ -std::pair, std::shared_ptr> +std::pair, std::shared_ptr> deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs, std::uint32_t seq); /** @@ -194,8 +194,8 @@ insertDeliverMaxAlias(boost::json::object& txJson, std::uint32_t apiVersion); bool insertDeliveredAmount( boost::json::object& metaJson, - std::shared_ptr const& txn, - std::shared_ptr const& meta, + std::shared_ptr const& txn, + std::shared_ptr const& meta, uint32_t date ); @@ -214,9 +214,9 @@ insertDeliveredAmount( bool insertMPTIssuanceID( boost::json::object& txnJson, - std::shared_ptr const& txn, + std::shared_ptr const& txn, boost::json::object& metaJson, - std::shared_ptr const& meta + std::shared_ptr const& meta ); /** @@ -226,7 +226,7 @@ insertMPTIssuanceID( * @return The JSON object */ boost::json::object -toJson(ripple::STBase const& obj); +toJson(xrpl::STBase const& obj); /** * @brief Convert SLE to JSON @@ -235,7 +235,7 @@ toJson(ripple::STBase const& obj); * @return The JSON object */ boost::json::object -toJson(ripple::SLE const& sle); +toJson(xrpl::SLE const& sle); /** * @brief Convert a LedgerHeader to JSON object. @@ -246,7 +246,7 @@ toJson(ripple::SLE const& sle); * @return The JSON object. */ boost::json::object -toJson(ripple::LedgerHeader const& info, bool binary, std::uint32_t apiVersion); +toJson(xrpl::LedgerHeader const& info, bool binary, std::uint32_t apiVersion); /** * @brief Convert a TxMeta to JSON object. @@ -255,9 +255,9 @@ toJson(ripple::LedgerHeader const& info, bool binary, std::uint32_t apiVersion); * @return The JSON object. */ boost::json::object -toJson(ripple::TxMeta const& meta); +toJson(xrpl::TxMeta const& meta); -using RippledJson = Json::Value; +using RippledJson = json::Value; /** * @brief Convert a RippledJson to boost::json::value @@ -279,8 +279,8 @@ toBoostJson(RippledJson const& value); */ boost::json::object generatePubLedgerMessage( - ripple::LedgerHeader const& lgrInfo, - ripple::Fees const& fees, + xrpl::LedgerHeader const& lgrInfo, + xrpl::Fees const& fees, std::string const& ledgerRange, std::uint32_t txnCount ); @@ -292,7 +292,7 @@ generatePubLedgerMessage( * @param ctx The context of the request * @return The ledger info or an error status */ -std::expected +std::expected ledgerHeaderFromRequest(std::shared_ptr const& backend, web::Context const& ctx); /** @@ -305,7 +305,7 @@ ledgerHeaderFromRequest(std::shared_ptr const& bac * @param maxSeq The maximum sequence to search * @return The ledger info or an error status */ -std::expected +std::expected getLedgerHeaderFromHashOrSeq( BackendInterface const& backend, boost::asio::yield_context yield, @@ -330,13 +330,13 @@ getLedgerHeaderFromHashOrSeq( std::expected traverseOwnedNodes( BackendInterface const& backend, - ripple::Keylet const& owner, - ripple::uint256 const& hexMarker, + xrpl::Keylet const& owner, + xrpl::uint256 const& hexMarker, std::uint32_t startHint, std::uint32_t sequence, std::uint32_t limit, boost::asio::yield_context yield, - std::function atOwnedNode + std::function atOwnedNode ); /** @@ -357,12 +357,12 @@ traverseOwnedNodes( std::expected traverseOwnedNodes( BackendInterface const& backend, - ripple::AccountID const& accountID, + xrpl::AccountID const& accountID, std::uint32_t sequence, std::uint32_t limit, std::optional jsonCursor, boost::asio::yield_context yield, - std::function atOwnedNode, + std::function atOwnedNode, bool nftIncluded = false ); @@ -375,11 +375,11 @@ traverseOwnedNodes( * @param context The context of the request * @return The SLE or nullptr if not found */ -std::shared_ptr +std::shared_ptr read( std::shared_ptr const& backend, - ripple::Keylet const& keylet, - ripple::LedgerHeader const& lgrInfo, + xrpl::Keylet const& keylet, + xrpl::LedgerHeader const& lgrInfo, web::Context const& context ); @@ -389,7 +389,7 @@ read( * @param transaction The transaction * @return A vector of accounts associated with the transaction */ -std::vector +std::vector getAccountsFromTransaction(boost::json::object const& transaction); /** @@ -400,7 +400,7 @@ getAccountsFromTransaction(boost::json::object const& transaction); * @return The blob */ std::vector -ledgerHeaderToBlob(ripple::LedgerHeader const& info, bool includeHash = false); +ledgerHeaderToBlob(xrpl::LedgerHeader const& info, bool includeHash = false); /** * @brief Whether global frozen is set @@ -415,7 +415,7 @@ bool isGlobalFrozen( BackendInterface const& backend, std::uint32_t seq, - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ); @@ -434,9 +434,9 @@ bool isFrozen( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ); @@ -454,7 +454,7 @@ bool fetchAndCheckAnyFlagsExists( BackendInterface const& backend, std::uint32_t sequence, - ripple::Keylet const& keylet, + xrpl::Keylet const& keylet, std::vector const& flags, boost::asio::yield_context yield ); @@ -477,9 +477,9 @@ bool isDeepFrozen( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ); @@ -498,9 +498,9 @@ bool isLPTokenFrozen( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Issue const& asset, - ripple::Issue const& asset2, + xrpl::AccountID const& account, + xrpl::Issue const& asset, + xrpl::Issue const& asset2, boost::asio::yield_context yield ); @@ -515,13 +515,13 @@ isLPTokenFrozen( * @param yield The coroutine context * @return The account funds */ -ripple::STAmount +xrpl::STAmount accountFunds( BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t sequence, - ripple::STAmount const& amount, - ripple::AccountID const& id, + xrpl::STAmount const& amount, + xrpl::AccountID const& id, boost::asio::yield_context yield ); @@ -538,14 +538,14 @@ accountFunds( * @param yield The coroutine context * @return The amount account holds */ -ripple::STAmount +xrpl::STAmount accountHolds( BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, bool zeroIfFrozen, boost::asio::yield_context yield ); @@ -562,13 +562,13 @@ accountHolds( * @param yield The coroutine context * @return The amount account holds */ -ripple::STAmount +xrpl::STAmount ammAccountHolds( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& account, - ripple::Currency const& currency, - ripple::AccountID const& issuer, + xrpl::AccountID const& account, + xrpl::Currency const& currency, + xrpl::AccountID const& issuer, bool const zeroIfFrozen, boost::asio::yield_context yield ); @@ -582,11 +582,11 @@ ammAccountHolds( * @param yield The coroutine context * @return The transfer rate */ -ripple::Rate +xrpl::Rate transferRate( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ); @@ -599,11 +599,11 @@ transferRate( * @param yield The coroutine context * @return The XRP liquidity */ -ripple::XRPAmount +xrpl::XRPAmount xrpLiquid( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& id, + xrpl::AccountID const& id, boost::asio::yield_context yield ); @@ -622,8 +622,8 @@ xrpLiquid( boost::json::array postProcessOrderBook( std::vector const& offers, - ripple::Book const& book, - ripple::AccountID const& takerID, + xrpl::Book const& book, + xrpl::AccountID const& takerID, data::BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t ledgerSequence, @@ -640,12 +640,12 @@ postProcessOrderBook( * @param domain The domain * @return The book or an error status */ -std::expected +std::expected parseBook( - ripple::Currency pays, - ripple::AccountID payIssuer, - ripple::Currency gets, - ripple::AccountID getIssuer, + xrpl::Currency pays, + xrpl::AccountID payIssuer, + xrpl::Currency gets, + xrpl::AccountID getIssuer, std::optional const& domain ); @@ -655,7 +655,7 @@ parseBook( * @param request The request * @return The book or an error status */ -std::expected +std::expected parseBook(boost::json::object const& request); /** @@ -664,17 +664,17 @@ parseBook(boost::json::object const& request); * @param taker The taker as json * @return The taker account or an error status */ -std::expected +std::expected parseTaker(boost::json::value const& taker); /** - * @brief Parse the json object into a ripple::Issue object. + * @brief Parse the json object into a xrpl::Issue object. * @param issue The json object to parse. The accepted format is { "currency" : "USD", "issuer" : * "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59" } or {"currency" : "XRP"} - * @return The ripple::Issue object. - * @exception raise Json::error exception if the json object is not in the accepted format. + * @return The xrpl::Issue object. + * @exception raise json::error exception if the json object is not in the accepted format. */ -ripple::Issue +xrpl::Issue parseIssue(boost::json::object const& issue); /** @@ -701,7 +701,7 @@ isAdminCmd(std::string const& method, boost::json::object const& request); * @param request The request * @return The NFTID or an error status */ -std::expected +std::expected getNFTID(boost::json::object const& request); /** @@ -796,7 +796,7 @@ logDuration(boost::json::object const& request, util::BaseTagDecorator const& ta * @param value JSON value to parse from * @return The parsed seed if successful; std::nullopt otherwise */ -std::optional +std::optional parseRippleLibSeed(boost::json::value const& value); /** @@ -815,11 +815,11 @@ std::expected traverseNFTObjects( BackendInterface const& backend, std::uint32_t sequence, - ripple::AccountID const& accountID, - ripple::uint256 nextPage, + xrpl::AccountID const& accountID, + xrpl::uint256 nextPage, std::uint32_t limit, boost::asio::yield_context yield, - std::function atOwnedNode + std::function atOwnedNode ); /** @@ -839,10 +839,7 @@ parseStringAsUInt(std::string const& value); // TODO: move to string utils or s * @return true if the transaction can have a delivered amount */ bool -canHaveDeliveredAmount( - std::shared_ptr const& txn, - std::shared_ptr const& meta -); +canHaveDeliveredAmount(std::shared_ptr const& txn, std::shared_ptr const& meta); /** * @brief Get the delivered amount @@ -853,10 +850,10 @@ canHaveDeliveredAmount( * @param date The date of the ledger * @return The delivered amount or std::nullopt if not available */ -std::optional +std::optional getDeliveredAmount( - std::shared_ptr const& txn, - std::shared_ptr const& meta, + std::shared_ptr const& txn, + std::shared_ptr const& meta, std::uint32_t ledgerSequence, uint32_t date ); diff --git a/src/rpc/common/MetaProcessors.cpp b/src/rpc/common/MetaProcessors.cpp index 8eaf3a8c6..5122cf56b 100644 --- a/src/rpc/common/MetaProcessors.cpp +++ b/src/rpc/common/MetaProcessors.cpp @@ -55,11 +55,11 @@ ValidateArrayAt::verify(boost::json::value& value, std::string_view key) const return {}; // ignore. field does not exist, let 'required' fail instead if (not value.as_object().at(key).is_array()) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; auto& arr = value.as_object().at(key).as_array(); if (idx_ >= arr.size()) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; auto& res = arr.at(idx_); for (auto const& spec : specs_) { diff --git a/src/rpc/common/Modifiers.hpp b/src/rpc/common/Modifiers.hpp index 35a6b0d3f..c211b00fc 100644 --- a/src/rpc/common/Modifiers.hpp +++ b/src/rpc/common/Modifiers.hpp @@ -128,12 +128,12 @@ struct ToNumber final { auto const strInt = boost::json::value_to(value.as_object().at(key)); if (strInt.find('.') != std::string::npos) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; // maybe a float + return Error{Status{RippledError::RpcInvalidParams}}; // maybe a float try { value.as_object()[key] = std::stoi(strInt); } catch (std::exception& e) { - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; } return {}; } diff --git a/src/rpc/common/Types.hpp b/src/rpc/common/Types.hpp index 85beda00b..ee73919f3 100644 --- a/src/rpc/common/Types.hpp +++ b/src/rpc/common/Types.hpp @@ -168,7 +168,7 @@ struct Result { * @brief A cursor object used to traverse nodes owned by an account. */ struct AccountCursor { - ripple::uint256 index; + xrpl::uint256 index; std::uint32_t hint{}; /** @@ -179,7 +179,7 @@ struct AccountCursor { std::string toString() const { - return ripple::strHex(index) + "," + std::to_string(hint); + return xrpl::strHex(index) + "," + std::to_string(hint); } /** diff --git a/src/rpc/common/Validators.cpp b/src/rpc/common/Validators.cpp index cb458252c..ef9b60f34 100644 --- a/src/rpc/common/Validators.cpp +++ b/src/rpc/common/Validators.cpp @@ -52,7 +52,7 @@ namespace rpc::validation { Required::verify(boost::json::value const& value, std::string_view key) { if (not value.is_object() or not value.as_object().contains(key)) - return Error{Status{RippledError::rpcINVALID_PARAMS, "Required field '" + std::string{key} + "' missing"}}; + return Error{Status{RippledError::RpcInvalidParams, "Required field '" + std::string{key} + "' missing"}}; return {}; } @@ -66,11 +66,11 @@ TimeFormatValidator::verify(boost::json::value const& value, std::string_view ke return {}; // ignore. field does not exist, let 'required' fail instead if (not value.as_object().at(key).is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; auto const ret = util::systemTpFromUtcStr(value_to(value.as_object().at(key)), format_); if (!ret) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; return {}; } @@ -95,22 +95,22 @@ checkIsU32Numeric(std::string_view sv) CustomValidator CustomValidators::uint160HexStringValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { - return makeHexStringValidator(value, key); + return makeHexStringValidator(value, key); }}; CustomValidator CustomValidators::uint192HexStringValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { - return makeHexStringValidator(value, key); + return makeHexStringValidator(value, key); }}; CustomValidator CustomValidators::uint256HexStringValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { - return makeHexStringValidator(value, key); + return makeHexStringValidator(value, key); }}; CustomValidator CustomValidators::ledgerIndexValidator = CustomValidator{[](boost::json::value const& value, std::string_view /* key */) -> MaybeError { - auto err = Error{Status{RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"}}; + auto err = Error{Status{RippledError::RpcInvalidParams, "ledgerIndexMalformed"}}; if (!value.is_string() && !(value.is_uint64() || value.is_int64())) return err; @@ -125,11 +125,11 @@ CustomValidator CustomValidators::ledgerIndexValidator = CustomValidator CustomValidators::ledgerTypeValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}', not string.", key)}}; + return Error{Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', not string.", key)}}; auto const type = util::LedgerTypes::getLedgerEntryTypeFromStr(boost::json::value_to(value)); - if (type == ripple::ltANY) - return Error{Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}'.", key)}}; + if (type == xrpl::ltANY) + return Error{Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}'.", key)}}; return MaybeError{}; }}; @@ -137,12 +137,12 @@ CustomValidator CustomValidators::ledgerTypeValidator = CustomValidator CustomValidators::accountValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotString"}}; // TODO: we are using accountFromStringStrict from RPCHelpers, after we // remove all old handler, this function can be moved to here if (!accountFromStringStrict(boost::json::value_to(value))) - return Error{Status{RippledError::rpcACT_MALFORMED, std::string(key) + "Malformed"}}; + return Error{Status{RippledError::RpcActMalformed, std::string(key) + "Malformed"}}; return MaybeError{}; }}; @@ -150,9 +150,9 @@ CustomValidator CustomValidators::accountValidator = CustomValidator CustomValidators::accountBase58Validator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotString"}}; - auto const account = util::parseBase58Wrapper(boost::json::value_to(value)); + auto const account = util::parseBase58Wrapper(boost::json::value_to(value)); if (!account || account->isZero()) return Error{Status{ClioError::RpcMalformedAddress}}; @@ -162,13 +162,13 @@ CustomValidator CustomValidators::accountBase58Validator = CustomValidator CustomValidators::accountMarkerValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotString"}}; // TODO: we are using parseAccountCursor from RPCHelpers, after we // remove all old handler, this function can be moved to here if (!parseAccountCursor(boost::json::value_to(value))) { // align with the current error message - return Error{Status{RippledError::rpcINVALID_PARAMS, "Malformed cursor."}}; + return Error{Status{RippledError::RpcInvalidParams, "Malformed cursor."}}; } return MaybeError{}; @@ -177,12 +177,12 @@ CustomValidator CustomValidators::accountMarkerValidator = CustomValidator CustomValidators::accountTypeValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}', not string.", key)}}; + return Error{Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', not string.", key)}}; auto const type = util::LedgerTypes::getAccountOwnedLedgerTypeFromStr(boost::json::value_to(value)); - if (type == ripple::ltANY) - return Error{Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}'.", key)}}; + if (type == xrpl::ltANY) + return Error{Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}'.", key)}}; return MaybeError{}; }}; @@ -190,14 +190,14 @@ CustomValidator CustomValidators::accountTypeValidator = CustomValidator CustomValidators::currencyValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotString"}}; auto const currencyStr = boost::json::value_to(value); if (currencyStr.empty()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "IsEmpty"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "IsEmpty"}}; - ripple::Currency currency; - if (!ripple::to_currency(currency, currencyStr)) + xrpl::Currency currency; + if (!xrpl::toCurrency(currency, currencyStr)) return Error{Status{ClioError::RpcMalformedCurrency, "malformedCurrency"}}; return MaybeError{}; @@ -206,17 +206,17 @@ CustomValidator CustomValidators::currencyValidator = CustomValidator CustomValidators::issuerValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotString"}}; - ripple::AccountID issuer; + xrpl::AccountID issuer; // TODO: need to align with the error - if (!ripple::to_issuer(issuer, boost::json::value_to(value))) - return Error{Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}', bad issuer.", key)}}; + if (!xrpl::toIssuer(issuer, boost::json::value_to(value))) + return Error{Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', bad issuer.", key)}}; - if (issuer == ripple::noAccount()) { + if (issuer == xrpl::noAccount()) { return Error{ - Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}', bad issuer account one.", key)} + Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', bad issuer account one.", key)} }; } @@ -226,7 +226,7 @@ CustomValidator CustomValidators::issuerValidator = CustomValidator CustomValidators::subscribeStreamValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_array()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotArray"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotArray"}}; static std::unordered_set const kVALID_STREAMS = { "ledger", "transactions", "transactions_proposed", "book_changes", "manifests", "validations" @@ -235,13 +235,13 @@ CustomValidator CustomValidators::subscribeStreamValidator = static std::unordered_set const kNOT_SUPPORT_STREAMS = {"peer_status", "consensus", "server"}; for (auto const& v : value.as_array()) { if (!v.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, "streamNotString"}}; + return Error{Status{RippledError::RpcInvalidParams, "streamNotString"}}; if (kNOT_SUPPORT_STREAMS.contains(boost::json::value_to(v))) - return Error{Status{RippledError::rpcNOT_SUPPORTED}}; + return Error{Status{RippledError::RpcNotSupported}}; if (not kVALID_STREAMS.contains(boost::json::value_to(v))) - return Error{Status{RippledError::rpcSTREAM_MALFORMED}}; + return Error{Status{RippledError::RpcStreamMalformed}}; } return MaybeError{}; @@ -250,10 +250,10 @@ CustomValidator CustomValidators::subscribeStreamValidator = CustomValidator CustomValidators::subscribeAccountsValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_array()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotArray"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotArray"}}; if (value.as_array().empty()) - return Error{Status{RippledError::rpcACT_MALFORMED, std::string(key) + " malformed."}}; + return Error{Status{RippledError::RpcActMalformed, std::string(key) + " malformed."}}; for (auto const& v : value.as_array()) { auto obj = boost::json::object(); @@ -271,7 +271,7 @@ CustomValidator CustomValidators::subscribeAccountsValidator = CustomValidator CustomValidators::currencyIssueValidator = CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (not value.is_object()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotObject"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotObject"}}; try { parseIssue(value.as_object()); @@ -287,14 +287,14 @@ CustomValidator CustomValidators::credentialTypeValidator = if (not value.is_string()) return Error{Status{ClioError::RpcMalformedAuthorizedCredentials, std::string(key) + " NotString"}}; - auto const& credTypeHex = ripple::strViewUnHex(value.as_string()); + auto const& credTypeHex = xrpl::strViewUnHex(value.as_string()); if (!credTypeHex.has_value()) return Error{Status{ClioError::RpcMalformedAuthorizedCredentials, std::string(key) + " NotHexString"}}; if (credTypeHex->empty()) return Error{Status{ClioError::RpcMalformedAuthorizedCredentials, std::string(key) + " is empty"}}; - if (credTypeHex->size() > ripple::maxCredentialTypeLength) { + if (credTypeHex->size() > xrpl::kMaxCredentialTypeLength) { return Error{ Status{ClioError::RpcMalformedAuthorizedCredentials, std::string(key) + " greater than max length"} }; @@ -316,11 +316,11 @@ CustomValidator CustomValidators::authorizeCredentialValidator = }}; } - if (authCred.size() > ripple::maxCredentialsArraySize) { + if (authCred.size() > xrpl::kMaxCredentialsArraySize) { return Error{Status{ ClioError::RpcMalformedAuthorizedCredentials, fmt::format( - "Max {} number of credentials in authorized_credentials array", ripple::maxCredentialsArraySize + "Max {} number of credentials in authorized_credentials array", xrpl::kMaxCredentialsArraySize ) }}; } diff --git a/src/rpc/common/Validators.hpp b/src/rpc/common/Validators.hpp index 633a6f6c9..bdd7bea1c 100644 --- a/src/rpc/common/Validators.hpp +++ b/src/rpc/common/Validators.hpp @@ -87,7 +87,7 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcNOT_SUPPORTED` if the value matched; otherwise no error is returned + * @return `RippledError::RpcNotSupported` if the value matched; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value const& value, std::string_view key) const @@ -97,7 +97,7 @@ public: auto const res = value_to(value.as_object().at(key)); if (value_ == res) { return Error{Status{ - RippledError::rpcNOT_SUPPORTED, + RippledError::RpcNotSupported, fmt::format("Not supported field '{}'s value '{}'", std::string{key}, res) }}; } @@ -117,13 +117,13 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcNOT_SUPPORTED` if the field is found; otherwise no error is returned + * @return `RippledError::RpcNotSupported` if the field is found; otherwise no error is returned */ [[nodiscard]] static MaybeError verify(boost::json::value const& value, std::string_view key) { if (value.is_object() and value.as_object().contains(key)) - return Error{Status{RippledError::rpcNOT_SUPPORTED, "Not supported field '" + std::string{key} + '\''}}; + return Error{Status{RippledError::RpcNotSupported, "Not supported field '" + std::string{key} + '\''}}; return {}; } @@ -147,7 +147,7 @@ struct Type final { * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value& value, std::string_view key) const @@ -159,7 +159,7 @@ struct Type final { auto const convertible = (checkTypeAndClamp(res) || ...); if (not convertible) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; return {}; } @@ -189,7 +189,7 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value const& value, std::string_view key) const @@ -204,7 +204,7 @@ public: // TODO: may want a way to make this code more generic (e.g. use a free // function that can be overridden for this comparison) if (res < min_ || res > max_) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; return {}; } @@ -232,7 +232,7 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value const& value, std::string_view key) const @@ -245,7 +245,7 @@ public: auto const res = value_to(value.as_object().at(key)); if (res < min_) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; return {}; } @@ -273,7 +273,7 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value const& value, std::string_view key) const @@ -286,7 +286,7 @@ public: auto const res = value_to(value.as_object().at(key)); if (res > max_) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; return {}; } @@ -313,7 +313,7 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value const& value, std::string_view key) const; @@ -341,7 +341,7 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value const& value, std::string_view key) const @@ -353,7 +353,7 @@ public: auto const res = value_to(value.as_object().at(key)); if (res != original_) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; return {}; } @@ -396,7 +396,7 @@ public: * * @param value The JSON value representing the outer object * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] MaybeError verify(boost::json::value const& value, std::string_view key) const @@ -408,7 +408,7 @@ public: auto const res = value_to(value.as_object().at(key)); if (std::find(std::begin(options_), std::end(options_), res) == std::end(options_)) - return Error{Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}'.", key)}}; + return Error{Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}'.", key)}}; return {}; } @@ -460,18 +460,18 @@ checkIsU32Numeric(std::string_view sv); template requires( - std::is_same_v || std::is_same_v || - std::is_same_v + std::is_same_v || std::is_same_v || + std::is_same_v ) MaybeError makeHexStringValidator(boost::json::value const& value, std::string_view key) { if (!value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotString"}}; HexType parsedInt; if (!parsedInt.parseHex(value.as_string().c_str())) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "Malformed"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "Malformed"}}; return MaybeError{}; } @@ -573,7 +573,7 @@ struct CustomValidators final { static CustomValidator subscribeAccountsValidator; /** - * @brief Validates an asset (ripple::Issue). + * @brief Validates an asset (xrpl::Issue). * * Used by amm_info. */ @@ -604,7 +604,7 @@ struct Hex256ItemType final { * * @param value the value to verify * @param key The key used to retrieve the tested value from the outer object - * @return `RippledError::rpcINVALID_PARAMS` if validation failed; otherwise no error is returned + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is returned */ [[nodiscard]] static MaybeError verify(boost::json::value const& value, std::string_view key) @@ -616,9 +616,9 @@ struct Hex256ItemType final { // loop through each item in the array and make sure it is uint256 hex string for (auto const& elem : res.as_array()) { - ripple::uint256 num; + xrpl::uint256 num; if (!elem.is_string() || !num.parseHex(elem.as_string())) { - return Error{Status{RippledError::rpcINVALID_PARAMS, "Item is not a valid uint256 type."}}; + return Error{Status{RippledError::RpcInvalidParams, "Item is not a valid uint256 type."}}; } } return {}; diff --git a/src/rpc/handlers/AMMInfo.cpp b/src/rpc/handlers/AMMInfo.cpp index d2af7498d..587c625bf 100644 --- a/src/rpc/handlers/AMMInfo.cpp +++ b/src/rpc/handlers/AMMInfo.cpp @@ -62,7 +62,7 @@ namespace { std::string -toIso8601(ripple::NetClock::time_point tp) +toIso8601(xrpl::NetClock::time_point tp) { using namespace std::chrono; static constexpr auto kRIPPLE_EPOCH_OFFSET = seconds{kRIPPLE_EPOCH_START}; @@ -80,19 +80,19 @@ namespace rpc { AMMInfoHandler::Result AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) const { - using namespace ripple; + using namespace xrpl; auto const hasInvalidParams = [&input] { // no asset/asset2 can be specified if amm account is specified if (input.ammAccount) - return input.issue1 != ripple::noIssue() || input.issue2 != ripple::noIssue(); + return input.issue1 != xrpl::noIssue() || input.issue2 != xrpl::noIssue(); // both assets must be specified when amm account is not specified - return input.issue1 == ripple::noIssue() || input.issue2 == ripple::noIssue(); + return input.issue1 == xrpl::noIssue() || input.issue2 == xrpl::noIssue(); }(); if (hasInvalidParams) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; auto const range = sharedPtrBackend_->fetchLedgerRange(); ASSERT(range.has_value(), "AMMInfo's ledger range must be available"); @@ -109,22 +109,22 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) if (input.accountID) { auto keylet = keylet::account(*input.accountID); if (not sharedPtrBackend_->fetchLedgerObject(keylet.key, lgrInfo.seq, ctx.yield)) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; } - ripple::uint256 ammID; + xrpl::uint256 ammID; if (input.ammAccount) { auto const accountKeylet = keylet::account(*input.ammAccount); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject(accountKeylet.key, lgrInfo.seq, ctx.yield); if (not accountLedgerObject) - return Error{Status{RippledError::rpcACT_MALFORMED}}; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{accountLedgerObject->data(), accountLedgerObject->size()}, accountKeylet.key + return Error{Status{RippledError::RpcActMalformed}}; + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{accountLedgerObject->data(), accountLedgerObject->size()}, accountKeylet.key }; - if (not sle.isFieldPresent(ripple::sfAMMID)) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; - ammID = sle.getFieldH256(ripple::sfAMMID); + if (not sle.isFieldPresent(xrpl::sfAMMID)) + return Error{Status{RippledError::RpcActNotFound}}; + ammID = sle.getFieldH256(xrpl::sfAMMID); } auto issue1 = input.issue1; @@ -133,18 +133,18 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) auto const ammBlob = sharedPtrBackend_->fetchLedgerObject(ammKeylet.key, lgrInfo.seq, ctx.yield); if (not ammBlob) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; auto const amm = SLE{SerialIter{ammBlob->data(), ammBlob->size()}, ammKeylet.key}; auto const ammAccountID = amm.getAccountID(sfAccount); auto const accBlob = sharedPtrBackend_->fetchLedgerObject(keylet::account(ammAccountID).key, lgrInfo.seq, ctx.yield); if (not accBlob) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; // If the issue1 and issue2 are not specified, we need to get them from the AMM. // Otherwise we preserve the mapping of asset1 -> issue1 and asset2 -> issue2 as requested by the user. - if (issue1 == ripple::noIssue() and issue2 == ripple::noIssue()) { + if (issue1 == xrpl::noIssue() and issue2 == xrpl::noIssue()) { issue1 = amm[sfAsset].get(); issue2 = amm[sfAsset2].get(); } @@ -158,10 +158,10 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) Output response; response.ledgerIndex = lgrInfo.seq; - response.ledgerHash = ripple::strHex(lgrInfo.hash); - response.amount1 = toBoostJson(asset1Balance.getJson(JsonOptions::none)); - response.amount2 = toBoostJson(asset2Balance.getJson(JsonOptions::none)); - response.lpToken = toBoostJson(lptAMMBalance.getJson(JsonOptions::none)); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); + response.amount1 = toBoostJson(asset1Balance.getJson(JsonOptions::Values::None)); + response.amount2 = toBoostJson(asset2Balance.getJson(JsonOptions::Values::None)); + response.lpToken = toBoostJson(lptAMMBalance.getJson(JsonOptions::Values::None)); response.tradingFee = amm[sfTradingFee]; response.ammAccount = to_string(ammAccountID); @@ -182,8 +182,8 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) boost::json::object auction; auto const timeSlot = ammAuctionTimeSlot(lgrInfo.parentCloseTime.time_since_epoch().count(), auctionSlot); - auction[JS(time_interval)] = timeSlot ? *timeSlot : AUCTION_SLOT_TIME_INTERVALS; - auction[JS(price)] = toBoostJson(auctionSlot[sfPrice].getJson(JsonOptions::none)); + auction[JS(time_interval)] = timeSlot ? *timeSlot : xrpl::kAuctionSlotTimeIntervals; + auction[JS(price)] = toBoostJson(auctionSlot[sfPrice].getJson(JsonOptions::Values::None)); auction[JS(discounted_fee)] = auctionSlot[sfDiscountedFee]; auction[JS(account)] = to_string(auctionSlot.getAccountID(sfAccount)); auction[JS(expiration)] = toIso8601(NetClock::time_point{NetClock::duration{auctionSlot[sfExpiration]}}); @@ -233,12 +233,12 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) static auto const kSTRING_ISSUE_VALIDATOR = validation::CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (not value.is_string()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotString"}}; try { - ripple::issueFromJson(boost::json::value_to(value)); + xrpl::issueFromJson(boost::json::value_to(value)); } catch (std::runtime_error const&) { - return Error{Status{RippledError::rpcISSUE_MALFORMED}}; + return Error{Status{RippledError::RpcIssueMalformed}}; } return MaybeError{}; @@ -249,28 +249,28 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, {JS(asset), meta::WithCustomError{ - validation::Type{}, Status(RippledError::rpcISSUE_MALFORMED) + validation::Type{}, Status(RippledError::RpcIssueMalformed) }, meta::IfType{kSTRING_ISSUE_VALIDATOR}, meta::IfType{ meta::WithCustomError{ - validation::CustomValidators::currencyIssueValidator, Status(RippledError::rpcISSUE_MALFORMED) + validation::CustomValidators::currencyIssueValidator, Status(RippledError::RpcIssueMalformed) }, }}, {JS(asset2), meta::WithCustomError{ - validation::Type{}, Status(RippledError::rpcISSUE_MALFORMED) + validation::Type{}, Status(RippledError::RpcIssueMalformed) }, meta::IfType{kSTRING_ISSUE_VALIDATOR}, meta::IfType{ meta::WithCustomError{ - validation::CustomValidators::currencyIssueValidator, Status(RippledError::rpcISSUE_MALFORMED) + validation::CustomValidators::currencyIssueValidator, Status(RippledError::RpcIssueMalformed) }, }}, {JS(amm_account), - meta::WithCustomError{validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED)}}, + meta::WithCustomError{validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed)}}, {JS(account), - meta::WithCustomError{validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED)}}, + meta::WithCustomError{validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed)}}, }; return kRPC_SPEC; diff --git a/src/rpc/handlers/AMMInfo.hpp b/src/rpc/handlers/AMMInfo.hpp index 28f0524a6..e21ace7c3 100644 --- a/src/rpc/handlers/AMMInfo.hpp +++ b/src/rpc/handlers/AMMInfo.hpp @@ -70,10 +70,10 @@ public: * @brief A struct to hold the input data for the command */ struct Input { - std::optional accountID; - std::optional ammAccount; - ripple::Issue issue1 = ripple::noIssue(); - ripple::Issue issue2 = ripple::noIssue(); + std::optional accountID; + std::optional ammAccount; + xrpl::Issue issue1 = xrpl::noIssue(); + xrpl::Issue issue2 = xrpl::noIssue(); std::optional ledgerHash; std::optional ledgerIndex; }; diff --git a/src/rpc/handlers/AccountChannels.cpp b/src/rpc/handlers/AccountChannels.cpp index 1fb38b4b0..fdf091dfc 100644 --- a/src/rpc/handlers/AccountChannels.cpp +++ b/src/rpc/handlers/AccountChannels.cpp @@ -51,32 +51,32 @@ namespace rpc { void -AccountChannelsHandler::addChannel(std::vector& jsonChannels, ripple::SLE const& channelSle) +AccountChannelsHandler::addChannel(std::vector& jsonChannels, xrpl::SLE const& channelSle) { ChannelResponse channel; - channel.channelID = ripple::to_string(channelSle.key()); - channel.account = ripple::to_string(channelSle.getAccountID(ripple::sfAccount)); - channel.accountDestination = ripple::to_string(channelSle.getAccountID(ripple::sfDestination)); - channel.amount = channelSle[ripple::sfAmount].getText(); - channel.balance = channelSle[ripple::sfBalance].getText(); - channel.settleDelay = channelSle[ripple::sfSettleDelay]; + channel.channelID = xrpl::to_string(channelSle.key()); + channel.account = xrpl::to_string(channelSle.getAccountID(xrpl::sfAccount)); + channel.accountDestination = xrpl::to_string(channelSle.getAccountID(xrpl::sfDestination)); + channel.amount = channelSle[xrpl::sfAmount].getText(); + channel.balance = channelSle[xrpl::sfBalance].getText(); + channel.settleDelay = channelSle[xrpl::sfSettleDelay]; - if (publicKeyType(channelSle[ripple::sfPublicKey])) { - ripple::PublicKey const pk(channelSle[ripple::sfPublicKey]); - channel.publicKey = toBase58(ripple::TokenType::AccountPublic, pk); + if (publicKeyType(channelSle[xrpl::sfPublicKey])) { + xrpl::PublicKey const pk(channelSle[xrpl::sfPublicKey]); + channel.publicKey = toBase58(xrpl::TokenType::AccountPublic, pk); channel.publicKeyHex = strHex(pk); } - if (auto const& v = channelSle[~ripple::sfExpiration]) + if (auto const& v = channelSle[~xrpl::sfExpiration]) channel.expiration = v; - if (auto const& v = channelSle[~ripple::sfCancelAfter]) + if (auto const& v = channelSle[~xrpl::sfCancelAfter]) channel.cancelAfter = v; - if (auto const& v = channelSle[~ripple::sfSourceTag]) + if (auto const& v = channelSle[~xrpl::sfSourceTag]) channel.sourceTag = v; - if (auto const& v = channelSle[~ripple::sfDestinationTag]) + if (auto const& v = channelSle[~xrpl::sfDestinationTag]) channel.destinationTag = v; jsonChannels.push_back(channel); @@ -97,18 +97,18 @@ AccountChannelsHandler::process(AccountChannelsHandler::Input const& input, Cont auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; auto const destAccountID = input.destinationAccount ? accountFromStringStrict(input.destinationAccount.value()) - : std::optional{}; + : std::optional{}; Output response; - auto const addToResponse = [&](ripple::SLE const sle) { - if (sle.getType() == ripple::ltPAYCHAN && sle.getAccountID(ripple::sfAccount) == accountID && - (!destAccountID || *destAccountID == sle.getAccountID(ripple::sfDestination))) { + auto const addToResponse = [&](xrpl::SLE const sle) { + if (sle.getType() == xrpl::ltPAYCHAN && sle.getAccountID(xrpl::sfAccount) == accountID && + (!destAccountID || *destAccountID == sle.getAccountID(xrpl::sfDestination))) { addChannel(response.channels, sle); } @@ -124,7 +124,7 @@ AccountChannelsHandler::process(AccountChannelsHandler::Input const& input, Cont response.account = input.account; response.limit = input.limit; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; auto const nextMarker = expectedNext.value(); diff --git a/src/rpc/handlers/AccountChannels.hpp b/src/rpc/handlers/AccountChannels.hpp index 2168882a6..2e1424784 100644 --- a/src/rpc/handlers/AccountChannels.hpp +++ b/src/rpc/handlers/AccountChannels.hpp @@ -149,7 +149,7 @@ public: private: static void - addChannel(std::vector& jsonChannels, ripple::SLE const& channelSle); + addChannel(std::vector& jsonChannels, xrpl::SLE const& channelSle); /** * @brief Convert the Output to a JSON object diff --git a/src/rpc/handlers/AccountCurrencies.cpp b/src/rpc/handlers/AccountCurrencies.cpp index d23fbe688..e70f9103d 100644 --- a/src/rpc/handlers/AccountCurrencies.cpp +++ b/src/rpc/handlers/AccountCurrencies.cpp @@ -31,6 +31,7 @@ #include #include #include +#include #include #include #include @@ -59,16 +60,16 @@ AccountCurrenciesHandler::process(AccountCurrenciesHandler::Input const& input, auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; Output response; - auto const addToResponse = [&](ripple::SLE const sle) { - if (sle.getType() == ripple::ltRIPPLE_STATE) { - auto balance = sle.getFieldAmount(ripple::sfBalance); - auto const lowLimit = sle.getFieldAmount(ripple::sfLowLimit); - auto const highLimit = sle.getFieldAmount(ripple::sfHighLimit); + auto const addToResponse = [&](xrpl::SLE const sle) { + if (sle.getType() == xrpl::ltRIPPLE_STATE) { + auto balance = sle.getFieldAmount(xrpl::sfBalance); + auto const lowLimit = sle.getFieldAmount(xrpl::sfLowLimit); + auto const highLimit = sle.getFieldAmount(xrpl::sfHighLimit); bool const viewLowest = (lowLimit.getIssuer() == accountID); auto const lineLimit = viewLowest ? lowLimit : highLimit; auto const lineLimitPeer = !viewLowest ? lowLimit : highLimit; @@ -77,10 +78,10 @@ AccountCurrenciesHandler::process(AccountCurrenciesHandler::Input const& input, balance.negate(); if (balance < lineLimit) - response.receiveCurrencies.insert(ripple::to_string(balance.getCurrency())); + response.receiveCurrencies.insert(xrpl::to_string(balance.get().currency)); if ((-balance) < lineLimitPeer) - response.sendCurrencies.insert(ripple::to_string(balance.getCurrency())); + response.sendCurrencies.insert(xrpl::to_string(balance.get().currency)); } return true; @@ -97,7 +98,7 @@ AccountCurrenciesHandler::process(AccountCurrenciesHandler::Input const& input, addToResponse ); - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; return response; diff --git a/src/rpc/handlers/AccountInfo.cpp b/src/rpc/handlers/AccountInfo.cpp index 8631b5632..214de6d66 100644 --- a/src/rpc/handlers/AccountInfo.cpp +++ b/src/rpc/handlers/AccountInfo.cpp @@ -57,7 +57,7 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons using namespace data; if (!input.account && !input.ident) - return Error{Status{RippledError::rpcINVALID_PARAMS, ripple::RPC::missing_field_message(JS(account))}}; + return Error{Status{RippledError::RpcInvalidParams, xrpl::RPC::missingFieldMessage(JS(account))}}; auto const range = sharedPtrBackend_->fetchLedgerRange(); ASSERT(range.has_value(), "AccountInfo's ledger range must be available"); @@ -71,18 +71,18 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons auto const& lgrInfo = expectedLgrInfo.value(); auto const accountStr = input.account.value_or(input.ident.value_or("")); auto const accountID = accountFromStringStrict(accountStr); - auto const accountKeylet = ripple::keylet::account(*accountID); + auto const accountKeylet = xrpl::keylet::account(*accountID); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject(accountKeylet.key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{accountLedgerObject->data(), accountLedgerObject->size()}, accountKeylet.key + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{accountLedgerObject->data(), accountLedgerObject->size()}, accountKeylet.key }; if (!accountKeylet.check(sle)) - return Error{Status{RippledError::rpcDB_DESERIALIZATION}}; + return Error{Status{RippledError::RpcDbDeserialization}}; auto isEnabled = [this, &ctx, seq = lgrInfo.seq](auto key) { return amendmentCenter_->isEnabled(ctx.yield, key, seq); @@ -94,7 +94,7 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons Output out{ .ledgerIndex = lgrInfo.seq, - .ledgerHash = ripple::strHex(lgrInfo.hash), + .ledgerHash = xrpl::strHex(lgrInfo.hash), .accountData = sle, .isDisallowIncomingEnabled = isDisallowIncomingEnabled, .isClawbackEnabled = isClawbackEnabled, @@ -107,20 +107,18 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons if (input.signerLists) { // We put the SignerList in an array because of an anticipated // future when we support multiple signer lists on one account. - auto const signersKey = ripple::keylet::signers(*accountID); + auto const signersKey = xrpl::keylet::signers(*accountID); // This code will need to be revisited if in the future we // support multiple SignerLists on one account. auto const signers = sharedPtrBackend_->fetchLedgerObject(signersKey.key, lgrInfo.seq, ctx.yield); - out.signerLists = std::vector(); + out.signerLists = std::vector(); if (signers) { - ripple::STLedgerEntry const sleSigners{ - ripple::SerialIter{signers->data(), signers->size()}, signersKey.key - }; + xrpl::STLedgerEntry const sleSigners{xrpl::SerialIter{signers->data(), signers->size()}, signersKey.key}; if (!signersKey.check(sleSigners)) - return Error{Status{RippledError::rpcDB_DESERIALIZATION}}; + return Error{Status{RippledError::RpcDbDeserialization}}; out.signerLists->push_back(sleSigners); } @@ -139,33 +137,33 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AccountInfoHandl {JS(validated), output.validated}, }; - std::vector> lsFlags{{ - {"defaultRipple", ripple::lsfDefaultRipple}, - {"depositAuth", ripple::lsfDepositAuth}, - {"disableMasterKey", ripple::lsfDisableMaster}, - {"disallowIncomingXRP", ripple::lsfDisallowXRP}, - {"globalFreeze", ripple::lsfGlobalFreeze}, - {"noFreeze", ripple::lsfNoFreeze}, - {"passwordSpent", ripple::lsfPasswordSpent}, - {"requireAuthorization", ripple::lsfRequireAuth}, - {"requireDestinationTag", ripple::lsfRequireDestTag}, + std::vector> lsFlags{{ + {"defaultRipple", xrpl::lsfDefaultRipple}, + {"depositAuth", xrpl::lsfDepositAuth}, + {"disableMasterKey", xrpl::lsfDisableMaster}, + {"disallowIncomingXRP", xrpl::lsfDisallowXRP}, + {"globalFreeze", xrpl::lsfGlobalFreeze}, + {"noFreeze", xrpl::lsfNoFreeze}, + {"passwordSpent", xrpl::lsfPasswordSpent}, + {"requireAuthorization", xrpl::lsfRequireAuth}, + {"requireDestinationTag", xrpl::lsfRequireDestTag}, }}; if (output.isDisallowIncomingEnabled) { - std::vector> const disallowIncomingFlags = { - {"disallowIncomingNFTokenOffer", ripple::lsfDisallowIncomingNFTokenOffer}, - {"disallowIncomingCheck", ripple::lsfDisallowIncomingCheck}, - {"disallowIncomingPayChan", ripple::lsfDisallowIncomingPayChan}, - {"disallowIncomingTrustline", ripple::lsfDisallowIncomingTrustline}, + std::vector> const disallowIncomingFlags = { + {"disallowIncomingNFTokenOffer", xrpl::lsfDisallowIncomingNFTokenOffer}, + {"disallowIncomingCheck", xrpl::lsfDisallowIncomingCheck}, + {"disallowIncomingPayChan", xrpl::lsfDisallowIncomingPayChan}, + {"disallowIncomingTrustline", xrpl::lsfDisallowIncomingTrustline}, }; lsFlags.insert(lsFlags.end(), disallowIncomingFlags.begin(), disallowIncomingFlags.end()); } if (output.isClawbackEnabled) - lsFlags.emplace_back("allowTrustLineClawback", ripple::lsfAllowTrustLineClawback); + lsFlags.emplace_back("allowTrustLineClawback", xrpl::lsfAllowTrustLineClawback); if (output.isTokenEscrowEnabled) - lsFlags.emplace_back("allowTrustLineLocking", ripple::lsfAllowTrustLineLocking); + lsFlags.emplace_back("allowTrustLineLocking", xrpl::lsfAllowTrustLineLocking); boost::json::object acctFlags; for (auto const& lsf : lsFlags) diff --git a/src/rpc/handlers/AccountInfo.hpp b/src/rpc/handlers/AccountInfo.hpp index 1b3897372..7a483f441 100644 --- a/src/rpc/handlers/AccountInfo.hpp +++ b/src/rpc/handlers/AccountInfo.hpp @@ -57,12 +57,12 @@ public: struct Output { uint32_t ledgerIndex; std::string ledgerHash; - ripple::STLedgerEntry accountData; + xrpl::STLedgerEntry accountData; bool isDisallowIncomingEnabled = false; bool isClawbackEnabled = false; bool isTokenEscrowEnabled = false; uint32_t apiVersion; - std::optional> signerLists; + std::optional> signerLists; // validated should be sent via framework bool validated = true; }; diff --git a/src/rpc/handlers/AccountLines.cpp b/src/rpc/handlers/AccountLines.cpp index 159089b9f..cae0db3d6 100644 --- a/src/rpc/handlers/AccountLines.cpp +++ b/src/rpc/handlers/AccountLines.cpp @@ -52,21 +52,21 @@ namespace rpc { void AccountLinesHandler::addLine( std::vector& lines, - ripple::SLE const& lineSle, - ripple::AccountID const& account, - std::optional const& peerAccount + xrpl::SLE const& lineSle, + xrpl::AccountID const& account, + std::optional const& peerAccount ) { - auto const flags = lineSle.getFieldU32(ripple::sfFlags); - auto const lowLimit = lineSle.getFieldAmount(ripple::sfLowLimit); - auto const highLimit = lineSle.getFieldAmount(ripple::sfHighLimit); + auto const flags = lineSle.getFieldU32(xrpl::sfFlags); + auto const lowLimit = lineSle.getFieldAmount(xrpl::sfLowLimit); + auto const highLimit = lineSle.getFieldAmount(xrpl::sfHighLimit); auto const lowID = lowLimit.getIssuer(); auto const highID = highLimit.getIssuer(); - auto const lowQualityIn = lineSle.getFieldU32(ripple::sfLowQualityIn); - auto const lowQualityOut = lineSle.getFieldU32(ripple::sfLowQualityOut); - auto const highQualityIn = lineSle.getFieldU32(ripple::sfHighQualityIn); - auto const highQualityOut = lineSle.getFieldU32(ripple::sfHighQualityOut); - auto balance = lineSle.getFieldAmount(ripple::sfBalance); + auto const lowQualityIn = lineSle.getFieldU32(xrpl::sfLowQualityIn); + auto const lowQualityOut = lineSle.getFieldU32(xrpl::sfLowQualityOut); + auto const highQualityIn = lineSle.getFieldU32(xrpl::sfHighQualityIn); + auto const highQualityOut = lineSle.getFieldU32(xrpl::sfHighQualityOut); + auto balance = lineSle.getFieldAmount(xrpl::sfBalance); auto const viewLowest = (lowID == account); auto const lineLimit = viewLowest ? lowLimit : highLimit; @@ -81,24 +81,23 @@ AccountLinesHandler::addLine( if (not viewLowest) balance.negate(); - bool const lineAuth = (flags & (viewLowest ? ripple::lsfLowAuth : ripple::lsfHighAuth)) != 0u; - bool const lineAuthPeer = (flags & (not viewLowest ? ripple::lsfLowAuth : ripple::lsfHighAuth)) != 0u; - bool const lineNoRipple = (flags & (viewLowest ? ripple::lsfLowNoRipple : ripple::lsfHighNoRipple)) != 0u; - bool const lineNoRipplePeer = (flags & (not viewLowest ? ripple::lsfLowNoRipple : ripple::lsfHighNoRipple)) != 0u; - bool const lineFreeze = (flags & (viewLowest ? ripple::lsfLowFreeze : ripple::lsfHighFreeze)) != 0u; - bool const lineFreezePeer = (flags & (not viewLowest ? ripple::lsfLowFreeze : ripple::lsfHighFreeze)) != 0u; - bool const lineDeepFreeze = (flags & (viewLowest ? ripple::lsfLowDeepFreeze : ripple::lsfHighDeepFreeze)) != 0u; - bool const lineDeepFreezePeer = - (flags & (not viewLowest ? ripple::lsfLowDeepFreeze : ripple::lsfHighDeepFreeze)) != 0u; + bool const lineAuth = (flags & (viewLowest ? xrpl::lsfLowAuth : xrpl::lsfHighAuth)) != 0u; + bool const lineAuthPeer = (flags & (not viewLowest ? xrpl::lsfLowAuth : xrpl::lsfHighAuth)) != 0u; + bool const lineNoRipple = (flags & (viewLowest ? xrpl::lsfLowNoRipple : xrpl::lsfHighNoRipple)) != 0u; + bool const lineNoRipplePeer = (flags & (not viewLowest ? xrpl::lsfLowNoRipple : xrpl::lsfHighNoRipple)) != 0u; + bool const lineFreeze = (flags & (viewLowest ? xrpl::lsfLowFreeze : xrpl::lsfHighFreeze)) != 0u; + bool const lineFreezePeer = (flags & (not viewLowest ? xrpl::lsfLowFreeze : xrpl::lsfHighFreeze)) != 0u; + bool const lineDeepFreeze = (flags & (viewLowest ? xrpl::lsfLowDeepFreeze : xrpl::lsfHighDeepFreeze)) != 0u; + bool const lineDeepFreezePeer = (flags & (not viewLowest ? xrpl::lsfLowDeepFreeze : xrpl::lsfHighDeepFreeze)) != 0u; - ripple::STAmount const& saBalance = balance; - ripple::STAmount const& saLimit = lineLimit; - ripple::STAmount const& saLimitPeer = lineLimitPeer; + xrpl::STAmount const& saBalance = balance; + xrpl::STAmount const& saLimit = lineLimit; + xrpl::STAmount const& saLimitPeer = lineLimitPeer; LineResponse line; - line.account = ripple::to_string(lineAccountIDPeer); + line.account = xrpl::to_string(lineAccountIDPeer); line.balance = saBalance.getText(); - line.currency = ripple::to_string(saBalance.issue().currency); + line.currency = xrpl::to_string(saBalance.get().currency); line.limit = saLimit.getText(); line.limitPeer = saLimitPeer.getText(); line.qualityIn = lineQualityIn; @@ -146,24 +145,24 @@ AccountLinesHandler::process(AccountLinesHandler::Input const& input, Context co auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (not accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; - auto const peerAccountID = input.peer ? accountFromStringStrict(*(input.peer)) : std::optional{}; + auto const peerAccountID = input.peer ? accountFromStringStrict(*(input.peer)) : std::optional{}; Output response; response.lines.reserve(input.limit); - auto const addToResponse = [&](ripple::SLE const sle) { - if (sle.getType() == ripple::ltRIPPLE_STATE) { + auto const addToResponse = [&](xrpl::SLE const sle) { + if (sle.getType() == xrpl::ltRIPPLE_STATE) { auto ignore = false; if (input.ignoreDefault) { - if (sle.getFieldAmount(ripple::sfLowLimit).getIssuer() == accountID) { - ignore = ((sle.getFieldU32(ripple::sfFlags) & ripple::lsfLowReserve) == 0u); + if (sle.getFieldAmount(xrpl::sfLowLimit).getIssuer() == accountID) { + ignore = ((sle.getFieldU32(xrpl::sfFlags) & xrpl::lsfLowReserve) == 0u); } else { - ignore = ((sle.getFieldU32(ripple::sfFlags) & ripple::lsfHighReserve) == 0u); + ignore = ((sle.getFieldU32(xrpl::sfFlags) & xrpl::lsfHighReserve) == 0u); } } @@ -184,7 +183,7 @@ AccountLinesHandler::process(AccountLinesHandler::Input const& input, Context co response.account = input.account; response.limit = input.limit; // not documented, // https://github.com/XRPLF/xrpl-dev-portal/issues/1838 - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; if (nextMarker.isNonZero()) diff --git a/src/rpc/handlers/AccountLines.hpp b/src/rpc/handlers/AccountLines.hpp index 1df1cf161..3c69995b5 100644 --- a/src/rpc/handlers/AccountLines.hpp +++ b/src/rpc/handlers/AccountLines.hpp @@ -131,11 +131,11 @@ public: {JS(account), validation::Required{}, meta::WithCustomError{ - validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED) + validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed) }}, {JS(peer), meta::WithCustomError{ - validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED) + validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed) }}, {JS(ignore_default), validation::Type{}}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, @@ -166,9 +166,9 @@ private: static void addLine( std::vector& lines, - ripple::SLE const& lineSle, - ripple::AccountID const& account, - std::optional const& peerAccount + xrpl::SLE const& lineSle, + xrpl::AccountID const& account, + std::optional const& peerAccount ); private: diff --git a/src/rpc/handlers/AccountMPTokenIssuances.cpp b/src/rpc/handlers/AccountMPTokenIssuances.cpp index 942431738..625c70d8c 100644 --- a/src/rpc/handlers/AccountMPTokenIssuances.cpp +++ b/src/rpc/handlers/AccountMPTokenIssuances.cpp @@ -50,68 +50,68 @@ namespace rpc { void AccountMPTokenIssuancesHandler::addMPTokenIssuance( std::vector& issuances, - ripple::SLE const& sle, - ripple::AccountID const& account + xrpl::SLE const& sle, + xrpl::AccountID const& account ) { MPTokenIssuanceResponse issuance; - issuance.MPTokenIssuanceID = ripple::strHex(sle.key()); - issuance.issuer = ripple::to_string(account); - issuance.sequence = sle.getFieldU32(ripple::sfSequence); - auto const flags = sle.getFieldU32(ripple::sfFlags); + issuance.MPTokenIssuanceID = xrpl::strHex(sle.key()); + issuance.issuer = xrpl::to_string(account); + issuance.sequence = sle.getFieldU32(xrpl::sfSequence); + auto const flags = sle.getFieldU32(xrpl::sfFlags); auto const setFlag = [&](std::optional& field, std::uint32_t mask) { if ((flags & mask) != 0u) field = true; }; - setFlag(issuance.mptLocked, ripple::lsfMPTLocked); - setFlag(issuance.mptCanLock, ripple::lsfMPTCanLock); - setFlag(issuance.mptRequireAuth, ripple::lsfMPTRequireAuth); - setFlag(issuance.mptCanEscrow, ripple::lsfMPTCanEscrow); - setFlag(issuance.mptCanTrade, ripple::lsfMPTCanTrade); - setFlag(issuance.mptCanTransfer, ripple::lsfMPTCanTransfer); - setFlag(issuance.mptCanClawback, ripple::lsfMPTCanClawback); + setFlag(issuance.mptLocked, xrpl::lsfMPTLocked); + setFlag(issuance.mptCanLock, xrpl::lsfMPTCanLock); + setFlag(issuance.mptRequireAuth, xrpl::lsfMPTRequireAuth); + setFlag(issuance.mptCanEscrow, xrpl::lsfMPTCanEscrow); + setFlag(issuance.mptCanTrade, xrpl::lsfMPTCanTrade); + setFlag(issuance.mptCanTransfer, xrpl::lsfMPTCanTransfer); + setFlag(issuance.mptCanClawback, xrpl::lsfMPTCanClawback); - if (sle.isFieldPresent(ripple::sfMutableFlags)) { - auto const mutableFlags = sle.getFieldU32(ripple::sfMutableFlags); + if (sle.isFieldPresent(xrpl::sfMutableFlags)) { + auto const mutableFlags = sle.getFieldU32(xrpl::sfMutableFlags); auto const setMutableFlag = [&](std::optional& field, std::uint32_t mask) { if ((mutableFlags & mask) != 0u) field = true; }; - setMutableFlag(issuance.mptCanMutateCanLock, ripple::lsmfMPTCanMutateCanLock); - setMutableFlag(issuance.mptCanMutateRequireAuth, ripple::lsmfMPTCanMutateRequireAuth); - setMutableFlag(issuance.mptCanMutateCanEscrow, ripple::lsmfMPTCanMutateCanEscrow); - setMutableFlag(issuance.mptCanMutateCanTrade, ripple::lsmfMPTCanMutateCanTrade); - setMutableFlag(issuance.mptCanMutateCanTransfer, ripple::lsmfMPTCanMutateCanTransfer); - setMutableFlag(issuance.mptCanMutateCanClawback, ripple::lsmfMPTCanMutateCanClawback); - setMutableFlag(issuance.mptCanMutateMetadata, ripple::lsmfMPTCanMutateMetadata); - setMutableFlag(issuance.mptCanMutateTransferFee, ripple::lsmfMPTCanMutateTransferFee); + setMutableFlag(issuance.mptCanMutateCanLock, xrpl::lsmfMPTCanMutateCanLock); + setMutableFlag(issuance.mptCanMutateRequireAuth, xrpl::lsmfMPTCanMutateRequireAuth); + setMutableFlag(issuance.mptCanMutateCanEscrow, xrpl::lsmfMPTCanMutateCanEscrow); + setMutableFlag(issuance.mptCanMutateCanTrade, xrpl::lsmfMPTCanMutateCanTrade); + setMutableFlag(issuance.mptCanMutateCanTransfer, xrpl::lsmfMPTCanMutateCanTransfer); + setMutableFlag(issuance.mptCanMutateCanClawback, xrpl::lsmfMPTCanMutateCanClawback); + setMutableFlag(issuance.mptCanMutateMetadata, xrpl::lsmfMPTCanMutateMetadata); + setMutableFlag(issuance.mptCanMutateTransferFee, xrpl::lsmfMPTCanMutateTransferFee); } - if (sle.isFieldPresent(ripple::sfTransferFee)) - issuance.transferFee = sle.getFieldU16(ripple::sfTransferFee); + if (sle.isFieldPresent(xrpl::sfTransferFee)) + issuance.transferFee = sle.getFieldU16(xrpl::sfTransferFee); - if (sle.isFieldPresent(ripple::sfAssetScale)) - issuance.assetScale = sle.getFieldU8(ripple::sfAssetScale); + if (sle.isFieldPresent(xrpl::sfAssetScale)) + issuance.assetScale = sle.getFieldU8(xrpl::sfAssetScale); - if (sle.isFieldPresent(ripple::sfMaximumAmount)) - issuance.maximumAmount = sle.getFieldU64(ripple::sfMaximumAmount); + if (sle.isFieldPresent(xrpl::sfMaximumAmount)) + issuance.maximumAmount = sle.getFieldU64(xrpl::sfMaximumAmount); - if (sle.isFieldPresent(ripple::sfOutstandingAmount)) - issuance.outstandingAmount = sle.getFieldU64(ripple::sfOutstandingAmount); + if (sle.isFieldPresent(xrpl::sfOutstandingAmount)) + issuance.outstandingAmount = sle.getFieldU64(xrpl::sfOutstandingAmount); - if (sle.isFieldPresent(ripple::sfLockedAmount)) - issuance.lockedAmount = sle.getFieldU64(ripple::sfLockedAmount); + if (sle.isFieldPresent(xrpl::sfLockedAmount)) + issuance.lockedAmount = sle.getFieldU64(xrpl::sfLockedAmount); - if (sle.isFieldPresent(ripple::sfMPTokenMetadata)) - issuance.mptokenMetadata = ripple::strHex(sle.getFieldVL(ripple::sfMPTokenMetadata)); + if (sle.isFieldPresent(xrpl::sfMPTokenMetadata)) + issuance.mptokenMetadata = xrpl::strHex(sle.getFieldVL(xrpl::sfMPTokenMetadata)); - if (sle.isFieldPresent(ripple::sfDomainID)) - issuance.domainID = ripple::strHex(sle.getFieldH256(ripple::sfDomainID)); + if (sle.isFieldPresent(xrpl::sfDomainID)) + issuance.domainID = xrpl::strHex(sle.getFieldH256(xrpl::sfDomainID)); issuances.push_back(issuance); } @@ -131,16 +131,16 @@ AccountMPTokenIssuancesHandler::process(AccountMPTokenIssuancesHandler::Input co auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (not accountLedgerObject.has_value()) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; Output response; response.issuances.reserve(input.limit); - auto const addToResponse = [&](ripple::SLE const& sle) { - if (sle.getType() == ripple::ltMPTOKEN_ISSUANCE) { + auto const addToResponse = [&](xrpl::SLE const& sle) { + if (sle.getType() == xrpl::ltMPTOKEN_ISSUANCE) { addMPTokenIssuance(response.issuances, sle, *accountID); } }; @@ -157,7 +157,7 @@ AccountMPTokenIssuancesHandler::process(AccountMPTokenIssuancesHandler::Input co response.account = input.account; response.limit = input.limit; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; if (nextMarker.isNonZero()) diff --git a/src/rpc/handlers/AccountMPTokenIssuances.hpp b/src/rpc/handlers/AccountMPTokenIssuances.hpp index eafe228d1..673107bc5 100644 --- a/src/rpc/handlers/AccountMPTokenIssuances.hpp +++ b/src/rpc/handlers/AccountMPTokenIssuances.hpp @@ -141,7 +141,7 @@ public: {JS(account), validation::Required{}, meta::WithCustomError{ - validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED) + validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed) }}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(limit), @@ -170,8 +170,8 @@ private: static void addMPTokenIssuance( std::vector& issuances, - ripple::SLE const& sle, - ripple::AccountID const& account + xrpl::SLE const& sle, + xrpl::AccountID const& account ); private: diff --git a/src/rpc/handlers/AccountMPTokens.cpp b/src/rpc/handlers/AccountMPTokens.cpp index 085841d0b..f3a26e299 100644 --- a/src/rpc/handlers/AccountMPTokens.cpp +++ b/src/rpc/handlers/AccountMPTokens.cpp @@ -49,26 +49,26 @@ namespace rpc { void -AccountMPTokensHandler::addMPToken(std::vector& mpts, ripple::SLE const& sle) +AccountMPTokensHandler::addMPToken(std::vector& mpts, xrpl::SLE const& sle) { MPTokenResponse token{}; - auto const flags = sle.getFieldU32(ripple::sfFlags); + auto const flags = sle.getFieldU32(xrpl::sfFlags); - token.MPTokenID = ripple::strHex(sle.key()); - token.account = ripple::to_string(sle.getAccountID(ripple::sfAccount)); - token.MPTokenIssuanceID = ripple::strHex(sle.getFieldH192(ripple::sfMPTokenIssuanceID)); - token.MPTAmount = sle.getFieldU64(ripple::sfMPTAmount); + token.MPTokenID = xrpl::strHex(sle.key()); + token.account = xrpl::to_string(sle.getAccountID(xrpl::sfAccount)); + token.MPTokenIssuanceID = xrpl::strHex(sle.getFieldH192(xrpl::sfMPTokenIssuanceID)); + token.MPTAmount = sle.getFieldU64(xrpl::sfMPTAmount); - if (sle.isFieldPresent(ripple::sfLockedAmount)) - token.lockedAmount = sle.getFieldU64(ripple::sfLockedAmount); + if (sle.isFieldPresent(xrpl::sfLockedAmount)) + token.lockedAmount = sle.getFieldU64(xrpl::sfLockedAmount); auto const setFlag = [&](std::optional& field, std::uint32_t mask) { if ((flags & mask) != 0u) field = true; }; - setFlag(token.mptLocked, ripple::lsfMPTLocked); - setFlag(token.mptAuthorized, ripple::lsfMPTAuthorized); + setFlag(token.mptLocked, xrpl::lsfMPTLocked); + setFlag(token.mptAuthorized, xrpl::lsfMPTAuthorized); mpts.push_back(token); } @@ -88,16 +88,16 @@ AccountMPTokensHandler::process(AccountMPTokensHandler::Input const& input, Cont auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (not accountLedgerObject.has_value()) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; Output response; response.mpts.reserve(input.limit); - auto const addToResponse = [&](ripple::SLE const& sle) { - if (sle.getType() == ripple::ltMPTOKEN) { + auto const addToResponse = [&](xrpl::SLE const& sle) { + if (sle.getType() == xrpl::ltMPTOKEN) { addMPToken(response.mpts, sle); } }; @@ -114,7 +114,7 @@ AccountMPTokensHandler::process(AccountMPTokensHandler::Input const& input, Cont response.account = input.account; response.limit = input.limit; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; if (nextMarker.isNonZero()) diff --git a/src/rpc/handlers/AccountMPTokens.hpp b/src/rpc/handlers/AccountMPTokens.hpp index 67bdccfc0..5fc090b09 100644 --- a/src/rpc/handlers/AccountMPTokens.hpp +++ b/src/rpc/handlers/AccountMPTokens.hpp @@ -118,7 +118,7 @@ public: {JS(account), validation::Required{}, meta::WithCustomError{ - validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED) + validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed) }}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(limit), @@ -145,7 +145,7 @@ public: private: static void - addMPToken(std::vector& mpts, ripple::SLE const& sle); + addMPToken(std::vector& mpts, xrpl::SLE const& sle); private: /** diff --git a/src/rpc/handlers/AccountNFTs.cpp b/src/rpc/handlers/AccountNFTs.cpp index d16ccebe6..5b153dd75 100644 --- a/src/rpc/handlers/AccountNFTs.cpp +++ b/src/rpc/handlers/AccountNFTs.cpp @@ -64,64 +64,63 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; auto response = Output{}; response.account = input.account; response.limit = input.limit; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; // if a marker was passed, start at the page specified in marker. Else, start at the max page - auto const pageKey = - input.marker ? ripple::uint256{input.marker->c_str()} : ripple::keylet::nftpage_max(*accountID).key; + auto const pageKey = input.marker ? xrpl::uint256{input.marker->c_str()} : xrpl::keylet::nftpageMax(*accountID).key; auto const blob = sharedPtrBackend_->fetchLedgerObject(pageKey, lgrInfo.seq, ctx.yield); if (!blob) { if (input.marker.has_value()) - return Error{Status{RippledError::rpcINVALID_PARAMS, "Marker field does not match any valid Page ID"}}; + return Error{Status{RippledError::RpcInvalidParams, "Marker field does not match any valid Page ID"}}; return response; } - std::optional page{ripple::SLE{ripple::SerialIter{blob->data(), blob->size()}, pageKey}}; + std::optional page{xrpl::SLE{xrpl::SerialIter{blob->data(), blob->size()}, pageKey}}; - if (page->getType() != ripple::ltNFTOKEN_PAGE) - return Error{Status{RippledError::rpcINVALID_PARAMS, "Marker matches Page ID from another Account"}}; + if (page->getType() != xrpl::ltNFTOKEN_PAGE) + return Error{Status{RippledError::RpcInvalidParams, "Marker matches Page ID from another Account"}}; auto numPages = 0u; while (page) { - auto const arr = page->getFieldArray(ripple::sfNFTokens); + auto const arr = page->getFieldArray(xrpl::sfNFTokens); for (auto const& nft : arr) { - auto const nftokenID = nft[ripple::sfNFTokenID]; + auto const nftokenID = nft[xrpl::sfNFTokenID]; - response.nfts.push_back(toBoostJson(nft.getJson(ripple::JsonOptions::none))); + response.nfts.push_back(toBoostJson(nft.getJson(xrpl::JsonOptions::Values::None))); auto& obj = response.nfts.back().as_object(); // Pull out the components of the nft ID. - obj[SFS(sfFlags)] = ripple::nft::getFlags(nftokenID); - obj[SFS(sfIssuer)] = to_string(ripple::nft::getIssuer(nftokenID)); - obj[SFS(sfNFTokenTaxon)] = ripple::nft::toUInt32(ripple::nft::getTaxon(nftokenID)); - obj[JS(nft_serial)] = ripple::nft::getSerial(nftokenID); + obj[SFS(sfFlags)] = xrpl::nft::getFlags(nftokenID); + obj[SFS(sfIssuer)] = to_string(xrpl::nft::getIssuer(nftokenID)); + obj[SFS(sfNFTokenTaxon)] = xrpl::nft::toUInt32(xrpl::nft::getTaxon(nftokenID)); + obj[JS(nft_serial)] = xrpl::nft::getSerial(nftokenID); - if (std::uint16_t const xferFee = {ripple::nft::getTransferFee(nftokenID)}) + if (std::uint16_t const xferFee = {xrpl::nft::getTransferFee(nftokenID)}) obj[SFS(sfTransferFee)] = xferFee; } ++numPages; - if (auto const npm = (*page)[~ripple::sfPreviousPageMin]) { - auto const nextKey = ripple::Keylet(ripple::ltNFTOKEN_PAGE, *npm); + if (auto const npm = (*page)[~xrpl::sfPreviousPageMin]) { + auto const nextKey = xrpl::Keylet(xrpl::ltNFTOKEN_PAGE, *npm); if (numPages == input.limit) { response.marker = to_string(nextKey.key); return response; } auto const nextBlob = sharedPtrBackend_->fetchLedgerObject(nextKey.key, lgrInfo.seq, ctx.yield); - page.emplace(ripple::SLE{ripple::SerialIter{nextBlob->data(), nextBlob->size()}, nextKey.key}); + page.emplace(xrpl::SLE{xrpl::SerialIter{nextBlob->data(), nextBlob->size()}, nextKey.key}); } else { page.reset(); } diff --git a/src/rpc/handlers/AccountObjects.cpp b/src/rpc/handlers/AccountObjects.cpp index 323b3e3cb..ca875ac82 100644 --- a/src/rpc/handlers/AccountObjects.cpp +++ b/src/rpc/handlers/AccountObjects.cpp @@ -65,12 +65,12 @@ AccountObjectsHandler::process(AccountObjectsHandler::Input const& input, Contex auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; - auto typeFilter = std::optional>{}; + auto typeFilter = std::optional>{}; if (input.deletionBlockersOnly) { typeFilter.emplace(); @@ -84,12 +84,12 @@ AccountObjectsHandler::process(AccountObjectsHandler::Input const& input, Contex typeFilter->push_back(type); } } else { - if (input.type && input.type != ripple::ltANY) + if (input.type && input.type != xrpl::ltANY) typeFilter = {*input.type}; } Output response; - auto const addToResponse = [&](ripple::SLE&& sle) { + auto const addToResponse = [&](xrpl::SLE&& sle) { if (not typeFilter or std::find(std::begin(typeFilter.value()), std::end(typeFilter.value()), sle.getType()) != std::end(typeFilter.value())) { @@ -105,7 +105,7 @@ AccountObjectsHandler::process(AccountObjectsHandler::Input const& input, Contex if (!expectedNext.has_value()) return Error{expectedNext.error()}; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; response.limit = input.limit; response.account = input.account; diff --git a/src/rpc/handlers/AccountObjects.hpp b/src/rpc/handlers/AccountObjects.hpp index f795518b2..12d192e06 100644 --- a/src/rpc/handlers/AccountObjects.hpp +++ b/src/rpc/handlers/AccountObjects.hpp @@ -67,7 +67,7 @@ public: uint32_t ledgerIndex{}; std::optional marker; uint32_t limit{}; - std::vector accountObjects; + std::vector accountObjects; bool validated = true; }; @@ -80,7 +80,7 @@ public: std::optional ledgerIndex; uint32_t limit = kLIMIT_DEFAULT; // [10,400] std::optional marker; - std::optional type; + std::optional type; bool deletionBlockersOnly = false; }; diff --git a/src/rpc/handlers/AccountOffers.cpp b/src/rpc/handlers/AccountOffers.cpp index 2d987678f..e96f53977 100644 --- a/src/rpc/handlers/AccountOffers.cpp +++ b/src/rpc/handlers/AccountOffers.cpp @@ -48,20 +48,20 @@ namespace rpc { void -AccountOffersHandler::addOffer(std::vector& offers, ripple::SLE const& offerSle) +AccountOffersHandler::addOffer(std::vector& offers, xrpl::SLE const& offerSle) { auto offer = AccountOffersHandler::Offer(); - offer.takerPays = offerSle.getFieldAmount(ripple::sfTakerPays); - offer.takerGets = offerSle.getFieldAmount(ripple::sfTakerGets); - offer.seq = offerSle.getFieldU32(ripple::sfSequence); - offer.flags = offerSle.getFieldU32(ripple::sfFlags); + offer.takerPays = offerSle.getFieldAmount(xrpl::sfTakerPays); + offer.takerGets = offerSle.getFieldAmount(xrpl::sfTakerGets); + offer.seq = offerSle.getFieldU32(xrpl::sfSequence); + offer.flags = offerSle.getFieldU32(xrpl::sfFlags); - auto const quality = getQuality(offerSle.getFieldH256(ripple::sfBookDirectory)); - auto const rate = ripple::amountFromQuality(quality); + auto const quality = getQuality(offerSle.getFieldH256(xrpl::sfBookDirectory)); + auto const rate = xrpl::amountFromQuality(quality); offer.quality = rate.getText(); - if (offerSle.isFieldPresent(ripple::sfExpiration)) - offer.expiration = offerSle.getFieldU32(ripple::sfExpiration); + if (offerSle.isFieldPresent(xrpl::sfExpiration)) + offer.expiration = offerSle.getFieldU32(xrpl::sfExpiration); offers.push_back(offer); }; @@ -81,18 +81,18 @@ AccountOffersHandler::process(AccountOffersHandler::Input const& input, Context auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; Output response; - response.account = ripple::to_string(*accountID); - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.account = xrpl::to_string(*accountID); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; - auto const addToResponse = [&](ripple::SLE const sle) { - if (sle.getType() == ripple::ltOFFER) + auto const addToResponse = [&](xrpl::SLE const sle) { + if (sle.getType() == xrpl::ltOFFER) addOffer(response.offers, sle); return true; @@ -142,13 +142,13 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AccountOffersHan if (offer.expiration) jsonObject[JS(expiration)] = *offer.expiration; - auto const convertAmount = [&](char const* field, ripple::STAmount const& amount) { + auto const convertAmount = [&](char const* field, xrpl::STAmount const& amount) { if (amount.native()) { jsonObject[field] = amount.getText(); } else { jsonObject[field] = { - {JS(currency), ripple::to_string(amount.getCurrency())}, - {JS(issuer), ripple::to_string(amount.getIssuer())}, + {JS(currency), xrpl::to_string(amount.get().currency)}, + {JS(issuer), xrpl::to_string(amount.getIssuer())}, {JS(value), amount.getText()}, }; } diff --git a/src/rpc/handlers/AccountOffers.hpp b/src/rpc/handlers/AccountOffers.hpp index ce9595c0b..dd6968a10 100644 --- a/src/rpc/handlers/AccountOffers.hpp +++ b/src/rpc/handlers/AccountOffers.hpp @@ -60,8 +60,8 @@ public: struct Offer { uint32_t flags{}; uint32_t seq{}; - ripple::STAmount takerGets; - ripple::STAmount takerPays; + xrpl::STAmount takerGets; + xrpl::STAmount takerPays; std::string quality; std::optional expiration; }; @@ -139,7 +139,7 @@ public: private: static void - addOffer(std::vector& offers, ripple::SLE const& offerSle); + addOffer(std::vector& offers, xrpl::SLE const& offerSle); /** * @brief Convert the Output to a JSON object diff --git a/src/rpc/handlers/AccountTx.cpp b/src/rpc/handlers/AccountTx.cpp index ad82919e6..d77d45d8e 100644 --- a/src/rpc/handlers/AccountTx.cpp +++ b/src/rpc/handlers/AccountTx.cpp @@ -62,7 +62,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c if (input.ledgerIndexMin) { if (ctx.apiVersion > 1u && (input.ledgerIndexMin > range->maxSequence || input.ledgerIndexMin < range->minSequence)) { - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMinOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMinOutOfRange"}}; } if (static_cast(*input.ledgerIndexMin) > minIndex) @@ -72,7 +72,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c if (input.ledgerIndexMax) { if (ctx.apiVersion > 1u && (input.ledgerIndexMax > range->maxSequence || input.ledgerIndexMax < range->minSequence)) { - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMaxOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMaxOutOfRange"}}; } if (static_cast(*input.ledgerIndexMax) < maxIndex) @@ -81,14 +81,14 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c if (minIndex > maxIndex) { if (ctx.apiVersion == 1u) - return Error{Status{RippledError::rpcLGR_IDXS_INVALID}}; + return Error{Status{RippledError::RpcLgrIdxsInvalid}}; - return Error{Status{RippledError::rpcINVALID_LGR_RANGE}}; + return Error{Status{RippledError::RpcInvalidLgrRange}}; } if (input.ledgerHash || input.ledgerIndex || input.usingValidatedLedger) { if (ctx.apiVersion > 1u && (input.ledgerIndexMax || input.ledgerIndexMin)) - return Error{Status{RippledError::rpcINVALID_PARAMS, "containsLedgerSpecifierAndRange"}}; + return Error{Status{RippledError::RpcInvalidParams, "containsLedgerSpecifierAndRange"}}; if (!input.ledgerIndexMax && !input.ledgerIndexMin) { // mimic rippled, when both range and index specified, respect the range. @@ -187,8 +187,8 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c if (auto const ledgerHeader = sharedPtrBackend_->fetchLedgerBySequence(txnPlusMeta.ledgerSequence, ctx.yield); ledgerHeader) { - obj[JS(ledger_hash)] = ripple::strHex(ledgerHeader->hash); - obj[JS(close_time_iso)] = ripple::to_string_iso(ledgerHeader->closeTime); + obj[JS(ledger_hash)] = xrpl::strHex(ledgerHeader->hash); + obj[JS(close_time_iso)] = xrpl::toStringIso(ledgerHeader->closeTime); } } obj[JS(validated)] = true; @@ -204,7 +204,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c } response.limit = input.limit; - response.account = ripple::to_string(*accountID); + response.account = xrpl::to_string(*accountID); response.ledgerIndexMin = minIndex; response.ledgerIndexMax = maxIndex; diff --git a/src/rpc/handlers/AccountTx.hpp b/src/rpc/handlers/AccountTx.hpp index e29bb4355..7a0639447 100644 --- a/src/rpc/handlers/AccountTx.hpp +++ b/src/rpc/handlers/AccountTx.hpp @@ -145,7 +145,7 @@ public: {JS(marker), meta::WithCustomError{ validation::Type{}, - Status{RippledError::rpcINVALID_PARAMS, "invalidMarker"}, + Status{RippledError::RpcInvalidParams, "invalidMarker"}, }, meta::Section{ {JS(ledger), validation::Required{}, validation::Type{}}, diff --git a/src/rpc/handlers/BookChanges.cpp b/src/rpc/handlers/BookChanges.cpp index 003ce4ef8..dd7bb8b1d 100644 --- a/src/rpc/handlers/BookChanges.cpp +++ b/src/rpc/handlers/BookChanges.cpp @@ -59,7 +59,7 @@ BookChangesHandler::process(BookChangesHandler::Input const& input, Context cons Output response; response.bookChanges = BookChanges::compute(transactions); - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; response.ledgerTime = lgrInfo.closeTime.time_since_epoch().count(); @@ -100,7 +100,7 @@ tag_invoke(boost::json::value_to_tag, boost::json::va } [[nodiscard]] boost::json::object -computeBookChanges(ripple::LedgerHeader const& lgrInfo, std::vector const& transactions) +computeBookChanges(xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions) { using boost::json::value_from; diff --git a/src/rpc/handlers/BookOffers.cpp b/src/rpc/handlers/BookOffers.cpp index 1383c68fd..71ee3b182 100644 --- a/src/rpc/handlers/BookOffers.cpp +++ b/src/rpc/handlers/BookOffers.cpp @@ -69,12 +69,12 @@ BookOffersHandler::process(Input const& input, Context const& ctx) const auto [offers, _] = sharedPtrBackend_->fetchBookOffers(bookKey, lgrInfo.seq, input.limit, ctx.yield); auto output = BookOffersHandler::Output{}; - output.ledgerHash = ripple::strHex(lgrInfo.hash); + output.ledgerHash = xrpl::strHex(lgrInfo.hash); output.ledgerIndex = lgrInfo.seq; output.offers = postProcessOrderBook( offers, book, - input.taker ? *(input.taker) : beast::zero, + input.taker ? *(input.taker) : beast::kZero, *sharedPtrBackend_, *amendmentCenter_, lgrInfo.seq, @@ -100,21 +100,21 @@ tag_invoke(boost::json::value_to_tag, boost::json::val auto input = BookOffersHandler::Input{}; auto const& jsonObject = jv.as_object(); - ripple::to_currency( + xrpl::toCurrency( input.getsCurrency, boost::json::value_to(jv.at(JS(taker_gets)).as_object().at(JS(currency))) ); - ripple::to_currency( + xrpl::toCurrency( input.paysCurrency, boost::json::value_to(jv.at(JS(taker_pays)).as_object().at(JS(currency))) ); if (jv.at(JS(taker_gets)).as_object().contains(JS(issuer))) { - ripple::to_issuer( + xrpl::toIssuer( input.getsID, boost::json::value_to(jv.at(JS(taker_gets)).as_object().at(JS(issuer))) ); } if (jv.at(JS(taker_pays)).as_object().contains(JS(issuer))) { - ripple::to_issuer( + xrpl::toIssuer( input.paysID, boost::json::value_to(jv.at(JS(taker_pays)).as_object().at(JS(issuer))) ); } diff --git a/src/rpc/handlers/BookOffers.hpp b/src/rpc/handlers/BookOffers.hpp index be85dfedc..5048510d5 100644 --- a/src/rpc/handlers/BookOffers.hpp +++ b/src/rpc/handlers/BookOffers.hpp @@ -79,12 +79,12 @@ public: std::optional ledgerHash; std::optional ledgerIndex; uint32_t limit = kLIMIT_DEFAULT; - std::optional taker; - ripple::Currency paysCurrency; - ripple::Currency getsCurrency; + std::optional taker; + xrpl::Currency paysCurrency; + xrpl::Currency getsCurrency; // accountID will be filled by input converter, if no issuer is given, will use XRP issuer - ripple::AccountID paysID = ripple::xrpAccount(); - ripple::AccountID getsID = ripple::xrpAccount(); + xrpl::AccountID paysID = xrpl::xrpAccount(); + xrpl::AccountID getsID = xrpl::xrpAccount(); std::optional domain; }; @@ -121,11 +121,11 @@ public: {JS(currency), validation::Required{}, meta::WithCustomError{ - validation::CustomValidators::currencyValidator, Status(RippledError::rpcDST_AMT_MALFORMED) + validation::CustomValidators::currencyValidator, Status(RippledError::RpcDstAmtMalformed) }}, {JS(issuer), meta::WithCustomError{ - validation::CustomValidators::issuerValidator, Status(RippledError::rpcDST_ISR_MALFORMED) + validation::CustomValidators::issuerValidator, Status(RippledError::RpcDstIsrMalformed) }} }}, {JS(taker_pays), @@ -135,26 +135,26 @@ public: {JS(currency), validation::Required{}, meta::WithCustomError{ - validation::CustomValidators::currencyValidator, Status(RippledError::rpcSRC_CUR_MALFORMED) + validation::CustomValidators::currencyValidator, Status(RippledError::RpcSrcCurMalformed) }}, {JS(issuer), meta::WithCustomError{ - validation::CustomValidators::issuerValidator, Status(RippledError::rpcSRC_ISR_MALFORMED) + validation::CustomValidators::issuerValidator, Status(RippledError::RpcSrcIsrMalformed) }} }}, // return INVALID_PARAMS if account format is wrong for "taker" {JS(taker), meta::WithCustomError{ validation::CustomValidators::accountValidator, - Status(RippledError::rpcINVALID_PARAMS, "Invalid field 'taker'.") + Status(RippledError::RpcInvalidParams, "Invalid field 'taker'.") }}, {JS(domain), meta::WithCustomError{ - validation::Type{}, Status(RippledError::rpcDOMAIN_MALFORMED, "Unable to parse domain.") + validation::Type{}, Status(RippledError::RpcDomainMalformed, "Unable to parse domain.") }, meta::WithCustomError{ validation::CustomValidators::uint256HexStringValidator, - Status(RippledError::rpcDOMAIN_MALFORMED, "Unable to parse domain.") + Status(RippledError::RpcDomainMalformed, "Unable to parse domain.") }}, {JS(limit), validation::Type{}, diff --git a/src/rpc/handlers/DepositAuthorized.cpp b/src/rpc/handlers/DepositAuthorized.cpp index 364760f5d..e2d08bd93 100644 --- a/src/rpc/handlers/DepositAuthorized.cpp +++ b/src/rpc/handlers/DepositAuthorized.cpp @@ -67,32 +67,32 @@ DepositAuthorizedHandler::process(DepositAuthorizedHandler::Input const& input, auto const destinationAccountID = accountFromStringStrict(input.destinationAccount); auto const srcAccountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*sourceAccountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*sourceAccountID).key, lgrInfo.seq, ctx.yield); if (!srcAccountLedgerObject) - return Error{Status{RippledError::rpcSRC_ACT_NOT_FOUND, "source_accountNotFound"}}; + return Error{Status{RippledError::RpcSrcActNotFound, "source_accountNotFound"}}; - auto const dstKeylet = ripple::keylet::account(*destinationAccountID).key; + auto const dstKeylet = xrpl::keylet::account(*destinationAccountID).key; auto const dstAccountLedgerObject = sharedPtrBackend_->fetchLedgerObject(dstKeylet, lgrInfo.seq, ctx.yield); if (!dstAccountLedgerObject) - return Error{Status{RippledError::rpcDST_ACT_NOT_FOUND, "destination_accountNotFound"}}; + return Error{Status{RippledError::RpcDstActNotFound, "destination_accountNotFound"}}; Output response; - auto it = ripple::SerialIter{dstAccountLedgerObject->data(), dstAccountLedgerObject->size()}; - auto const sleDest = ripple::SLE{it, dstKeylet}; - bool const reqAuth = sleDest.isFlag(ripple::lsfDepositAuth) && (sourceAccountID != destinationAccountID); + auto it = xrpl::SerialIter{dstAccountLedgerObject->data(), dstAccountLedgerObject->size()}; + auto const sleDest = xrpl::SLE{it, dstKeylet}; + bool const reqAuth = sleDest.isFlag(xrpl::lsfDepositAuth) && (sourceAccountID != destinationAccountID); auto const& creds = input.credentials; bool const credentialsPresent = creds.has_value(); - ripple::STArray authCreds; + xrpl::STArray authCreds; if (credentialsPresent) { if (creds.value().empty()) { - return Error{Status{RippledError::rpcINVALID_PARAMS, "credential array has no elements."}}; + return Error{Status{RippledError::RpcInvalidParams, "credential array has no elements."}}; } - if (creds.value().size() > ripple::maxCredentialsArraySize) { - return Error{Status{RippledError::rpcINVALID_PARAMS, "credential array too long."}}; + if (creds.value().size() > xrpl::kMaxCredentialsArraySize) { + return Error{Status{RippledError::RpcInvalidParams, "credential array too long."}}; } auto const credArray = credentials::fetchCredentialArray( input.credentials, *sourceAccountID, *sharedPtrBackend_, lgrInfo, ctx.yield @@ -107,16 +107,16 @@ DepositAuthorizedHandler::process(DepositAuthorizedHandler::Input const& input, bool depositAuthorized = true; if (reqAuth) { - ripple::uint256 hashKey; + xrpl::uint256 hashKey; if (credentialsPresent) { auto const sortedAuthCreds = credentials::createAuthCredentials(authCreds); ASSERT( sortedAuthCreds.size() == authCreds.size(), "should already be checked above that there is no duplicate" ); - hashKey = ripple::keylet::depositPreauth(*destinationAccountID, sortedAuthCreds).key; + hashKey = xrpl::keylet::depositPreauth(*destinationAccountID, sortedAuthCreds).key; } else { - hashKey = ripple::keylet::depositPreauth(*destinationAccountID, *sourceAccountID).key; + hashKey = xrpl::keylet::depositPreauth(*destinationAccountID, *sourceAccountID).key; } depositAuthorized = sharedPtrBackend_->fetchLedgerObject(hashKey, lgrInfo.seq, ctx.yield).has_value(); @@ -124,7 +124,7 @@ DepositAuthorizedHandler::process(DepositAuthorizedHandler::Input const& input, response.sourceAccount = input.sourceAccount; response.destinationAccount = input.destinationAccount; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; response.depositAuthorized = depositAuthorized; if (credentialsPresent) diff --git a/src/rpc/handlers/Feature.cpp b/src/rpc/handlers/Feature.cpp index 1a8422739..7679284b5 100644 --- a/src/rpc/handlers/Feature.cpp +++ b/src/rpc/handlers/Feature.cpp @@ -71,7 +71,7 @@ FeatureHandler::process(FeatureHandler::Input const& input, Context const& ctx) auto searchPredicate = [search = input.feature](auto const& feature) { if (search) - return ripple::to_string(feature.feature) == search.value() or feature.name == search.value(); + return xrpl::to_string(feature.feature) == search.value() or feature.name == search.value(); return true; }; @@ -79,13 +79,13 @@ FeatureHandler::process(FeatureHandler::Input const& input, Context const& ctx) rg::transform(all | vs::filter(searchPredicate), std::back_inserter(filtered), [&](auto const& feature) { return Output::Feature{ .name = feature.name, - .key = ripple::to_string(feature.feature), + .key = xrpl::to_string(feature.feature), .supported = feature.isSupportedByClio, }; }); if (filtered.empty()) - return Error{Status{RippledError::rpcBAD_FEATURE}}; + return Error{Status{RippledError::RpcBadFeature}}; std::vector names; rg::transform(filtered, std::back_inserter(names), [](auto const& feature) { return feature.name; }); @@ -103,7 +103,7 @@ FeatureHandler::process(FeatureHandler::Input const& input, Context const& ctx) return Output{ .features = std::move(features), - .ledgerHash = ripple::strHex(lgrInfo.hash), + .ledgerHash = xrpl::strHex(lgrInfo.hash), .ledgerIndex = lgrInfo.seq, .inlineResult = input.feature.has_value() }; @@ -117,7 +117,7 @@ FeatureHandler::spec([[maybe_unused]] uint32_t apiVersion) {JS(vetoed), meta::WithCustomError{ validation::NotSupported{}, - Status(RippledError::rpcNO_PERMISSION, "The admin portion of feature API is not available through Clio.") + Status(RippledError::RpcNoPermission, "The admin portion of feature API is not available through Clio.") }}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, diff --git a/src/rpc/handlers/GatewayBalances.cpp b/src/rpc/handlers/GatewayBalances.cpp index ca95142fc..ebc63605a 100644 --- a/src/rpc/handlers/GatewayBalances.cpp +++ b/src/rpc/handlers/GatewayBalances.cpp @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -73,18 +74,18 @@ GatewayBalancesHandler::process(GatewayBalancesHandler::Input const& input, Cont auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; auto output = GatewayBalancesHandler::Output{}; - auto addEscrow = [&](ripple::SLE const& sle) { - if (sle.getType() == ripple::ltESCROW) { - auto const& escrow = sle.getFieldAmount(ripple::sfAmount); - auto& lockedBalance = output.locked[escrow.getCurrency()]; - if (lockedBalance == beast::zero) { + auto addEscrow = [&](xrpl::SLE const& sle) { + if (sle.getType() == xrpl::ltESCROW) { + auto const& escrow = sle.getFieldAmount(xrpl::sfAmount); + auto& lockedBalance = output.locked[escrow.get().currency]; + if (lockedBalance == beast::kZero) { // This is needed to set the currency code correctly lockedBalance = escrow; } else { @@ -95,26 +96,26 @@ GatewayBalancesHandler::process(GatewayBalancesHandler::Input const& input, Cont // On overflow return the largest valid STAmount. // Very large sums of STAmount are approximations // anyway. - lockedBalance = ripple::STAmount( - lockedBalance.issue(), ripple::STAmount::cMaxValue, ripple::STAmount::cMaxOffset + lockedBalance = xrpl::STAmount( + lockedBalance.get(), xrpl::STAmount::kMaxValue, xrpl::STAmount::kMaxOffset ); } } } }; - auto const addToResponse = [&](ripple::SLE const sle) { + auto const addToResponse = [&](xrpl::SLE const sle) { addEscrow(sle); - if (sle.getType() == ripple::ltRIPPLE_STATE) { - ripple::STAmount balance = sle.getFieldAmount(ripple::sfBalance); - auto const lowLimit = sle.getFieldAmount(ripple::sfLowLimit); - auto const highLimit = sle.getFieldAmount(ripple::sfHighLimit); + if (sle.getType() == xrpl::ltRIPPLE_STATE) { + xrpl::STAmount balance = sle.getFieldAmount(xrpl::sfBalance); + auto const lowLimit = sle.getFieldAmount(xrpl::sfLowLimit); + auto const highLimit = sle.getFieldAmount(xrpl::sfHighLimit); auto const lowID = lowLimit.getIssuer(); auto const highID = highLimit.getIssuer(); auto const viewLowest = (lowLimit.getIssuer() == accountID); - auto const flags = sle.getFieldU32(ripple::sfFlags); - auto const freeze = flags & (viewLowest ? ripple::lsfLowFreeze : ripple::lsfHighFreeze); + auto const flags = sle.getFieldU32(xrpl::sfFlags); + auto const freeze = flags & (viewLowest ? xrpl::lsfLowFreeze : xrpl::lsfHighFreeze); if (!viewLowest) balance.negate(); @@ -139,15 +140,17 @@ GatewayBalancesHandler::process(GatewayBalancesHandler::Input const& input, Cont output.frozenBalances[peer].push_back(-balance); } else { // normal negative balance, obligation to customer - auto& bal = output.sums[balance.getCurrency()]; - if (bal == beast::zero) { + auto& bal = output.sums[balance.get().currency]; + if (bal == beast::kZero) { // This is needed to set the currency code correctly bal = -balance; } else { try { bal -= balance; } catch (std::runtime_error const& e) { - bal = ripple::STAmount(bal.issue(), ripple::STAmount::cMaxValue, ripple::STAmount::cMaxOffset); + bal = xrpl::STAmount( + bal.get(), xrpl::STAmount::kMaxValue, xrpl::STAmount::kMaxOffset + ); } } } @@ -171,7 +174,7 @@ GatewayBalancesHandler::process(GatewayBalancesHandler::Input const& input, Cont return Error{ret.error()}; output.accountID = input.account; - output.ledgerHash = ripple::strHex(lgrInfo.hash); + output.ledgerHash = xrpl::strHex(lgrInfo.hash); output.ledgerIndex = lgrInfo.seq; return output; @@ -184,12 +187,12 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, GatewayBalancesH if (!output.sums.empty()) { boost::json::object obligations; for (auto const& [k, v] : output.sums) - obligations[ripple::to_string(k)] = v.getText(); + obligations[xrpl::to_string(k)] = v.getText(); obj[JS(obligations)] = std::move(obligations); } - auto const toJson = [](std::map> const& balances) { + auto const toJson = [](std::map> const& balances) { boost::json::object balancesObj; if (not balances.empty()) { @@ -197,12 +200,12 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, GatewayBalancesH boost::json::array arr; for (auto const& balance : accBalances) { boost::json::object entry; - entry[JS(currency)] = ripple::to_string(balance.issue().currency); + entry[JS(currency)] = xrpl::to_string(balance.get().currency); entry[JS(value)] = balance.getText(); arr.push_back(std::move(entry)); } - balancesObj[ripple::to_string(accId)] = std::move(arr); + balancesObj[xrpl::to_string(accId)] = std::move(arr); } } @@ -223,7 +226,7 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, GatewayBalancesH if (!output.locked.empty()) { boost::json::object lockedObj; for (auto const& [currency, amount] : output.locked) { - lockedObj[ripple::to_string(currency)] = amount.getText(); + lockedObj[xrpl::to_string(currency)] = amount.getText(); } obj[JS(locked)] = std::move(lockedObj); } diff --git a/src/rpc/handlers/GatewayBalances.hpp b/src/rpc/handlers/GatewayBalances.hpp index d354c6325..00c049eca 100644 --- a/src/rpc/handlers/GatewayBalances.hpp +++ b/src/rpc/handlers/GatewayBalances.hpp @@ -69,11 +69,11 @@ public: uint32_t ledgerIndex; std::string accountID; bool overflow = false; - std::map sums; - std::map> hotBalances; - std::map> assets; - std::map> frozenBalances; - std::map locked; + std::map sums; + std::map> hotBalances; + std::map> assets; + std::map> frozenBalances; + std::map locked; // validated should be sent via framework bool validated = true; }; @@ -83,7 +83,7 @@ public: */ struct Input { std::string account; - std::set hotWallets; + std::set hotWallets; std::optional ledgerHash; std::optional ledgerIndex; }; @@ -117,16 +117,16 @@ public: // wallet needs to be an valid accountID or public key auto const wallets = value.is_array() ? value.as_array() : boost::json::array{value}; - auto const getAccountID = [](auto const& j) -> std::optional { + auto const getAccountID = [](auto const& j) -> std::optional { if (j.is_string()) { - auto const pk = util::parseBase58Wrapper( - ripple::TokenType::AccountPublic, boost::json::value_to(j) + auto const pk = util::parseBase58Wrapper( + xrpl::TokenType::AccountPublic, boost::json::value_to(j) ); if (pk) - return ripple::calcAccountID(*pk); + return xrpl::calcAccountID(*pk); - return util::parseBase58Wrapper(boost::json::value_to(j)); + return util::parseBase58Wrapper(boost::json::value_to(j)); } return {}; @@ -149,9 +149,9 @@ public: }; static auto const kSPEC_V1 = - RpcSpec{kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_HOTWALLET)}}}; + RpcSpec{kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(xrpl::RpcInvalidHotwallet)}}}; static auto const kSPEC_V2 = - RpcSpec{kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_PARAMS)}}}; + RpcSpec{kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(xrpl::RpcInvalidParams)}}}; return apiVersion == 1 ? kSPEC_V1 : kSPEC_V2; } diff --git a/src/rpc/handlers/GetAggregatePrice.cpp b/src/rpc/handlers/GetAggregatePrice.cpp index f09e2f7c2..1776b5096 100644 --- a/src/rpc/handlers/GetAggregatePrice.cpp +++ b/src/rpc/handlers/GetAggregatePrice.cpp @@ -76,42 +76,40 @@ GetAggregatePriceHandler::process(GetAggregatePriceHandler::Input const& input, // sorted descending by lastUpdateTime, ascending by AssetPrice using TimestampPricesBiMap = boost::bimaps::bimap< boost::bimaps::multiset_of>, - boost::bimaps::multiset_of>; + boost::bimaps::multiset_of>; TimestampPricesBiMap timestampPricesBiMap; for (auto const& oracle : input.oracles) { - auto const oracleIndex = ripple::keylet::oracle(oracle.account, oracle.documentId).key; + auto const oracleIndex = xrpl::keylet::oracle(oracle.account, oracle.documentId).key; auto const oracleObject = sharedPtrBackend_->fetchLedgerObject(oracleIndex, lgrInfo.seq, ctx.yield); if (not oracleObject) continue; - ripple::STLedgerEntry const oracleSle{ - ripple::SerialIter{oracleObject->data(), oracleObject->size()}, oracleIndex - }; + xrpl::STLedgerEntry const oracleSle{xrpl::SerialIter{oracleObject->data(), oracleObject->size()}, oracleIndex}; tracebackOracleObject(ctx.yield, oracleSle, [&](auto const& node) { - auto const& series = node.getFieldArray(ripple::sfPriceDataSeries); + auto const& series = node.getFieldArray(xrpl::sfPriceDataSeries); // Find the token pair entry with the price if (auto const iter = std::find_if( series.begin(), series.end(), - [&](ripple::STObject const& o) -> bool { - return o.getFieldCurrency(ripple::sfBaseAsset).getText() == input.baseAsset and - o.getFieldCurrency(ripple::sfQuoteAsset).getText() == input.quoteAsset and - o.isFieldPresent(ripple::sfAssetPrice); + [&](xrpl::STObject const& o) -> bool { + return o.getFieldCurrency(xrpl::sfBaseAsset).getText() == input.baseAsset and + o.getFieldCurrency(xrpl::sfQuoteAsset).getText() == input.quoteAsset and + o.isFieldPresent(xrpl::sfAssetPrice); } ); iter != series.end()) { - auto const price = iter->getFieldU64(ripple::sfAssetPrice); + auto const price = iter->getFieldU64(xrpl::sfAssetPrice); // Asset price is after scale, so we need to get the negative of the scale auto const scale = - iter->isFieldPresent(ripple::sfScale) ? -static_cast(iter->getFieldU8(ripple::sfScale)) : 0; + iter->isFieldPresent(xrpl::sfScale) ? -static_cast(iter->getFieldU8(xrpl::sfScale)) : 0; timestampPricesBiMap.insert( TimestampPricesBiMap::value_type( - node.getFieldU32(ripple::sfLastUpdateTime), ripple::STAmount{ripple::noIssue(), price, scale} + node.getFieldU32(xrpl::sfLastUpdateTime), xrpl::STAmount{xrpl::noIssue(), price, scale} ) ); return true; @@ -121,14 +119,14 @@ GetAggregatePriceHandler::process(GetAggregatePriceHandler::Input const& input, } if (timestampPricesBiMap.empty()) - return Error{Status{ripple::rpcOBJECT_NOT_FOUND}}; + return Error{Status{xrpl::RpcObjectNotFound}}; auto const latestTime = timestampPricesBiMap.left.begin()->first; Output out{ .time = latestTime, .trimStats = std::nullopt, - .ledgerHash = ripple::to_string(lgrInfo.hash), + .ledgerHash = xrpl::to_string(lgrInfo.hash), .ledgerIndex = lgrInfo.seq, .median = "" }; @@ -146,15 +144,14 @@ GetAggregatePriceHandler::process(GetAggregatePriceHandler::Input const& input, auto const getStats = [](TimestampPricesBiMap::right_const_iterator begin, TimestampPricesBiMap::right_const_iterator end) -> Stats { - ripple::STAmount avg{ripple::noIssue(), 0, 0}; - ripple::Number sd{0}; + xrpl::STAmount avg{xrpl::noIssue(), 0, 0}; + xrpl::Number sd{0}; std::uint16_t const size = std::distance(begin, end); - avg = std::accumulate(begin, end, avg, [&](ripple::STAmount const& acc, auto const& it) { - return acc + it.first; - }); - avg = divide(avg, ripple::STAmount{ripple::noIssue(), size, 0}, ripple::noIssue()); + avg = + std::accumulate(begin, end, avg, [&](xrpl::STAmount const& acc, auto const& it) { return acc + it.first; }); + avg = divide(avg, xrpl::STAmount{xrpl::noIssue(), size, 0}, xrpl::noIssue()); if (size > 1) { - sd = std::accumulate(begin, end, sd, [&](ripple::Number const& acc, auto const& it) { + sd = std::accumulate(begin, end, sd, [&](xrpl::Number const& acc, auto const& it) { return acc + ((it.first - avg) * (it.first - avg)); }); sd = root2(sd / (size - 1)); @@ -182,11 +179,11 @@ GetAggregatePriceHandler::process(GetAggregatePriceHandler::Input const& input, auto const median = [&, size = out.extireStats.size]() { auto const middle = size / 2; if ((size % 2) == 0) { - static ripple::STAmount const kTWO{ripple::noIssue(), 2, 0}; + static xrpl::STAmount const kTWO{xrpl::noIssue(), 2, 0}; auto it = itAdvance(timestampPricesBiMap.right.begin(), middle - 1); auto const& a1 = it->first; auto const& a2 = (++it)->first; - return divide(a1 + a2, kTWO, ripple::noIssue()); + return divide(a1 + a2, kTWO, xrpl::noIssue()); } return itAdvance(timestampPricesBiMap.right.begin(), middle)->first; }(); @@ -198,14 +195,14 @@ GetAggregatePriceHandler::process(GetAggregatePriceHandler::Input const& input, void GetAggregatePriceHandler::tracebackOracleObject( boost::asio::yield_context yield, - ripple::STObject const& oracleObject, - std::function const& callback + xrpl::STObject const& oracleObject, + std::function const& callback ) const { static constexpr auto kHISTORY_MAX = 3; - std::optional optOracleObject = oracleObject; - std::optional optCurrentObject = optOracleObject; + std::optional optOracleObject = oracleObject; + std::optional optCurrentObject = optOracleObject; bool isNew = false; bool noOracleFound = false; @@ -223,7 +220,7 @@ GetAggregatePriceHandler::tracebackOracleObject( if (++history > kHISTORY_MAX) return; - auto const prevTxIndex = optCurrentObject->getFieldH256(ripple::sfPreviousTxnID); + auto const prevTxIndex = optCurrentObject->getFieldH256(xrpl::sfPreviousTxnID); auto const prevTx = sharedPtrBackend_->fetchTransaction(prevTxIndex, yield); if (not prevTx) @@ -232,13 +229,13 @@ GetAggregatePriceHandler::tracebackOracleObject( noOracleFound = true; auto const [_, meta] = deserializeTxPlusMeta(*prevTx); - for (ripple::STObject const& node : meta->getFieldArray(ripple::sfAffectedNodes)) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltORACLE) { + for (xrpl::STObject const& node : meta->getFieldArray(xrpl::sfAffectedNodes)) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltORACLE) { continue; } noOracleFound = false; optCurrentObject = node; - isNew = node.isFieldPresent(ripple::sfNewFields); + isNew = node.isFieldPresent(xrpl::sfNewFields); // if a meta is for the new and this is the first // look-up then it's the meta for the tx that // created the current object; i.e. there is no @@ -246,8 +243,8 @@ GetAggregatePriceHandler::tracebackOracleObject( if (isNew and history == 1) return; - optOracleObject = isNew ? dynamic_cast(node.peekAtField(ripple::sfNewFields)) - : dynamic_cast(node.peekAtField(ripple::sfFinalFields)); + optOracleObject = isNew ? dynamic_cast(node.peekAtField(xrpl::sfNewFields)) + : dynamic_cast(node.peekAtField(xrpl::sfFinalFields)); break; } @@ -273,7 +270,7 @@ tag_invoke(boost::json::value_to_tag, boost::js input.oracles.push_back( GetAggregatePriceHandler::Oracle{ .documentId = boost::json::value_to(oracle.as_object().at(JS(oracle_document_id))), - .account = *util::parseBase58Wrapper( + .account = *util::parseBase58Wrapper( boost::json::value_to(oracle.as_object().at(JS(account))) ) } @@ -302,7 +299,7 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, GetAggregatePric {JS(entire_set), boost::json::object{ {JS(mean), output.extireStats.avg.getText()}, - {JS(standard_deviation), ripple::to_string(output.extireStats.sd)}, + {JS(standard_deviation), xrpl::to_string(output.extireStats.sd)}, {JS(size), output.extireStats.size} }}, {JS(median), output.median} @@ -311,7 +308,7 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, GetAggregatePric if (output.trimStats) { jv.as_object()[JS(trimmed_set)] = boost::json::object{ {JS(mean), output.trimStats->avg.getText()}, - {JS(standard_deviation), ripple::to_string(output.trimStats->sd)}, + {JS(standard_deviation), xrpl::to_string(output.trimStats->sd)}, {JS(size), output.trimStats->size} }; } diff --git a/src/rpc/handlers/GetAggregatePrice.hpp b/src/rpc/handlers/GetAggregatePrice.hpp index 9d2953493..eb05732a4 100644 --- a/src/rpc/handlers/GetAggregatePrice.hpp +++ b/src/rpc/handlers/GetAggregatePrice.hpp @@ -58,9 +58,9 @@ public: * @brief A struct to hold the statistics */ struct Stats { - ripple::STAmount avg{}; // NOLINT(readability-redundant-member-init) + xrpl::STAmount avg{}; // NOLINT(readability-redundant-member-init) // standard deviation - ripple::Number sd{}; // NOLINT(readability-redundant-member-init) + xrpl::Number sd{}; // NOLINT(readability-redundant-member-init) uint32_t size{0}; }; @@ -82,7 +82,7 @@ public: */ struct Oracle { std::uint32_t documentId{0}; - ripple::AccountID account; + xrpl::AccountID account; }; /** @@ -124,12 +124,12 @@ public: static auto const kORACLES_VALIDATOR = modifiers::CustomModifier{[](boost::json::value& value, std::string_view) -> MaybeError { if (!value.is_array() or value.as_array().empty() or value.as_array().size() > kORACLES_MAX) - return Error{Status{RippledError::rpcORACLE_MALFORMED}}; + return Error{Status{RippledError::RpcOracleMalformed}}; for (auto& oracle : value.as_array()) { if (!oracle.is_object() or !oracle.as_object().contains(JS(oracle_document_id)) or !oracle.as_object().contains(JS(account))) - return Error{Status{RippledError::rpcORACLE_MALFORMED}}; + return Error{Status{RippledError::RpcOracleMalformed}}; auto maybeError = validation::Type{}.verify(oracle, JS(oracle_document_id)); @@ -143,7 +143,7 @@ public: maybeError = validation::CustomValidators::accountBase58Validator.verify(oracle.as_object(), JS(account)); if (!maybeError) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; }; return MaybeError{}; @@ -158,12 +158,12 @@ public: {JS(base_asset), validation::Required{}, meta::WithCustomError{ - validation::CustomValidators::currencyValidator, Status(RippledError::rpcINVALID_PARAMS) + validation::CustomValidators::currencyValidator, Status(RippledError::RpcInvalidParams) }}, {JS(quote_asset), validation::Required{}, meta::WithCustomError{ - validation::CustomValidators::currencyValidator, Status(RippledError::rpcINVALID_PARAMS) + validation::CustomValidators::currencyValidator, Status(RippledError::RpcInvalidParams) }}, {JS(oracles), validation::Required{}, kORACLES_VALIDATOR}, // note: Unlike `rippled`, Clio only supports UInt as input, no string, no `null`, etc. @@ -197,8 +197,8 @@ private: void tracebackOracleObject( boost::asio::yield_context yield, - ripple::STObject const& oracleObject, - std::function const& callback + xrpl::STObject const& oracleObject, + std::function const& callback ) const; /** diff --git a/src/rpc/handlers/Ledger.cpp b/src/rpc/handlers/Ledger.cpp index 69923636c..386739c2c 100644 --- a/src/rpc/handlers/Ledger.cpp +++ b/src/rpc/handlers/Ledger.cpp @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -82,7 +83,7 @@ LedgerHandler::process(LedgerHandler::Input const& input, Context const& ctx) co return toJsonWithBinaryTx(tx, ctx.apiVersion); }; - auto const isoTimeStr = ripple::to_string_iso(lgrInfo.closeTime); + auto const isoTimeStr = xrpl::toStringIso(lgrInfo.closeTime); auto const expandTxJsonV2 = [&](data::TransactionAndMetadata const& tx) { auto [txn, meta] = toExpandedJson(tx, ctx.apiVersion); @@ -97,7 +98,7 @@ LedgerHandler::process(LedgerHandler::Input const& input, Context const& ctx) co } entry[JS(close_time_iso)] = isoTimeStr; - entry[JS(ledger_hash)] = ripple::strHex(lgrInfo.hash); + entry[JS(ledger_hash)] = xrpl::strHex(lgrInfo.hash); if (txn.contains(JS(hash))) { entry[JS(hash)] = txn.at(JS(hash)); txn.erase(JS(hash)); @@ -123,10 +124,10 @@ LedgerHandler::process(LedgerHandler::Input const& input, Context const& ctx) co if (input.ownerFunds) { // check the type of tx auto const [tx, meta] = rpc::deserializeTxPlusMeta(obj); - if (tx and tx->isFieldPresent(ripple::sfTransactionType) and - tx->getTxnType() == ripple::ttOFFER_CREATE) { - auto const account = tx->getAccountID(ripple::sfAccount); - auto const amount = tx->getFieldAmount(ripple::sfTakerGets); + if (tx and tx->isFieldPresent(xrpl::sfTransactionType) and + tx->getTxnType() == xrpl::ttOFFER_CREATE) { + auto const account = tx->getAccountID(xrpl::sfAccount); + auto const amount = tx->getFieldAmount(xrpl::sfTakerGets); // If the offer create is not self funded then add the // owner balance @@ -136,7 +137,7 @@ LedgerHandler::process(LedgerHandler::Input const& input, Context const& ctx) co *amendmentCenter_, lgrInfo.seq, account, - amount.getCurrency(), + amount.template get().currency, amount.getIssuer(), false, // fhIGNORE_FREEZE from rippled ctx.yield @@ -154,7 +155,7 @@ LedgerHandler::process(LedgerHandler::Input const& input, Context const& ctx) co std::move_iterator(hashes.begin()), std::move_iterator(hashes.end()), std::back_inserter(jsonTxs), - [](auto hash) { return boost::json::string(ripple::strHex(hash)); } + [](auto hash) { return boost::json::string(xrpl::strHex(hash)); } ); } } @@ -167,12 +168,12 @@ LedgerHandler::process(LedgerHandler::Input const& input, Context const& ctx) co for (auto const& obj : diff) { boost::json::object entry; - entry["object_id"] = ripple::strHex(obj.key); + entry["object_id"] = xrpl::strHex(obj.key); if (input.binary) { - entry["object"] = ripple::strHex(obj.blob); + entry["object"] = xrpl::strHex(obj.blob); } else if (!obj.blob.empty()) { - ripple::STLedgerEntry const sle{ripple::SerialIter{obj.blob.data(), obj.blob.size()}, obj.key}; + xrpl::STLedgerEntry const sle{xrpl::SerialIter{obj.blob.data(), obj.blob.size()}, obj.key}; entry["object"] = toJson(sle); } else { entry["object"] = ""; @@ -182,7 +183,7 @@ LedgerHandler::process(LedgerHandler::Input const& input, Context const& ctx) co } } - output.ledgerHash = ripple::strHex(lgrInfo.hash); + output.ledgerHash = xrpl::strHex(lgrInfo.hash); output.ledgerIndex = lgrInfo.seq; return output; diff --git a/src/rpc/handlers/LedgerData.cpp b/src/rpc/handlers/LedgerData.cpp index 9b35eed9b..e931aca4e 100644 --- a/src/rpc/handlers/LedgerData.cpp +++ b/src/rpc/handlers/LedgerData.cpp @@ -57,10 +57,10 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const { // marker must be int if outOfOrder is true if (input.outOfOrder && input.marker) - return Error{Status{RippledError::rpcINVALID_PARAMS, "outOfOrderMarkerNotInt"}}; + return Error{Status{RippledError::RpcInvalidParams, "outOfOrderMarkerNotInt"}}; if (!input.outOfOrder && input.diffMarker) - return Error{Status{RippledError::rpcINVALID_PARAMS, "markerNotString"}}; + return Error{Status{RippledError::RpcInvalidParams, "markerNotString"}}; auto const range = sharedPtrBackend_->fetchLedgerRange(); ASSERT(range.has_value(), "LedgerData's ledger range must be available"); @@ -81,10 +81,10 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const output.header = toJson(lgrInfo, input.binary, ctx.apiVersion); } else { if (input.marker && !sharedPtrBackend_->fetchLedgerObject(*(input.marker), lgrInfo.seq, ctx.yield)) - return Error{Status{RippledError::rpcINVALID_PARAMS, "markerDoesNotExist"}}; + return Error{Status{RippledError::RpcInvalidParams, "markerDoesNotExist"}}; } - output.ledgerHash = ripple::strHex(lgrInfo.hash); + output.ledgerHash = xrpl::strHex(lgrInfo.hash); output.ledgerIndex = lgrInfo.seq; auto const start = std::chrono::system_clock::now(); @@ -93,7 +93,7 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const if (input.diffMarker) { // keep the same logic as previous implementation auto diff = sharedPtrBackend_->fetchLedgerDiff(*(input.diffMarker), ctx.yield); - std::vector keys; + std::vector keys; for (auto& [key, object] : diff) { if (object.empty()) @@ -119,7 +119,7 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const results = std::move(page.objects); if (page.cursor) { - output.marker = ripple::strHex(*(page.cursor)); + output.marker = xrpl::strHex(*(page.cursor)); } else if (input.outOfOrder) { output.diffMarker = range->maxSequence; } @@ -132,14 +132,14 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const output.states.reserve(results.size()); for (auto const& [key, object] : results) { - ripple::STLedgerEntry const sle{ripple::SerialIter{object.data(), object.size()}, key}; + xrpl::STLedgerEntry const sle{xrpl::SerialIter{object.data(), object.size()}, key}; // note the filter is after limit is applied, same as rippled - if (input.type == ripple::LedgerEntryType::ltANY || sle.getType() == input.type) { + if (input.type == xrpl::LedgerEntryType::ltANY || sle.getType() == input.type) { if (input.binary) { boost::json::object entry; - entry[JS(data)] = ripple::serializeHex(sle); - entry[JS(index)] = ripple::to_string(sle.key()); + entry[JS(data)] = xrpl::serializeHex(sle); + entry[JS(index)] = xrpl::to_string(sle.key()); output.states.push_back(std::move(entry)); } else { output.states.push_back(toJson(sle)); @@ -201,7 +201,7 @@ tag_invoke(boost::json::value_to_tag, boost::json::val if (jsonObject.contains(JS(marker))) { if (jsonObject.at(JS(marker)).is_string()) { - input.marker = ripple::uint256{boost::json::value_to(jsonObject.at(JS(marker))).data()}; + input.marker = xrpl::uint256{boost::json::value_to(jsonObject.at(JS(marker))).data()}; } else { input.diffMarker = util::integralValueAs(jsonObject.at(JS(marker))); } diff --git a/src/rpc/handlers/LedgerData.hpp b/src/rpc/handlers/LedgerData.hpp index 5fbc8ba6b..b3c58e0ed 100644 --- a/src/rpc/handlers/LedgerData.hpp +++ b/src/rpc/handlers/LedgerData.hpp @@ -84,10 +84,10 @@ public: std::optional ledgerIndex; bool binary = false; uint32_t limit = LedgerDataHandler::kLIMIT_JSON; // max 256 for json ; 2048 for binary - std::optional marker; + std::optional marker; std::optional diffMarker; bool outOfOrder = false; - ripple::LedgerEntryType type = ripple::LedgerEntryType::ltANY; + xrpl::LedgerEntryType type = xrpl::LedgerEntryType::ltANY; }; using Result = HandlerReturnType; diff --git a/src/rpc/handlers/LedgerEntry.cpp b/src/rpc/handlers/LedgerEntry.cpp index fa173fc5c..a235f9c50 100644 --- a/src/rpc/handlers/LedgerEntry.cpp +++ b/src/rpc/handlers/LedgerEntry.cpp @@ -61,16 +61,16 @@ namespace rpc { LedgerEntryHandler::Result LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context const& ctx) const { - ripple::uint256 key; + xrpl::uint256 key; if (input.index) { - key = ripple::uint256{std::string_view(*(input.index))}; + key = xrpl::uint256{std::string_view(*(input.index))}; if (key.isZero()) - return Error{Status{RippledError::rpcENTRY_NOT_FOUND}}; + return Error{Status{RippledError::RpcEntryNotFound}}; } else if (input.accountRoot) { - key = ripple::keylet::account(*util::parseBase58Wrapper(*(input.accountRoot))).key; + key = xrpl::keylet::account(*util::parseBase58Wrapper(*(input.accountRoot))).key; } else if (input.did) { - key = ripple::keylet::did(*util::parseBase58Wrapper(*(input.did))).key; + key = xrpl::keylet::did(*util::parseBase58Wrapper(*(input.did))).key; } else if (input.directory) { auto const expectedkey = composeKeyFromDirectory(*input.directory); if (!expectedkey.has_value()) @@ -78,28 +78,26 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons key = expectedkey.value(); } else if (input.offer) { - auto const id = util::parseBase58Wrapper( - boost::json::value_to(input.offer->at(JS(account))) - ); - key = ripple::keylet::offer(*id, boost::json::value_to(input.offer->at(JS(seq)))).key; + auto const id = + util::parseBase58Wrapper(boost::json::value_to(input.offer->at(JS(account)))); + key = xrpl::keylet::offer(*id, boost::json::value_to(input.offer->at(JS(seq)))).key; } else if (input.rippleStateAccount) { - auto const id1 = util::parseBase58Wrapper( + auto const id1 = util::parseBase58Wrapper( boost::json::value_to(input.rippleStateAccount->at(JS(accounts)).as_array().at(0)) ); - auto const id2 = util::parseBase58Wrapper( + auto const id2 = util::parseBase58Wrapper( boost::json::value_to(input.rippleStateAccount->at(JS(accounts)).as_array().at(1)) ); auto const currency = - ripple::to_currency(boost::json::value_to(input.rippleStateAccount->at(JS(currency)))); + xrpl::toCurrency(boost::json::value_to(input.rippleStateAccount->at(JS(currency)))); - key = ripple::keylet::line(*id1, *id2, currency).key; + key = xrpl::keylet::line(*id1, *id2, currency).key; } else if (input.escrow) { - auto const id = util::parseBase58Wrapper( - boost::json::value_to(input.escrow->at(JS(owner))) - ); - key = ripple::keylet::escrow(*id, util::integralValueAs(input.escrow->at(JS(seq)))).key; + auto const id = + util::parseBase58Wrapper(boost::json::value_to(input.escrow->at(JS(owner)))); + key = xrpl::keylet::escrow(*id, util::integralValueAs(input.escrow->at(JS(seq)))).key; } else if (input.depositPreauth) { - auto const owner = util::parseBase58Wrapper( + auto const owner = util::parseBase58Wrapper( boost::json::value_to(input.depositPreauth->at(JS(owner))) ); // Only one of authorize or authorized_credentials MUST exist; @@ -111,10 +109,10 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons } if (input.depositPreauth->contains(JS(authorized))) { - auto const authorized = util::parseBase58Wrapper( + auto const authorized = util::parseBase58Wrapper( boost::json::value_to(input.depositPreauth->at(JS(authorized))) ); - key = ripple::keylet::depositPreauth(*owner, *authorized).key; + key = xrpl::keylet::depositPreauth(*owner, *authorized).key; } else { auto const authorizedCredentials = rpc::credentials::parseAuthorizeCredentials( input.depositPreauth->at(JS(authorized_credentials)).as_array() @@ -124,86 +122,82 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons if (authCreds.size() != authorizedCredentials.size()) return Error{Status{ClioError::RpcMalformedAuthorizedCredentials, "duplicates in credentials."}}; - key = ripple::keylet::depositPreauth(owner.value(), authCreds).key; + key = xrpl::keylet::depositPreauth(owner.value(), authCreds).key; } } else if (input.ticket) { - auto const id = util::parseBase58Wrapper( + auto const id = util::parseBase58Wrapper( boost::json::value_to(input.ticket->at(JS(account))) ); - key = ripple::getTicketIndex(*id, util::integralValueAs(input.ticket->at(JS(ticket_seq)))); + key = xrpl::getTicketIndex(*id, util::integralValueAs(input.ticket->at(JS(ticket_seq)))); } else if (input.amm) { auto const getIssuerFromJson = [](auto const& assetJson) { // the field check has been done in validator - auto const currency = ripple::to_currency(boost::json::value_to(assetJson.at(JS(currency)))); - if (ripple::isXRP(currency)) { - return ripple::xrpIssue(); + auto const currency = xrpl::toCurrency(boost::json::value_to(assetJson.at(JS(currency)))); + if (xrpl::isXRP(currency)) { + return xrpl::xrpIssue(); } - auto const issuer = util::parseBase58Wrapper( - boost::json::value_to(assetJson.at(JS(issuer))) - ); - return ripple::Issue{currency, *issuer}; + auto const issuer = + util::parseBase58Wrapper(boost::json::value_to(assetJson.at(JS(issuer)))); + return xrpl::Issue{currency, *issuer}; }; - key = ripple::keylet::amm( - getIssuerFromJson(input.amm->at(JS(asset))), getIssuerFromJson(input.amm->at(JS(asset2))) - ) - .key; + key = + xrpl::keylet::amm(getIssuerFromJson(input.amm->at(JS(asset))), getIssuerFromJson(input.amm->at(JS(asset2)))) + .key; } else if (input.bridge) { if (!input.bridgeAccount && !input.chainClaimId && !input.createAccountClaimId) return Error{Status{ClioError::RpcMalformedRequest}}; if (input.bridgeAccount) { - auto const bridgeAccount = util::parseBase58Wrapper(*(input.bridgeAccount)); - auto const chainType = ripple::STXChainBridge::srcChain(bridgeAccount == input.bridge->lockingChainDoor()); + auto const bridgeAccount = util::parseBase58Wrapper(*(input.bridgeAccount)); + auto const chainType = xrpl::STXChainBridge::srcChain(bridgeAccount == input.bridge->lockingChainDoor()); if (bridgeAccount != input.bridge->door(chainType)) return Error{Status{ClioError::RpcMalformedRequest}}; - key = ripple::keylet::bridge(input.bridge->value(), chainType).key; + key = xrpl::keylet::bridge(input.bridge->value(), chainType).key; } else if (input.chainClaimId) { - key = ripple::keylet::xChainClaimID(input.bridge->value(), input.chainClaimId.value()).key; + key = xrpl::keylet::xChainClaimID(input.bridge->value(), input.chainClaimId.value()).key; } else { - key = ripple::keylet::xChainCreateAccountClaimID(input.bridge->value(), input.createAccountClaimId.value()) - .key; + key = + xrpl::keylet::xChainCreateAccountClaimID(input.bridge->value(), input.createAccountClaimId.value()).key; } } else if (input.oracleNode) { key = input.oracleNode.value(); } else if (input.credential) { key = input.credential.value(); } else if (input.mptIssuance) { - auto const mptIssuanceID = ripple::uint192{std::string_view(*(input.mptIssuance))}; - key = ripple::keylet::mptIssuance(mptIssuanceID).key; + auto const mptIssuanceID = xrpl::uint192{std::string_view(*(input.mptIssuance))}; + key = xrpl::keylet::mptIssuance(mptIssuanceID).key; } else if (input.mptoken) { auto const holder = - ripple::parseBase58(boost::json::value_to(input.mptoken->at(JS(account)))); - auto const mptIssuanceID = ripple::uint192{ - std::string_view(boost::json::value_to(input.mptoken->at(JS(mpt_issuance_id)))) - }; - key = ripple::keylet::mptoken(mptIssuanceID, *holder).key; + xrpl::parseBase58(boost::json::value_to(input.mptoken->at(JS(account)))); + auto const mptIssuanceID = + xrpl::uint192{std::string_view(boost::json::value_to(input.mptoken->at(JS(mpt_issuance_id))))}; + key = xrpl::keylet::mptoken(mptIssuanceID, *holder).key; } else if (input.permissionedDomain) { - auto const account = ripple::parseBase58( + auto const account = xrpl::parseBase58( boost::json::value_to(input.permissionedDomain->at(JS(account))) ); auto const seq = util::integralValueAs(input.permissionedDomain->at(JS(seq))); - key = ripple::keylet::permissionedDomain(*account, seq).key; + key = xrpl::keylet::permissionedDomain(*account, seq).key; } else if (input.vault) { auto const account = - ripple::parseBase58(boost::json::value_to(input.vault->at(JS(owner)))); + xrpl::parseBase58(boost::json::value_to(input.vault->at(JS(owner)))); auto const seq = util::integralValueAs(input.vault->at(JS(seq))); - key = ripple::keylet::vault(*account, seq).key; + key = xrpl::keylet::vault(*account, seq).key; } else if (input.delegate) { auto const account = - ripple::parseBase58(boost::json::value_to(input.delegate->at(JS(account)))); - auto const authorize = ripple::parseBase58( - boost::json::value_to(input.delegate->at(JS(authorize))) - ); - key = ripple::keylet::delegate(*account, *authorize).key; + xrpl::parseBase58(boost::json::value_to(input.delegate->at(JS(account)))); + auto const authorize = + xrpl::parseBase58(boost::json::value_to(input.delegate->at(JS(authorize)))); + key = xrpl::keylet::delegate(*account, *authorize).key; } else { // Must specify 1 of the following fields to indicate what type if (ctx.apiVersion == 1) return Error{Status{ClioError::RpcUnknownOption}}; - return Error{Status{RippledError::rpcINVALID_PARAMS, "No ledger_entry params provided."}}; + return Error{Status{RippledError::RpcInvalidParams, "No ledger_entry params provided."}}; } // check ledger exists @@ -222,27 +216,27 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons if (!ledgerObject || ledgerObject->empty()) { if (not input.includeDeleted) - return Error{Status{RippledError::rpcENTRY_NOT_FOUND}}; + return Error{Status{RippledError::RpcEntryNotFound}}; auto const deletedSeq = sharedPtrBackend_->fetchLedgerObjectSeq(key, lgrInfo.seq, ctx.yield); if (!deletedSeq) - return Error{Status{RippledError::rpcENTRY_NOT_FOUND}}; + return Error{Status{RippledError::RpcEntryNotFound}}; ledgerObject = sharedPtrBackend_->fetchLedgerObject(key, deletedSeq.value() - 1, ctx.yield); if (!ledgerObject || ledgerObject->empty()) - return Error{Status{RippledError::rpcENTRY_NOT_FOUND}}; + return Error{Status{RippledError::RpcEntryNotFound}}; output.deletedLedgerIndex = deletedSeq; } - ripple::STLedgerEntry const sle{ripple::SerialIter{ledgerObject->data(), ledgerObject->size()}, key}; + xrpl::STLedgerEntry const sle{xrpl::SerialIter{ledgerObject->data(), ledgerObject->size()}, key}; - if (input.expectedType != ripple::ltANY && sle.getType() != input.expectedType) - return Error{Status{RippledError::rpcUNEXPECTED_LEDGER_TYPE}}; + if (input.expectedType != xrpl::ltANY && sle.getType() != input.expectedType) + return Error{Status{RippledError::RpcUnexpectedLedgerType}}; - output.index = ripple::strHex(key); + output.index = xrpl::strHex(key); output.ledgerIndex = lgrInfo.seq; - output.ledgerHash = ripple::strHex(lgrInfo.hash); + output.ledgerHash = xrpl::strHex(lgrInfo.hash); if (input.binary) { - output.nodeBinary = ripple::strHex(*ledgerObject); + output.nodeBinary = xrpl::strHex(*ledgerObject); } else { output.node = toJson(sle); } @@ -250,28 +244,28 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons return output; } -std::expected +std::expected LedgerEntryHandler::composeKeyFromDirectory(boost::json::object const& directory) noexcept { // can not specify both dir_root and owner. if (directory.contains(JS(dir_root)) && directory.contains(JS(owner))) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "mayNotSpecifyBothDirRootAndOwner"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "mayNotSpecifyBothDirRootAndOwner"}}; // at least one should available if (!(directory.contains(JS(dir_root)) || directory.contains(JS(owner)))) - return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "missingOwnerOrDirRoot"}}; + return std::unexpected{Status{RippledError::RpcInvalidParams, "missingOwnerOrDirRoot"}}; uint64_t const subIndex = directory.contains(JS(sub_index)) ? boost::json::value_to(directory.at(JS(sub_index))) : 0; if (directory.contains(JS(dir_root))) { - ripple::uint256 const uDirRoot{boost::json::value_to(directory.at(JS(dir_root))).data()}; - return ripple::keylet::page(uDirRoot, subIndex).key; + xrpl::uint256 const uDirRoot{boost::json::value_to(directory.at(JS(dir_root))).data()}; + return xrpl::keylet::page(uDirRoot, subIndex).key; } auto const ownerID = - util::parseBase58Wrapper(boost::json::value_to(directory.at(JS(owner)))); - return ripple::keylet::page(ripple::keylet::ownerDir(*ownerID), subIndex).key; + util::parseBase58Wrapper(boost::json::value_to(directory.at(JS(owner)))); + return xrpl::keylet::page(xrpl::keylet::ownerDir(*ownerID), subIndex).key; } void @@ -315,64 +309,62 @@ tag_invoke(boost::json::value_to_tag, boost::json::va input.binary = jv.at(JS(binary)).as_bool(); // check all the potential index - static auto const kINDEX_FIELD_TYPE_MAP = std::unordered_map{ - {JS(index), ripple::ltANY}, - {JS(directory), ripple::ltDIR_NODE}, - {JS(offer), ripple::ltOFFER}, - {JS(check), ripple::ltCHECK}, - {JS(escrow), ripple::ltESCROW}, - {JS(payment_channel), ripple::ltPAYCHAN}, - {JS(deposit_preauth), ripple::ltDEPOSIT_PREAUTH}, - {JS(ticket), ripple::ltTICKET}, - {JS(nft_page), ripple::ltNFTOKEN_PAGE}, - {JS(amm), ripple::ltAMM}, - {JS(xchain_owned_create_account_claim_id), ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, - {JS(xchain_owned_claim_id), ripple::ltXCHAIN_OWNED_CLAIM_ID}, - {JS(oracle), ripple::ltORACLE}, - {JS(credential), ripple::ltCREDENTIAL}, - {JS(mptoken), ripple::ltMPTOKEN}, - {JS(permissioned_domain), ripple::ltPERMISSIONED_DOMAIN}, - {JS(vault), ripple::ltVAULT}, - {JS(delegate), ripple::ltDELEGATE}, - {JS(amendments), ripple::ltAMENDMENTS}, - {JS(fee), ripple::ltFEE_SETTINGS}, - {JS(hashes), ripple::ltLEDGER_HASHES}, - {JS(nft_offer), ripple::ltNFTOKEN_OFFER}, - {JS(nunl), ripple::ltNEGATIVE_UNL}, - {JS(signer_list), ripple::ltSIGNER_LIST} + static auto const kINDEX_FIELD_TYPE_MAP = std::unordered_map{ + {JS(index), xrpl::ltANY}, + {JS(directory), xrpl::ltDIR_NODE}, + {JS(offer), xrpl::ltOFFER}, + {JS(check), xrpl::ltCHECK}, + {JS(escrow), xrpl::ltESCROW}, + {JS(payment_channel), xrpl::ltPAYCHAN}, + {JS(deposit_preauth), xrpl::ltDEPOSIT_PREAUTH}, + {JS(ticket), xrpl::ltTICKET}, + {JS(nft_page), xrpl::ltNFTOKEN_PAGE}, + {JS(amm), xrpl::ltAMM}, + {JS(xchain_owned_create_account_claim_id), xrpl::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, + {JS(xchain_owned_claim_id), xrpl::ltXCHAIN_OWNED_CLAIM_ID}, + {JS(oracle), xrpl::ltORACLE}, + {JS(credential), xrpl::ltCREDENTIAL}, + {JS(mptoken), xrpl::ltMPTOKEN}, + {JS(permissioned_domain), xrpl::ltPERMISSIONED_DOMAIN}, + {JS(vault), xrpl::ltVAULT}, + {JS(delegate), xrpl::ltDELEGATE}, + {JS(amendments), xrpl::ltAMENDMENTS}, + {JS(fee), xrpl::ltFEE_SETTINGS}, + {JS(hashes), xrpl::ltLEDGER_HASHES}, + {JS(nft_offer), xrpl::ltNFTOKEN_OFFER}, + {JS(nunl), xrpl::ltNEGATIVE_UNL}, + {JS(signer_list), xrpl::ltSIGNER_LIST} }; auto const parseBridgeFromJson = [](boost::json::value const& bridgeJson) { - auto const lockingDoor = *util::parseBase58Wrapper( - boost::json::value_to(bridgeJson.at(ripple::sfLockingChainDoor.getJsonName().c_str())) + auto const lockingDoor = *util::parseBase58Wrapper( + boost::json::value_to(bridgeJson.at(xrpl::sfLockingChainDoor.getJsonName().cStr())) ); - auto const issuingDoor = *util::parseBase58Wrapper( - boost::json::value_to(bridgeJson.at(ripple::sfIssuingChainDoor.getJsonName().c_str())) + auto const issuingDoor = *util::parseBase58Wrapper( + boost::json::value_to(bridgeJson.at(xrpl::sfIssuingChainDoor.getJsonName().cStr())) ); - auto const lockingIssue = - parseIssue(bridgeJson.at(ripple::sfLockingChainIssue.getJsonName().c_str()).as_object()); - auto const issuingIssue = - parseIssue(bridgeJson.at(ripple::sfIssuingChainIssue.getJsonName().c_str()).as_object()); + auto const lockingIssue = parseIssue(bridgeJson.at(xrpl::sfLockingChainIssue.getJsonName().cStr()).as_object()); + auto const issuingIssue = parseIssue(bridgeJson.at(xrpl::sfIssuingChainIssue.getJsonName().cStr()).as_object()); - return ripple::STXChainBridge{lockingDoor, lockingIssue, issuingDoor, issuingIssue}; + return xrpl::STXChainBridge{lockingDoor, lockingIssue, issuingDoor, issuingIssue}; }; auto const parseOracleFromJson = [](boost::json::value const& json) { auto const account = - util::parseBase58Wrapper(boost::json::value_to(json.at(JS(account)))); + util::parseBase58Wrapper(boost::json::value_to(json.at(JS(account)))); auto const documentId = boost::json::value_to(json.at(JS(oracle_document_id))); - return ripple::keylet::oracle(*account, documentId).key; + return xrpl::keylet::oracle(*account, documentId).key; }; auto const parseCredentialFromJson = [](boost::json::value const& json) { auto const subject = - util::parseBase58Wrapper(boost::json::value_to(json.at(JS(subject)))); + util::parseBase58Wrapper(boost::json::value_to(json.at(JS(subject)))); auto const issuer = - util::parseBase58Wrapper(boost::json::value_to(json.at(JS(issuer)))); - auto const credType = ripple::strUnHex(boost::json::value_to(json.at(JS(credential_type)))); + util::parseBase58Wrapper(boost::json::value_to(json.at(JS(issuer)))); + auto const credType = xrpl::strUnHex(boost::json::value_to(json.at(JS(credential_type)))); - return ripple::keylet::credential(*subject, *issuer, ripple::Slice(credType->data(), credType->size())).key; + return xrpl::keylet::credential(*subject, *issuer, xrpl::Slice(credType->data(), credType->size())).key; }; auto const indexFieldType = std::ranges::find_if(kINDEX_FIELD_TYPE_MAP, [&jsonObject](auto const& pair) { diff --git a/src/rpc/handlers/LedgerEntry.hpp b/src/rpc/handlers/LedgerEntry.hpp index 4280d569c..0d70979a1 100644 --- a/src/rpc/handlers/LedgerEntry.hpp +++ b/src/rpc/handlers/LedgerEntry.hpp @@ -87,7 +87,7 @@ public: std::optional index; // index can be extracted from payment_channel, check, escrow, offer // etc, expectedType is used to save the type of index - ripple::LedgerEntryType expectedType = ripple::ltANY; + xrpl::LedgerEntryType expectedType = xrpl::ltANY; // account id to address account root object std::optional accountRoot; // account id to address did object @@ -105,12 +105,12 @@ public: std::optional mptoken; std::optional permissionedDomain; std::optional vault; - std::optional bridge; + std::optional bridge; std::optional bridgeAccount; std::optional chainClaimId; std::optional createAccountClaimId; - std::optional oracleNode; - std::optional credential; + std::optional oracleNode; + std::optional credential; std::optional delegate; bool includeDeleted = false; }; @@ -143,15 +143,13 @@ public: if (!value.is_array() || value.as_array().size() != 2 || !value.as_array()[0].is_string() || !value.as_array()[1].is_string() || value.as_array()[0].as_string() == value.as_array()[1].as_string()) { - return Error{Status{RippledError::rpcINVALID_PARAMS, "malformedAccounts"}}; + return Error{Status{RippledError::RpcInvalidParams, "malformedAccounts"}}; } - auto const id1 = util::parseBase58Wrapper( - boost::json::value_to(value.as_array()[0]) - ); - auto const id2 = util::parseBase58Wrapper( - boost::json::value_to(value.as_array()[1]) - ); + auto const id1 = + util::parseBase58Wrapper(boost::json::value_to(value.as_array()[0])); + auto const id2 = + util::parseBase58Wrapper(boost::json::value_to(value.as_array()[1])); if (!id1 || !id2) return Error{Status{ClioError::RpcMalformedAddress, "malformedAddresses"}}; @@ -168,16 +166,16 @@ public: static auto const kBRIDGE_JSON_VALIDATOR = meta::WithCustomError{ meta::IfType{meta::Section{ - {ripple::sfLockingChainDoor.getJsonName().c_str(), + {xrpl::sfLockingChainDoor.getJsonName().cStr(), validation::Required{}, validation::CustomValidators::accountBase58Validator}, - {ripple::sfIssuingChainDoor.getJsonName().c_str(), + {xrpl::sfIssuingChainDoor.getJsonName().cStr(), validation::Required{}, validation::CustomValidators::accountBase58Validator}, - {ripple::sfLockingChainIssue.getJsonName().c_str(), + {xrpl::sfLockingChainIssue.getJsonName().cStr(), validation::Required{}, validation::CustomValidators::currencyIssueValidator}, - {ripple::sfIssuingChainIssue.getJsonName().c_str(), + {xrpl::sfIssuingChainIssue.getJsonName().cStr(), validation::Required{}, validation::CustomValidators::currencyIssueValidator}, }}, @@ -454,7 +452,7 @@ public: private: // dir_root and owner can not be both empty or filled at the same time // This function will return an error if this is the case - static std::expected + static std::expected composeKeyFromDirectory(boost::json::object const& directory) noexcept; /** diff --git a/src/rpc/handlers/LedgerIndex.cpp b/src/rpc/handlers/LedgerIndex.cpp index 297d4f047..35664d2ca 100644 --- a/src/rpc/handlers/LedgerIndex.cpp +++ b/src/rpc/handlers/LedgerIndex.cpp @@ -51,8 +51,8 @@ LedgerIndexHandler::process(LedgerIndexHandler::Input const& input, Context cons auto const ledger = sharedPtrBackend_->fetchLedgerBySequence(index, ctx.yield); return Output{ .ledgerIndex = index, - .ledgerHash = ripple::strHex(ledger->hash), - .closeTimeIso = ripple::to_string_iso(ledger->closeTime) + .ledgerHash = xrpl::strHex(ledger->hash), + .closeTimeIso = xrpl::toStringIso(ledger->closeTime) }; }; @@ -76,7 +76,7 @@ LedgerIndexHandler::process(LedgerIndexHandler::Input const& input, Context cons // If the given date is earlier than the first valid ledger, return lgrNotFound if (earlierThan(minIndex)) - return Error{Status{RippledError::rpcLGR_NOT_FOUND, "ledgerNotInRange"}}; + return Error{Status{RippledError::RpcLgrNotFound, "ledgerNotInRange"}}; auto const view = std::ranges::iota_view{minIndex, maxIndex + 1}; diff --git a/src/rpc/handlers/MPTHolders.cpp b/src/rpc/handlers/MPTHolders.cpp index 86aa3a99a..acf006de6 100644 --- a/src/rpc/handlers/MPTHolders.cpp +++ b/src/rpc/handlers/MPTHolders.cpp @@ -30,20 +30,20 @@ #include #include #include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include +#include #include #include #include -using namespace ripple; +using namespace xrpl; namespace rpc { @@ -61,16 +61,16 @@ MPTHoldersHandler::process(MPTHoldersHandler::Input const& input, Context const& auto const& lgrInfo = expectedLgrInfo.value(); auto const limit = input.limit.value_or(MPTHoldersHandler::kLIMIT_DEFAULT); - auto const mptID = ripple::uint192{input.mptID.c_str()}; + auto const mptID = xrpl::uint192{input.mptID.c_str()}; auto const issuanceLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::mptIssuance(mptID).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::mptIssuance(mptID).key, lgrInfo.seq, ctx.yield); if (!issuanceLedgerObject) - return Error{Status{RippledError::rpcOBJECT_NOT_FOUND, "objectNotFound"}}; + return Error{Status{RippledError::RpcObjectNotFound, "objectNotFound"}}; - std::optional cursor; + std::optional cursor; if (input.marker) - cursor = ripple::AccountID{input.marker->c_str()}; + cursor = xrpl::AccountID{input.marker->c_str()}; auto const dbResponse = sharedPtrBackend_->fetchMPTHolders(mptID, limit, cursor, lgrInfo.seq, ctx.yield); auto output = MPTHoldersHandler::Output{}; @@ -80,14 +80,14 @@ MPTHoldersHandler::process(MPTHoldersHandler::Input const& input, Context const& boost::json::array const mpts; for (auto const& mpt : dbResponse.mptokens) { - ripple::STLedgerEntry const sle{ripple::SerialIter{mpt.data(), mpt.size()}, keylet::mptIssuance(mptID).key}; + xrpl::STLedgerEntry const sle{xrpl::SerialIter{mpt.data(), mpt.size()}, keylet::mptIssuance(mptID).key}; boost::json::object mptJson; - mptJson[JS(account)] = toBase58(sle[ripple::sfAccount]); + mptJson[JS(account)] = toBase58(sle[xrpl::sfAccount]); mptJson[JS(flags)] = sle.getFlags(); mptJson["mpt_amount"] = - toBoostJson(ripple::STUInt64{ripple::sfMPTAmount, sle[ripple::sfMPTAmount]}.getJson(JsonOptions::none)); - mptJson["mptoken_index"] = ripple::to_string(ripple::keylet::mptoken(mptID, sle[ripple::sfAccount]).key); + toBoostJson(xrpl::STUInt64{xrpl::sfMPTAmount, sle[xrpl::sfMPTAmount]}.getJson(JsonOptions::Values::None)); + mptJson["mptoken_index"] = xrpl::to_string(xrpl::keylet::mptoken(mptID, sle[xrpl::sfAccount]).key); output.mpts.push_back(mptJson); } diff --git a/src/rpc/handlers/NFTBuyOffers.cpp b/src/rpc/handlers/NFTBuyOffers.cpp index 7c337044b..5da74422d 100644 --- a/src/rpc/handlers/NFTBuyOffers.cpp +++ b/src/rpc/handlers/NFTBuyOffers.cpp @@ -24,7 +24,7 @@ #include #include -using namespace ripple; +using namespace xrpl; namespace rpc { @@ -32,7 +32,7 @@ NFTBuyOffersHandler::Result NFTBuyOffersHandler::process(NFTBuyOffersHandler::Input const& input, Context const& ctx) const { auto const tokenID = uint256{input.nftID.c_str()}; - auto const directory = keylet::nft_buys(tokenID); + auto const directory = keylet::nftBuys(tokenID); return iterateOfferDirectory(input, tokenID, directory, ctx.yield); } diff --git a/src/rpc/handlers/NFTHistory.cpp b/src/rpc/handlers/NFTHistory.cpp index 9d3dc17ac..da7158813 100644 --- a/src/rpc/handlers/NFTHistory.cpp +++ b/src/rpc/handlers/NFTHistory.cpp @@ -60,25 +60,25 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& if (input.ledgerIndexMin) { if (range->maxSequence < input.ledgerIndexMin || range->minSequence > input.ledgerIndexMin) - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMinOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMinOutOfRange"}}; minIndex = *input.ledgerIndexMin; } if (input.ledgerIndexMax) { if (range->maxSequence < input.ledgerIndexMax || range->minSequence > input.ledgerIndexMax) - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMaxOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMaxOutOfRange"}}; maxIndex = *input.ledgerIndexMax; } if (minIndex > maxIndex) - return Error{Status{RippledError::rpcLGR_IDXS_INVALID}}; + return Error{Status{RippledError::RpcLgrIdxsInvalid}}; if (input.ledgerHash || input.ledgerIndex) { // rippled does not have this check if (input.ledgerIndexMax || input.ledgerIndexMin) - return Error{Status{RippledError::rpcINVALID_PARAMS, "containsLedgerSpecifierAndRange"}}; + return Error{Status{RippledError::RpcInvalidParams, "containsLedgerSpecifierAndRange"}}; auto const expectedLgrInfo = getLedgerHeaderFromHashOrSeq( *sharedPtrBackend_, ctx.yield, input.ledgerHash, input.ledgerIndex, range->maxSequence @@ -104,7 +104,7 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& } auto const limit = input.limit.value_or(kLIMIT_DEFAULT); - auto const tokenID = ripple::uint256{input.nftID.c_str()}; + auto const tokenID = xrpl::uint256{input.nftID.c_str()}; auto const [txnsAndCursor, timeDiff] = util::timed([&]() { return sharedPtrBackend_->fetchNFTTransactions(tokenID, limit, input.forward, cursor, ctx.yield); @@ -147,8 +147,8 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& if (auto const lgrInfo = sharedPtrBackend_->fetchLedgerBySequence(txnPlusMeta.ledgerSequence, ctx.yield); lgrInfo) { - obj[JS(close_time_iso)] = ripple::to_string_iso(lgrInfo->closeTime); - obj[JS(ledger_hash)] = ripple::strHex(lgrInfo->hash); + obj[JS(close_time_iso)] = xrpl::toStringIso(lgrInfo->closeTime); + obj[JS(ledger_hash)] = xrpl::strHex(lgrInfo->hash); } } } else { @@ -162,7 +162,7 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& } response.limit = input.limit; - response.nftID = ripple::to_string(tokenID); + response.nftID = xrpl::to_string(tokenID); response.ledgerIndexMin = minIndex; response.ledgerIndexMax = maxIndex; diff --git a/src/rpc/handlers/NFTHistory.hpp b/src/rpc/handlers/NFTHistory.hpp index 58425c1d7..efa1a1f82 100644 --- a/src/rpc/handlers/NFTHistory.hpp +++ b/src/rpc/handlers/NFTHistory.hpp @@ -132,7 +132,7 @@ public: modifiers::Clamp{kLIMIT_MIN, kLIMIT_MAX}}, {JS(marker), meta::WithCustomError{ - validation::Type{}, Status{RippledError::rpcINVALID_PARAMS, "invalidMarker"} + validation::Type{}, Status{RippledError::RpcInvalidParams, "invalidMarker"} }, meta::Section{ {JS(ledger), validation::Required{}, validation::Type{}}, diff --git a/src/rpc/handlers/NFTInfo.cpp b/src/rpc/handlers/NFTInfo.cpp index 32d6e4578..129be7c2c 100644 --- a/src/rpc/handlers/NFTInfo.cpp +++ b/src/rpc/handlers/NFTInfo.cpp @@ -39,14 +39,14 @@ #include -using namespace ripple; +using namespace xrpl; namespace rpc { NFTInfoHandler::Result NFTInfoHandler::process(NFTInfoHandler::Input const& input, Context const& ctx) const { - auto const tokenID = ripple::uint256{input.nftID.c_str()}; + auto const tokenID = xrpl::uint256{input.nftID.c_str()}; auto const range = sharedPtrBackend_->fetchLedgerRange(); ASSERT(range.has_value(), "NFTInfo's ledger range must be available"); @@ -61,7 +61,7 @@ NFTInfoHandler::process(NFTInfoHandler::Input const& input, Context const& ctx) auto const maybeNft = sharedPtrBackend_->fetchNFT(tokenID, lgrInfo.seq, ctx.yield); if (not maybeNft.has_value()) - return Error{Status{RippledError::rpcOBJECT_NOT_FOUND, "NFT not found"}}; + return Error{Status{RippledError::RpcObjectNotFound, "NFT not found"}}; // TODO - this formatting is exactly the same and SHOULD REMAIN THE SAME // for each element of the `nfts_by_issuer` API. We should factor this out diff --git a/src/rpc/handlers/NFTOffersCommon.cpp b/src/rpc/handlers/NFTOffersCommon.cpp index 3e33578ae..ad7e2b6dc 100644 --- a/src/rpc/handlers/NFTOffersCommon.cpp +++ b/src/rpc/handlers/NFTOffersCommon.cpp @@ -51,16 +51,16 @@ #include #include -using namespace ripple; +using namespace xrpl; using namespace ::rpc; -namespace ripple { +namespace xrpl { // TODO: move to some common serialization impl place inline static void tag_invoke(boost::json::value_from_tag, boost::json::value& jv, SLE const& offer) { - auto amount = ::toBoostJson(offer.getFieldAmount(sfAmount).getJson(JsonOptions::none)); + auto amount = ::toBoostJson(offer.getFieldAmount(sfAmount).getJson(JsonOptions::Values::None)); boost::json::object obj = { {JS(nft_offer_index), to_string(offer.key())}, @@ -78,15 +78,15 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, SLE const& offer jv = std::move(obj); } -} // namespace ripple +} // namespace xrpl namespace rpc { NFTOffersHandlerBase::Result NFTOffersHandlerBase::iterateOfferDirectory( Input input, - ripple::uint256 const& tokenID, - ripple::Keylet const& directory, + xrpl::uint256 const& tokenID, + xrpl::Keylet const& directory, boost::asio::yield_context yield ) const { @@ -104,10 +104,10 @@ NFTOffersHandlerBase::iterateOfferDirectory( // TODO: just check for existence without pulling if (not sharedPtrBackend_->fetchLedgerObject(directory.key, lgrInfo.seq, yield)) - return Error{Status{RippledError::rpcOBJECT_NOT_FOUND, "notFound"}}; + return Error{Status{RippledError::RpcObjectNotFound, "notFound"}}; auto output = Output{.nftID = input.nftID, .offers = {}, .limit = {}, .marker = {}}; - auto offers = std::vector{}; + auto offers = std::vector{}; auto reserve = input.limit; auto cursor = uint256{}; auto startHint = uint64_t{0ul}; @@ -125,12 +125,12 @@ NFTOffersHandlerBase::iterateOfferDirectory( return nullptr; }(); - if (!sle || sle->getFieldU16(ripple::sfLedgerEntryType) != ripple::ltNFTOKEN_OFFER || - tokenID != sle->getFieldH256(ripple::sfNFTokenID)) { - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + if (!sle || sle->getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltNFTOKEN_OFFER || + tokenID != sle->getFieldH256(xrpl::sfNFTokenID)) { + return Error{Status{RippledError::RpcInvalidParams}}; } - startHint = sle->getFieldU64(ripple::sfNFTokenOfferNode); + startHint = sle->getFieldU64(xrpl::sfNFTokenOfferNode); output.offers.push_back(*sle); offers.reserve(reserve); } else { @@ -139,8 +139,8 @@ NFTOffersHandlerBase::iterateOfferDirectory( } auto result = traverseOwnedNodes( - *sharedPtrBackend_, directory, cursor, startHint, lgrInfo.seq, reserve, yield, [&offers](ripple::SLE&& offer) { - if (offer.getType() == ripple::ltNFTOKEN_OFFER) { + *sharedPtrBackend_, directory, cursor, startHint, lgrInfo.seq, reserve, yield, [&offers](xrpl::SLE&& offer) { + if (offer.getType() == xrpl::ltNFTOKEN_OFFER) { offers.push_back(std::move(offer)); return true; } diff --git a/src/rpc/handlers/NFTOffersCommon.hpp b/src/rpc/handlers/NFTOffersCommon.hpp index 21eb23bd3..c11adda73 100644 --- a/src/rpc/handlers/NFTOffersCommon.hpp +++ b/src/rpc/handlers/NFTOffersCommon.hpp @@ -58,7 +58,7 @@ public: */ struct Output { std::string nftID; - std::vector offers; + std::vector offers; // validated should be sent via framework bool validated = true; @@ -125,8 +125,8 @@ protected: Result iterateOfferDirectory( Input input, - ripple::uint256 const& tokenID, - ripple::Keylet const& directory, + xrpl::uint256 const& tokenID, + xrpl::Keylet const& directory, boost::asio::yield_context yield ) const; diff --git a/src/rpc/handlers/NFTSellOffers.cpp b/src/rpc/handlers/NFTSellOffers.cpp index c9aef48f6..95850abbd 100644 --- a/src/rpc/handlers/NFTSellOffers.cpp +++ b/src/rpc/handlers/NFTSellOffers.cpp @@ -24,7 +24,7 @@ #include #include -using namespace ripple; +using namespace xrpl; namespace rpc { @@ -32,7 +32,7 @@ NFTSellOffersHandler::Result NFTSellOffersHandler::process(NFTSellOffersHandler::Input const& input, Context const& ctx) const { auto const tokenID = uint256{input.nftID.c_str()}; - auto const directory = keylet::nft_sells(tokenID); + auto const directory = keylet::nftSells(tokenID); return iterateOfferDirectory(input, tokenID, directory, ctx.yield); } diff --git a/src/rpc/handlers/NFTsByIssuer.cpp b/src/rpc/handlers/NFTsByIssuer.cpp index c5f3f9c75..5746f98fc 100644 --- a/src/rpc/handlers/NFTsByIssuer.cpp +++ b/src/rpc/handlers/NFTsByIssuer.cpp @@ -42,7 +42,7 @@ #include #include -using namespace ripple; +using namespace xrpl; namespace rpc { @@ -64,10 +64,10 @@ NFTsByIssuerHandler::process(NFTsByIssuerHandler::Input const& input, Context co auto const issuer = accountFromStringStrict(input.issuer); auto const accountLedgerObject = - sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*issuer).key, lgrInfo.seq, ctx.yield); + sharedPtrBackend_->fetchLedgerObject(xrpl::keylet::account(*issuer).key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; std::optional cursor; if (input.marker) diff --git a/src/rpc/handlers/NoRippleCheck.cpp b/src/rpc/handlers/NoRippleCheck.cpp index 4fe0cb046..8770f9560 100644 --- a/src/rpc/handlers/NoRippleCheck.cpp +++ b/src/rpc/handlers/NoRippleCheck.cpp @@ -36,6 +36,7 @@ #include #include #include +#include #include #include #include @@ -70,16 +71,16 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); - auto const keylet = ripple::keylet::account(*accountID).key; + auto const keylet = xrpl::keylet::account(*accountID).key; auto const accountObj = sharedPtrBackend_->fetchLedgerObject(keylet, lgrInfo.seq, ctx.yield); if (!accountObj) - return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}}; + return Error{Status{RippledError::RpcActNotFound, "accountNotFound"}}; - auto it = ripple::SerialIter{accountObj->data(), accountObj->size()}; - auto sle = ripple::SLE{it, keylet}; - auto accountSeq = sle.getFieldU32(ripple::sfSequence); - bool const bDefaultRipple = (sle.getFieldU32(ripple::sfFlags) & ripple::lsfDefaultRipple) != 0u; + auto it = xrpl::SerialIter{accountObj->data(), accountObj->size()}; + auto sle = xrpl::SLE{it, keylet}; + auto accountSeq = sle.getFieldU32(xrpl::sfSequence); + bool const bDefaultRipple = (sle.getFieldU32(xrpl::sfFlags) & xrpl::lsfDefaultRipple) != 0u; auto const fees = input.transactions ? sharedPtrBackend_->fetchFees(lgrInfo.seq, ctx.yield) : std::nullopt; auto output = NoRippleCheckHandler::Output(); @@ -87,10 +88,10 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context if (input.transactions) output.transactions.emplace(boost::json::array()); - auto const getBaseTx = [&](ripple::AccountID const& accountID, std::uint32_t accountSeq) { + auto const getBaseTx = [&](xrpl::AccountID const& accountID, std::uint32_t accountSeq) { boost::json::object tx; tx[JS(Sequence)] = accountSeq; - tx[JS(Account)] = ripple::toBase58(accountID); + tx[JS(Account)] = xrpl::toBase58(accountID); tx[JS(Fee)] = toBoostJson(fees->base.jsonClipped()); return tx; @@ -107,7 +108,7 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context if (input.transactions) { auto tx = getBaseTx(*accountID, accountSeq++); tx[JS(TransactionType)] = "AccountSet"; - tx[JS(SetFlag)] = ripple::asfDefaultRipple; + tx[JS(SetFlag)] = xrpl::asfDefaultRipple; output.transactions->push_back(tx); } } @@ -121,13 +122,13 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context std::numeric_limits::max(), {}, ctx.yield, - [&](ripple::SLE const ownedItem) { + [&](xrpl::SLE const ownedItem) { // don't push to result if limit is reached - if (limit != 0 && ownedItem.getType() == ripple::ltRIPPLE_STATE) { - bool const bLow = accountID == ownedItem.getFieldAmount(ripple::sfLowLimit).getIssuer(); + if (limit != 0 && ownedItem.getType() == xrpl::ltRIPPLE_STATE) { + bool const bLow = accountID == ownedItem.getFieldAmount(xrpl::sfLowLimit).getIssuer(); - bool const bNoRipple = (ownedItem.getFieldU32(ripple::sfFlags) & - (bLow ? ripple::lsfLowNoRipple : ripple::lsfHighNoRipple)) != 0u; + bool const bNoRipple = (ownedItem.getFieldU32(xrpl::sfFlags) & + (bLow ? xrpl::lsfLowNoRipple : xrpl::lsfHighNoRipple)) != 0u; std::string problem; bool needFix = false; @@ -141,27 +142,29 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context if (needFix) { --limit; - ripple::AccountID const peer = - ownedItem.getFieldAmount(bLow ? ripple::sfHighLimit : ripple::sfLowLimit).getIssuer(); - ripple::STAmount const peerLimit = - ownedItem.getFieldAmount(bLow ? ripple::sfHighLimit : ripple::sfLowLimit); + xrpl::AccountID const peer = + ownedItem.getFieldAmount(bLow ? xrpl::sfHighLimit : xrpl::sfLowLimit).getIssuer(); + xrpl::STAmount const peerLimit = + ownedItem.getFieldAmount(bLow ? xrpl::sfHighLimit : xrpl::sfLowLimit); problem += fmt::format( - "{} line to {}", to_string(peerLimit.getCurrency()), to_string(peerLimit.getIssuer()) + "{} line to {}", + to_string(peerLimit.get().currency), + to_string(peerLimit.getIssuer()) ); output.problems.emplace_back(problem); if (input.transactions) { - ripple::STAmount limitAmount( - ownedItem.getFieldAmount(bLow ? ripple::sfLowLimit : ripple::sfHighLimit) + xrpl::STAmount limitAmount( + ownedItem.getFieldAmount(bLow ? xrpl::sfLowLimit : xrpl::sfHighLimit) ); - limitAmount.setIssuer(peer); + limitAmount.setIssue(xrpl::Issue{limitAmount.get().currency, peer}); auto tx = getBaseTx(*accountID, accountSeq++); tx[JS(TransactionType)] = "TrustSet"; - tx[JS(LimitAmount)] = toBoostJson(limitAmount.getJson(ripple::JsonOptions::none)); - tx[JS(Flags)] = bNoRipple ? ripple::tfClearNoRipple : ripple::tfSetNoRipple; + tx[JS(LimitAmount)] = toBoostJson(limitAmount.getJson(xrpl::JsonOptions::Values::None)); + tx[JS(Flags)] = bNoRipple ? xrpl::tfClearNoRipple : xrpl::tfSetNoRipple; output.transactions->push_back(tx); } @@ -173,7 +176,7 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context ); output.ledgerIndex = lgrInfo.seq; - output.ledgerHash = ripple::strHex(lgrInfo.hash); + output.ledgerHash = xrpl::strHex(lgrInfo.hash); return output; } diff --git a/src/rpc/handlers/NoRippleCheck.hpp b/src/rpc/handlers/NoRippleCheck.hpp index c7da7ae62..80b9e100a 100644 --- a/src/rpc/handlers/NoRippleCheck.hpp +++ b/src/rpc/handlers/NoRippleCheck.hpp @@ -109,7 +109,7 @@ public: {JS(role), validation::Required{}, meta::WithCustomError{ - validation::OneOf{"gateway", "user"}, Status{RippledError::rpcINVALID_PARAMS, "role field is invalid"} + validation::OneOf{"gateway", "user"}, Status{RippledError::RpcInvalidParams, "role field is invalid"} }}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator}, diff --git a/src/rpc/handlers/Random.cpp b/src/rpc/handlers/Random.cpp index 20c7a1b45..291da314b 100644 --- a/src/rpc/handlers/Random.cpp +++ b/src/rpc/handlers/Random.cpp @@ -35,10 +35,10 @@ namespace rpc { RandomHandler::Result RandomHandler::process([[maybe_unused]] Context const& ctx) { - ripple::uint256 rand; - beast::rngfill(rand.begin(), ripple::uint256::size(), ripple::crypto_prng()); + xrpl::uint256 rand; + beast::rngfill(rand.begin(), xrpl::uint256::size(), xrpl::cryptoPrng()); - return Output{ripple::strHex(rand)}; + return Output{xrpl::strHex(rand)}; } void diff --git a/src/rpc/handlers/ServerInfo.hpp b/src/rpc/handlers/ServerInfo.hpp index b54e83f71..911ffa3b4 100644 --- a/src/rpc/handlers/ServerInfo.hpp +++ b/src/rpc/handlers/ServerInfo.hpp @@ -96,8 +96,8 @@ public: struct ValidatedLedgerSection { uint32_t age = 0; std::string hash; - ripple::LedgerIndex seq = {}; - std::optional fees = std::nullopt; + xrpl::LedgerIndex seq = {}; + std::optional fees = std::nullopt; }; /** @@ -107,7 +107,7 @@ public: std::size_t size = 0; bool isEnabled = false; bool isFull = false; - ripple::LedgerIndex latestLedgerSeq = {}; + xrpl::LedgerIndex latestLedgerSeq = {}; float objectHitRate = 1.0; float successorHitRate = 1.0; }; @@ -122,7 +122,7 @@ public: std::chrono::time_point time = std::chrono::system_clock::now(); std::chrono::seconds uptime = {}; std::string clioVersion = util::build::getClioVersionString(); - std::string xrplVersion = ripple::BuildInfo::getVersionString(); + std::string xrplVersion = xrpl::BuildInfo::getVersionString(); std::optional rippledInfo = std::nullopt; ValidatedLedgerSection validatedLedger = {}; CacheSection cache = {}; @@ -197,11 +197,11 @@ public: auto const lgrInfo = backend_->fetchLedgerBySequence(range->maxSequence, ctx.yield); if (not lgrInfo.has_value()) - return Error{Status{RippledError::rpcINTERNAL}}; + return Error{Status{RippledError::RpcInternal}}; auto const fees = backend_->fetchFees(lgrInfo->seq, ctx.yield); if (not fees.has_value()) - return Error{Status{RippledError::rpcINTERNAL}}; + return Error{Status{RippledError::RpcInternal}}; auto output = Output{}; auto const sinceEpoch = duration_cast(system_clock::now().time_since_epoch()).count(); @@ -231,7 +231,7 @@ public: } output.info.validatedLedger.age = age < 0 ? 0 : age; - output.info.validatedLedger.hash = ripple::strHex(lgrInfo->hash); + output.info.validatedLedger.hash = xrpl::strHex(lgrInfo->hash); output.info.validatedLedger.seq = lgrInfo->seq; output.info.validatedLedger.fees = fees; output.info.cache.size = backend_->cache().size(); @@ -263,7 +263,7 @@ private: tag_invoke(boost::json::value_from_tag, boost::json::value& jv, InfoSection const& info) { using boost::json::value_from; - using ripple::to_string; + using xrpl::to_string; jv = { {JS(complete_ledgers), info.completeLedgers}, diff --git a/src/rpc/handlers/Subscribe.cpp b/src/rpc/handlers/Subscribe.cpp index 6e2f75dc0..ef4f150b2 100644 --- a/src/rpc/handlers/Subscribe.cpp +++ b/src/rpc/handlers/Subscribe.cpp @@ -68,22 +68,22 @@ SubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) static auto const kBOOKS_VALIDATOR = validation::CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_array()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotArray"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotArray"}}; for (auto const& book : value.as_array()) { if (!book.is_object()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "ItemNotObject"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "ItemNotObject"}}; if (book.as_object().contains("both") && !book.as_object().at("both").is_bool()) - return Error{Status{RippledError::rpcINVALID_PARAMS, "bothNotBool"}}; + return Error{Status{RippledError::RpcInvalidParams, "bothNotBool"}}; if (book.as_object().contains("snapshot") && !book.as_object().at("snapshot").is_bool()) - return Error{Status{RippledError::rpcINVALID_PARAMS, "snapshotNotBool"}}; + return Error{Status{RippledError::RpcInvalidParams, "snapshotNotBool"}}; if (book.as_object().contains("taker")) { if (auto err = meta::WithCustomError( validation::CustomValidators::accountValidator, - Status{RippledError::rpcBAD_ISSUER, "Issuer account malformed."} + Status{RippledError::RpcBadIssuer, "Issuer account malformed."} ) .verify(book.as_object(), "taker"); !err) @@ -215,7 +215,7 @@ SubscribeHandler::subscribeToBooks( // the taker is not really used, same issue with // https://github.com/XRPLF/xrpl-dev-portal/issues/1818 - auto const takerID = internalBook.taker ? accountFromStringStrict(*(internalBook.taker)) : beast::zero; + auto const takerID = internalBook.taker ? accountFromStringStrict(*(internalBook.taker)) : beast::kZero; auto const orderBook = postProcessOrderBook( offers, book, *takerID, *sharedPtrBackend_, *amendmentCenter_, rng->maxSequence, yield @@ -229,7 +229,7 @@ SubscribeHandler::subscribeToBooks( if (!output.asks) output.asks = boost::json::array(); getOrderBook(internalBook.book, *(output.bids)); - getOrderBook(ripple::reversed(internalBook.book), *(output.asks)); + getOrderBook(xrpl::reversed(internalBook.book), *(output.asks)); } else { if (!output.offers) output.offers = boost::json::array(); @@ -240,7 +240,7 @@ SubscribeHandler::subscribeToBooks( subscriptions_->subBook(internalBook.book, session); if (internalBook.both) - subscriptions_->subBook(ripple::reversed(internalBook.book), session); + subscriptions_->subBook(xrpl::reversed(internalBook.book), session); } } diff --git a/src/rpc/handlers/Subscribe.hpp b/src/rpc/handlers/Subscribe.hpp index 0d7c6816d..5aa08b9c8 100644 --- a/src/rpc/handlers/Subscribe.hpp +++ b/src/rpc/handlers/Subscribe.hpp @@ -78,7 +78,7 @@ public: * @brief A struct to hold the data for one order book */ struct OrderBook { - ripple::Book book; + xrpl::Book book; std::optional taker; bool snapshot = false; bool both = false; diff --git a/src/rpc/handlers/TransactionEntry.cpp b/src/rpc/handlers/TransactionEntry.cpp index 19d7df8ad..6c5f5384f 100644 --- a/src/rpc/handlers/TransactionEntry.cpp +++ b/src/rpc/handlers/TransactionEntry.cpp @@ -56,7 +56,7 @@ TransactionEntryHandler::process(TransactionEntryHandler::Input const& input, Co output.apiVersion = ctx.apiVersion; output.ledgerHeader = expectedLgrInfo.value(); - auto const dbRet = sharedPtrBackend_->fetchTransaction(ripple::uint256{input.txHash.c_str()}, ctx.yield); + auto const dbRet = sharedPtrBackend_->fetchTransaction(xrpl::uint256{input.txHash.c_str()}, ctx.yield); // Note: transaction_entry is meant to only search a specified ledger for // the specified transaction. tx searches the entire range of history. For // rippled, having two separate commands made sense, as tx would use SQLite @@ -67,7 +67,7 @@ TransactionEntryHandler::process(TransactionEntryHandler::Input const& input, Co // ledger; we simulate that here by returning not found if the transaction // is in a different ledger than the one specified. if (!dbRet || dbRet->ledgerSequence != output.ledgerHeader->seq) - return Error{Status{RippledError::rpcTXN_NOT_FOUND, "transactionNotFound", "Transaction not found."}}; + return Error{Status{RippledError::RpcTxnNotFound, "transactionNotFound", "Transaction not found."}}; auto [txn, meta] = toExpandedJson(*dbRet, ctx.apiVersion); @@ -86,11 +86,11 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, TransactionEntry {metaKey, output.metadata}, {JS(tx_json), output.tx}, {JS(ledger_index), output.ledgerHeader->seq}, - {JS(ledger_hash), ripple::strHex(output.ledgerHeader->hash)}, + {JS(ledger_hash), xrpl::strHex(output.ledgerHeader->hash)}, }; if (output.apiVersion > 1u) { - jv.as_object()[JS(close_time_iso)] = ripple::to_string_iso(output.ledgerHeader->closeTime); + jv.as_object()[JS(close_time_iso)] = xrpl::toStringIso(output.ledgerHeader->closeTime); if (output.tx.contains(JS(hash))) { jv.as_object()[JS(hash)] = output.tx.at(JS(hash)); jv.as_object()[JS(tx_json)].as_object().erase(JS(hash)); diff --git a/src/rpc/handlers/TransactionEntry.hpp b/src/rpc/handlers/TransactionEntry.hpp index fb2fb82c3..d63cb2b20 100644 --- a/src/rpc/handlers/TransactionEntry.hpp +++ b/src/rpc/handlers/TransactionEntry.hpp @@ -53,7 +53,7 @@ public: * @brief A struct to hold the output data of the command */ struct Output { - std::optional ledgerHeader; + std::optional ledgerHeader; // TODO: use a better type for this boost::json::object metadata; boost::json::object tx; diff --git a/src/rpc/handlers/Tx.hpp b/src/rpc/handlers/Tx.hpp index df681deb2..36f617ec3 100644 --- a/src/rpc/handlers/Tx.hpp +++ b/src/rpc/handlers/Tx.hpp @@ -76,7 +76,7 @@ public: std::optional txStr = std::nullopt; // NOLINT(readability-redundant-member-init) std::optional ctid = std::nullopt; // NOLINT(readability-redundant-member-init) ctid when binary=true - std::optional ledgerHeader = + std::optional ledgerHeader = std::nullopt; // NOLINT(readability-redundant-member-init) ledger hash when apiVersion >= 2 uint32_t apiVersion = 0u; bool validated = true; @@ -141,20 +141,20 @@ public: process(Input const& input, Context const& ctx) const { if (input.ctid && input.transaction) // ambiguous identifier - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; if (!input.ctid && !input.transaction) // at least one identifier must be supplied - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; static constexpr auto kMAX_LEDGER_RANGE = 1000u; auto const rangeSupplied = input.minLedger && input.maxLedger; if (rangeSupplied) { if (*input.minLedger > *input.maxLedger) - return Error{Status{RippledError::rpcINVALID_LGR_RANGE}}; + return Error{Status{RippledError::RpcInvalidLgrRange}}; if (*input.maxLedger - *input.minLedger > kMAX_LEDGER_RANGE) - return Error{Status{RippledError::rpcEXCESSIVE_LGR_RANGE}}; + return Error{Status{RippledError::RpcExcessiveLgrRange}}; } std::optional currentNetId = std::nullopt; @@ -166,13 +166,13 @@ public: if (input.ctid) { auto const ctid = rpc::decodeCTID(*input.ctid); if (!ctid) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; auto const [lgrSeq, txnIdx, netId] = *ctid; // when current network id is available, let us check the network id from parameter if (currentNetId && netId != *currentNetId) { return Error{Status{ - RippledError::rpcWRONG_NETWORK, + RippledError::RpcWrongNetwork, fmt::format( "Wrong network. You should submit this request to a node running on NetworkID: {}", netId ) @@ -181,7 +181,7 @@ public: dbResponse = fetchTxViaCtid(lgrSeq, txnIdx, ctx.yield); } else { - dbResponse = sharedPtrBackend_->fetchTransaction(ripple::uint256{input.transaction->c_str()}, ctx.yield); + dbResponse = sharedPtrBackend_->fetchTransaction(xrpl::uint256{input.transaction->c_str()}, ctx.yield); } auto output = TxHandler::Output{.apiVersion = ctx.apiVersion}; @@ -197,10 +197,10 @@ public: boost::json::object extra; extra["searched_all"] = searchedAll; - return Error{Status{RippledError::rpcTXN_NOT_FOUND, std::move(extra)}}; + return Error{Status{RippledError::RpcTxnNotFound, std::move(extra)}}; } - return Error{Status{RippledError::rpcTXN_NOT_FOUND}}; + return Error{Status{RippledError::RpcTxnNotFound}}; } auto const [txn, meta] = toExpandedJson(*dbResponse, ctx.apiVersion, NFTokenjson::ENABLE, currentNetId); @@ -209,8 +209,8 @@ public: output.tx = txn; output.meta = meta; } else { - output.txStr = ripple::strHex(dbResponse->transaction); - output.metaStr = ripple::strHex(dbResponse->metadata); + output.txStr = xrpl::strHex(dbResponse->transaction); + output.metaStr = xrpl::strHex(dbResponse->metadata); // input.transaction might be not available, get hash via tx object if (txn.contains(JS(hash))) @@ -300,8 +300,8 @@ private: obj[JS(ledger_index)] = output.ledgerIndex; if (output.ledgerHeader) { - obj[JS(ledger_hash)] = ripple::strHex(output.ledgerHeader->hash); - obj[JS(close_time_iso)] = ripple::to_string_iso(output.ledgerHeader->closeTime); + obj[JS(ledger_hash)] = xrpl::strHex(output.ledgerHeader->hash); + obj[JS(close_time_iso)] = xrpl::toStringIso(output.ledgerHeader->closeTime); } return obj; }; diff --git a/src/rpc/handlers/Unsubscribe.cpp b/src/rpc/handlers/Unsubscribe.cpp index c47f9d052..55201d6be 100644 --- a/src/rpc/handlers/Unsubscribe.cpp +++ b/src/rpc/handlers/Unsubscribe.cpp @@ -55,14 +55,14 @@ UnsubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) static auto const kBOOKS_VALIDATOR = validation::CustomValidator{[](boost::json::value const& value, std::string_view key) -> MaybeError { if (!value.is_array()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotArray"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "NotArray"}}; for (auto const& book : value.as_array()) { if (!book.is_object()) - return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "ItemNotObject"}}; + return Error{Status{RippledError::RpcInvalidParams, std::string(key) + "ItemNotObject"}}; if (book.as_object().contains("both") && !book.as_object().at("both").is_bool()) - return Error{Status{RippledError::rpcINVALID_PARAMS, "bothNotBool"}}; + return Error{Status{RippledError::RpcInvalidParams, "bothNotBool"}}; auto const parsedBook = parseBook(book.as_object()); if (!parsedBook.has_value()) @@ -161,7 +161,7 @@ UnsubscribeHandler::unsubscribeFromBooks( subscriptions_->unsubBook(orderBook.book, session); if (orderBook.both) - subscriptions_->unsubBook(ripple::reversed(orderBook.book), session); + subscriptions_->unsubBook(xrpl::reversed(orderBook.book), session); } } diff --git a/src/rpc/handlers/Unsubscribe.hpp b/src/rpc/handlers/Unsubscribe.hpp index 64a251657..ab907fd58 100644 --- a/src/rpc/handlers/Unsubscribe.hpp +++ b/src/rpc/handlers/Unsubscribe.hpp @@ -55,7 +55,7 @@ public: * @brief A struct to hold one order book */ struct OrderBook { - ripple::Book book; + xrpl::Book book; bool both = false; }; diff --git a/src/rpc/handlers/VaultInfo.cpp b/src/rpc/handlers/VaultInfo.cpp index ad4074594..2d837a06a 100644 --- a/src/rpc/handlers/VaultInfo.cpp +++ b/src/rpc/handlers/VaultInfo.cpp @@ -95,14 +95,14 @@ VaultInfoHandler::process(VaultInfoHandler::Input const& input, Context const& c auto const& lgrInfo = *expectedLgrInfo; // Extract the vault keylet based on input - auto const vaultKeylet = [&]() -> std::expected { + auto const vaultKeylet = [&]() -> std::expected { if (input.owner && input.tnxSequence) { auto const accountStr = *input.owner; auto const accountID = accountFromStringStrict(accountStr); // checks that account exists { - auto const accountKeylet = ripple::keylet::account(*accountID); + auto const accountKeylet = xrpl::keylet::account(*accountID); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject(accountKeylet.key, lgrInfo.seq, ctx.yield); @@ -110,11 +110,11 @@ VaultInfoHandler::process(VaultInfoHandler::Input const& input, Context const& c return std::unexpected{Status{ClioError::RpcEntryNotFound}}; } - return ripple::keylet::vault(*accountID, *input.tnxSequence); + return xrpl::keylet::vault(*accountID, *input.tnxSequence); } - ripple::uint256 nodeIndex; + xrpl::uint256 nodeIndex; if (nodeIndex.parseHex(*input.vaultID)) - return ripple::keylet::vault(nodeIndex); + return xrpl::keylet::vault(nodeIndex); return std::unexpected{Status{ClioError::RpcEntryNotFound}}; }(); @@ -129,26 +129,26 @@ VaultInfoHandler::process(VaultInfoHandler::Input const& input, Context const& c if (not vaultLedgerObject) return Error{Status{ClioError::RpcEntryNotFound, "vault object not found."}}; - ripple::STLedgerEntry const vaultSle{ - ripple::SerialIter{vaultLedgerObject->data(), vaultLedgerObject->size()}, vaultKeylet.value().key + xrpl::STLedgerEntry const vaultSle{ + xrpl::SerialIter{vaultLedgerObject->data(), vaultLedgerObject->size()}, vaultKeylet.value().key }; - auto const issuanceKeylet = ripple::keylet::mptIssuance(vaultSle[ripple::sfShareMPTID]).key; + auto const issuanceKeylet = xrpl::keylet::mptIssuance(vaultSle[xrpl::sfShareMPTID]).key; auto const issuanceObject = sharedPtrBackend_->fetchLedgerObject(issuanceKeylet, lgrInfo.seq, ctx.yield); if (not issuanceObject) return Error{Status{ClioError::RpcEntryNotFound, "issuance object not found."}}; - ripple::STLedgerEntry const issuanceSle{ - ripple::SerialIter{issuanceObject->data(), issuanceObject->size()}, issuanceKeylet + xrpl::STLedgerEntry const issuanceSle{ + xrpl::SerialIter{issuanceObject->data(), issuanceObject->size()}, issuanceKeylet }; // put issuance object into "shares" field of vault object // follows same logic as rippled: // https://github.com/XRPLF/rippled/pull/5224/files#diff-6cb544622c7942261f097d628f61f1c1fcf34a1bcfd954aedbada4238fc28f69R107 Output response; - response.vault = toBoostJson(vaultSle.getJson(ripple::JsonOptions::none)); - response.vault.as_object()[JS(shares)] = toBoostJson(issuanceSle.getJson(ripple::JsonOptions::none)); + response.vault = toBoostJson(vaultSle.getJson(xrpl::JsonOptions::Values::None)); + response.vault.as_object()[JS(shares)] = toBoostJson(issuanceSle.getJson(xrpl::JsonOptions::Values::None)); response.ledgerIndex = lgrInfo.seq; return response; diff --git a/src/util/AccountUtils.hpp b/src/util/AccountUtils.hpp index ce4ea9f98..1c872b844 100644 --- a/src/util/AccountUtils.hpp +++ b/src/util/AccountUtils.hpp @@ -44,7 +44,7 @@ parseBase58Wrapper(std::string const& str) if (!std::all_of(std::begin(str), std::end(str), [](unsigned char c) { return std::isalnum(c); })) return std::nullopt; - return ripple::parseBase58(str); + return xrpl::parseBase58(str); } /** @@ -58,12 +58,12 @@ parseBase58Wrapper(std::string const& str) */ template [[nodiscard]] std::optional -parseBase58Wrapper(ripple::TokenType type, std::string const& str) +parseBase58Wrapper(xrpl::TokenType type, std::string const& str) { if (!std::all_of(std::begin(str), std::end(str), [](unsigned char c) { return std::isalnum(c); })) return std::nullopt; - return ripple::parseBase58(type, str); + return xrpl::parseBase58(type, str); } } // namespace util diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt index ba393f29c..323fff23e 100644 --- a/src/util/CMakeLists.txt +++ b/src/util/CMakeLists.txt @@ -52,7 +52,6 @@ target_link_libraries( clio_util PUBLIC Boost::headers Boost::iostreams - Boost::coroutine Boost::context fmt::fmt openssl::openssl diff --git a/src/util/LedgerUtils.cpp b/src/util/LedgerUtils.cpp index ca7cfb515..a70427386 100644 --- a/src/util/LedgerUtils.cpp +++ b/src/util/LedgerUtils.cpp @@ -31,16 +31,16 @@ namespace util { -ripple::LedgerEntryType +xrpl::LedgerEntryType LedgerTypes::getLedgerEntryTypeFromStr(std::string const& entryName) { if (auto const result = getLedgerTypeAttributeFromStr(entryName); result.has_value()) { return result->get().type_; } - return ripple::ltANY; + return xrpl::ltANY; } -ripple::LedgerEntryType +xrpl::LedgerEntryType LedgerTypes::getAccountOwnedLedgerTypeFromStr(std::string const& entryName) { if (auto const result = getLedgerTypeAttributeFromStr(entryName); @@ -48,7 +48,7 @@ LedgerTypes::getAccountOwnedLedgerTypeFromStr(std::string const& entryName) return result->get().type_; } - return ripple::ltANY; + return xrpl::ltANY; } std::optional> diff --git a/src/util/LedgerUtils.hpp b/src/util/LedgerUtils.hpp index cbf81fc33..4ac0c9474 100644 --- a/src/util/LedgerUtils.hpp +++ b/src/util/LedgerUtils.hpp @@ -51,7 +51,7 @@ class LedgerTypeAttribute { DeletionBlocker // The ledger object is owned by account and it blocks deletion }; - ripple::LedgerEntryType type_ = ripple::ltANY; + xrpl::LedgerEntryType type_ = xrpl::ltANY; char const* name_ = nullptr; char const* rpcName_ = nullptr; LedgerCategory category_ = LedgerCategory::Invalid; @@ -59,7 +59,7 @@ class LedgerTypeAttribute { constexpr LedgerTypeAttribute( char const* name, char const* rpcName, - ripple::LedgerEntryType type, + xrpl::LedgerEntryType type, LedgerCategory category ) : type_{type}, name_{name}, rpcName_{rpcName}, category_{category} @@ -68,19 +68,19 @@ class LedgerTypeAttribute { public: static constexpr LedgerTypeAttribute - chainLedgerType(char const* name, char const* rpcName, ripple::LedgerEntryType type) + chainLedgerType(char const* name, char const* rpcName, xrpl::LedgerEntryType type) { return LedgerTypeAttribute(name, rpcName, type, LedgerCategory::Chain); } static constexpr LedgerTypeAttribute - accountOwnedLedgerType(char const* name, char const* rpcName, ripple::LedgerEntryType type) + accountOwnedLedgerType(char const* name, char const* rpcName, xrpl::LedgerEntryType type) { return LedgerTypeAttribute(name, rpcName, type, LedgerCategory::AccountOwned); } static constexpr LedgerTypeAttribute - deletionBlockerLedgerType(char const* name, char const* rpcName, ripple::LedgerEntryType type) + deletionBlockerLedgerType(char const* name, char const* rpcName, xrpl::LedgerEntryType type) { return LedgerTypeAttribute(name, rpcName, type, LedgerCategory::DeletionBlocker); } @@ -98,51 +98,47 @@ class LedgerTypes { using LedgerTypeAttributeList = LedgerTypeAttribute[]; static constexpr LedgerTypeAttributeList const kLEDGER_TYPES{ - LedgerTypeAttribute::accountOwnedLedgerType(JS(AccountRoot), JS(account), ripple::ltACCOUNT_ROOT), - LedgerTypeAttribute::chainLedgerType(JS(Amendments), JS(amendments), ripple::ltAMENDMENTS), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(Check), JS(check), ripple::ltCHECK), - LedgerTypeAttribute::accountOwnedLedgerType(JS(DepositPreauth), JS(deposit_preauth), ripple::ltDEPOSIT_PREAUTH), + LedgerTypeAttribute::accountOwnedLedgerType(JS(AccountRoot), JS(account), xrpl::ltACCOUNT_ROOT), + LedgerTypeAttribute::chainLedgerType(JS(Amendments), JS(amendments), xrpl::ltAMENDMENTS), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(Check), JS(check), xrpl::ltCHECK), + LedgerTypeAttribute::accountOwnedLedgerType(JS(DepositPreauth), JS(deposit_preauth), xrpl::ltDEPOSIT_PREAUTH), // dir node belongs to account, but can not be filtered from account_objects - LedgerTypeAttribute::chainLedgerType(JS(DirectoryNode), JS(directory), ripple::ltDIR_NODE), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(Escrow), JS(escrow), ripple::ltESCROW), - LedgerTypeAttribute::chainLedgerType(JS(FeeSettings), JS(fee), ripple::ltFEE_SETTINGS), - LedgerTypeAttribute::chainLedgerType(JS(LedgerHashes), JS(hashes), ripple::ltLEDGER_HASHES), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Offer), JS(offer), ripple::ltOFFER), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(PayChannel), JS(payment_channel), ripple::ltPAYCHAN), - LedgerTypeAttribute::accountOwnedLedgerType(JS(SignerList), JS(signer_list), ripple::ltSIGNER_LIST), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(RippleState), JS(state), ripple::ltRIPPLE_STATE), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Ticket), JS(ticket), ripple::ltTICKET), - LedgerTypeAttribute::accountOwnedLedgerType(JS(NFTokenOffer), JS(nft_offer), ripple::ltNFTOKEN_OFFER), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(NFTokenPage), JS(nft_page), ripple::ltNFTOKEN_PAGE), - LedgerTypeAttribute::accountOwnedLedgerType(JS(AMM), JS(amm), ripple::ltAMM), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(Bridge), JS(bridge), ripple::ltBRIDGE), + LedgerTypeAttribute::chainLedgerType(JS(DirectoryNode), JS(directory), xrpl::ltDIR_NODE), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(Escrow), JS(escrow), xrpl::ltESCROW), + LedgerTypeAttribute::chainLedgerType(JS(FeeSettings), JS(fee), xrpl::ltFEE_SETTINGS), + LedgerTypeAttribute::chainLedgerType(JS(LedgerHashes), JS(hashes), xrpl::ltLEDGER_HASHES), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Offer), JS(offer), xrpl::ltOFFER), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(PayChannel), JS(payment_channel), xrpl::ltPAYCHAN), + LedgerTypeAttribute::accountOwnedLedgerType(JS(SignerList), JS(signer_list), xrpl::ltSIGNER_LIST), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(RippleState), JS(state), xrpl::ltRIPPLE_STATE), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Ticket), JS(ticket), xrpl::ltTICKET), + LedgerTypeAttribute::accountOwnedLedgerType(JS(NFTokenOffer), JS(nft_offer), xrpl::ltNFTOKEN_OFFER), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(NFTokenPage), JS(nft_page), xrpl::ltNFTOKEN_PAGE), + LedgerTypeAttribute::accountOwnedLedgerType(JS(AMM), JS(amm), xrpl::ltAMM), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(Bridge), JS(bridge), xrpl::ltBRIDGE), LedgerTypeAttribute::deletionBlockerLedgerType( JS(XChainOwnedClaimID), JS(xchain_owned_claim_id), - ripple::ltXCHAIN_OWNED_CLAIM_ID + xrpl::ltXCHAIN_OWNED_CLAIM_ID ), LedgerTypeAttribute::deletionBlockerLedgerType( JS(XChainOwnedCreateAccountClaimID), JS(xchain_owned_create_account_claim_id), - ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID + xrpl::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID ), - LedgerTypeAttribute::accountOwnedLedgerType(JS(DID), JS(did), ripple::ltDID), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Oracle), JS(oracle), ripple::ltORACLE), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Credential), JS(credential), ripple::ltCREDENTIAL), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Vault), JS(vault), ripple::ltVAULT), - LedgerTypeAttribute::chainLedgerType(JS(NegativeUNL), JS(nunl), ripple::ltNEGATIVE_UNL), - LedgerTypeAttribute::deletionBlockerLedgerType( - JS(MPTokenIssuance), - JS(mpt_issuance), - ripple::ltMPTOKEN_ISSUANCE - ), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(MPToken), JS(mptoken), ripple::ltMPTOKEN), + LedgerTypeAttribute::accountOwnedLedgerType(JS(DID), JS(did), xrpl::ltDID), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Oracle), JS(oracle), xrpl::ltORACLE), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Credential), JS(credential), xrpl::ltCREDENTIAL), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Vault), JS(vault), xrpl::ltVAULT), + LedgerTypeAttribute::chainLedgerType(JS(NegativeUNL), JS(nunl), xrpl::ltNEGATIVE_UNL), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(MPTokenIssuance), JS(mpt_issuance), xrpl::ltMPTOKEN_ISSUANCE), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(MPToken), JS(mptoken), xrpl::ltMPTOKEN), LedgerTypeAttribute::deletionBlockerLedgerType( JS(PermissionedDomain), JS(permissioned_domain), - ripple::ltPERMISSIONED_DOMAIN + xrpl::ltPERMISSIONED_DOMAIN ), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Delegate), JS(delegate), ripple::ltDELEGATE), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Delegate), JS(delegate), xrpl::ltDELEGATE), }; public: @@ -172,7 +168,7 @@ public: constexpr auto kDELETION_BLOCKERS_COUNT = std::count_if(std::begin(kLEDGER_TYPES), std::end(kLEDGER_TYPES), kFILTER); - std::array res{}; + std::array res{}; auto it = std::begin(res); std::ranges::for_each(kLEDGER_TYPES, [&](auto const& item) { if (kFILTER(item)) { @@ -184,22 +180,22 @@ public: } /** - * @brief Returns the ripple::LedgerEntryType from the given string. + * @brief Returns the xrpl::LedgerEntryType from the given string. * * @param entryName The name or canonical name (case-insensitive) of the ledger entry type for all categories - * @return The ripple::LedgerEntryType of the given string, returns ltANY if not found. + * @return The xrpl::LedgerEntryType of the given string, returns ltANY if not found. */ - static ripple::LedgerEntryType + static xrpl::LedgerEntryType getLedgerEntryTypeFromStr(std::string const& entryName); /** - * @brief Returns the ripple::LedgerEntryType from the given string. + * @brief Returns the xrpl::LedgerEntryType from the given string. * * @param entryName The name or canonical name (case-insensitive) of the ledger entry type for account owned * category - * @return The ripple::LedgerEntryType of the given string, returns ltANY if not found. + * @return The xrpl::LedgerEntryType of the given string, returns ltANY if not found. */ - static ripple::LedgerEntryType + static xrpl::LedgerEntryType getAccountOwnedLedgerTypeFromStr(std::string const& entryName); private: @@ -208,32 +204,32 @@ private: }; /** - * @brief Deserializes a ripple::LedgerHeader from ripple::Slice of data. + * @brief Deserializes a xrpl::LedgerHeader from xrpl::Slice of data. * * @param data The slice to deserialize - * @return The deserialized ripple::LedgerHeader + * @return The deserialized xrpl::LedgerHeader */ -inline ripple::LedgerHeader -deserializeHeader(ripple::Slice data) +inline xrpl::LedgerHeader +deserializeHeader(xrpl::Slice data) { - return ripple::deserializeHeader(data, /* hasHash = */ true); + return xrpl::deserializeHeader(data, /* hasHash = */ true); } /** - * @brief A helper function that converts a ripple::LedgerHeader to a string representation. + * @brief A helper function that converts a xrpl::LedgerHeader to a string representation. * * @param info The ledger header * @return The string representation of the supplied ledger header */ inline std::string -toString(ripple::LedgerHeader const& info) +toString(xrpl::LedgerHeader const& info) { return fmt::format( "LedgerHeader {{Sequence: {}, Hash: {}, TxHash: {}, AccountHash: {}, ParentHash: {}}}", info.seq, - ripple::strHex(info.hash), + xrpl::strHex(info.hash), strHex(info.txHash), - ripple::strHex(info.accountHash), + xrpl::strHex(info.accountHash), strHex(info.parentHash) ); } diff --git a/src/util/Shasum.cpp b/src/util/Shasum.cpp index d3b65e408..29882815e 100644 --- a/src/util/Shasum.cpp +++ b/src/util/Shasum.cpp @@ -28,13 +28,13 @@ namespace util { -ripple::uint256 +xrpl::uint256 sha256sum(std::string_view s) { - ripple::sha256_hasher hasher; + xrpl::sha256_hasher hasher; hasher(s.data(), s.size()); - auto const hashData = static_cast(hasher); - ripple::uint256 sha256; + auto const hashData = static_cast(hasher); + xrpl::uint256 sha256; std::memcpy(sha256.data(), hashData.data(), hashData.size()); return sha256; } @@ -42,7 +42,7 @@ sha256sum(std::string_view s) std::string sha256sumString(std::string_view s) { - return ripple::to_string(sha256sum(s)); + return xrpl::to_string(sha256sum(s)); } void @@ -51,13 +51,13 @@ Sha256sum::update(void const* data, size_t size) hasher_(data, size); } -ripple::uint256 +xrpl::uint256 Sha256sum::finalize() && { - auto const hashData = static_cast(hasher_); - ripple::uint256 result; + auto const hashData = static_cast(hasher_); + xrpl::uint256 result; std::memcpy(result.data(), hashData.data(), hashData.size()); - hasher_ = ripple::sha256_hasher{}; + hasher_ = xrpl::sha256_hasher{}; return result; } diff --git a/src/util/Shasum.hpp b/src/util/Shasum.hpp index 54834c0af..c0c021d4d 100644 --- a/src/util/Shasum.hpp +++ b/src/util/Shasum.hpp @@ -31,9 +31,9 @@ namespace util { * @brief Calculates the SHA256 sum of a string. * * @param s The string to hash. - * @return The SHA256 sum as a ripple::uint256. + * @return The SHA256 sum as a xrpl::uint256. */ -ripple::uint256 +xrpl::uint256 sha256sum(std::string_view s); /** @@ -52,7 +52,7 @@ sha256sumString(std::string_view s); * without requiring all data to be in memory at once. */ class Sha256sum { - ripple::sha256_hasher hasher_; + xrpl::sha256_hasher hasher_; public: /** @@ -77,11 +77,11 @@ public: } /** - * @brief Finalize hash and return result as ripple::uint256. + * @brief Finalize hash and return result as xrpl::uint256. * * @return The SHA-256 hash. */ - ripple::uint256 + xrpl::uint256 finalize() &&; }; diff --git a/src/util/TimeUtils.cpp b/src/util/TimeUtils.cpp index 557b9c2eb..228bbde6f 100644 --- a/src/util/TimeUtils.cpp +++ b/src/util/TimeUtils.cpp @@ -49,9 +49,9 @@ systemTpToUtcStr(std::chrono::system_clock::time_point const& tp, std::string co } [[nodiscard]] std::chrono::system_clock::time_point -systemTpFromLedgerCloseTime(ripple::NetClock::time_point closeTime) +systemTpFromLedgerCloseTime(xrpl::NetClock::time_point closeTime) { - return std::chrono::system_clock::time_point{closeTime.time_since_epoch() + ripple::epoch_offset}; + return std::chrono::system_clock::time_point{closeTime.time_since_epoch() + xrpl::kEpochOffset}; } } // namespace util diff --git a/src/util/TimeUtils.hpp b/src/util/TimeUtils.hpp index 012479ca8..063a9fd9a 100644 --- a/src/util/TimeUtils.hpp +++ b/src/util/TimeUtils.hpp @@ -52,6 +52,6 @@ systemTpToUtcStr(std::chrono::system_clock::time_point const& tp, std::string co * @return The system_clock::time_point. */ [[nodiscard]] std::chrono::system_clock::time_point -systemTpFromLedgerCloseTime(ripple::NetClock::time_point closeTime); +systemTpFromLedgerCloseTime(xrpl::NetClock::time_point closeTime); } // namespace util diff --git a/src/util/TxUtils.cpp b/src/util/TxUtils.cpp index 40360e6f9..374282989 100644 --- a/src/util/TxUtils.cpp +++ b/src/util/TxUtils.cpp @@ -39,8 +39,8 @@ getTxTypesInLowercase() static std::unordered_set const kTYPES_KEYS_IN_LOWERCASE = []() { std::unordered_set keys; std::transform( - ripple::TxFormats::getInstance().begin(), - ripple::TxFormats::getInstance().end(), + xrpl::TxFormats::getInstance().begin(), + xrpl::TxFormats::getInstance().end(), std::inserter(keys, keys.begin()), [](auto const& pair) { return util::toLower(pair.getName()); } ); diff --git a/src/web/ProxyIpResolver.hpp b/src/web/ProxyIpResolver.hpp index f805e3336..2b888367e 100644 --- a/src/web/ProxyIpResolver.hpp +++ b/src/web/ProxyIpResolver.hpp @@ -43,8 +43,8 @@ namespace web { */ class ProxyIpResolver { std::unordered_set proxyIps_; - // ripple::uint256 doesn't have hash implementation - std::unordered_set proxyTokens_; + // xrpl::uint256 doesn't have hash implementation + std::unordered_set proxyTokens_; public: /** diff --git a/src/web/impl/ErrorHandling.hpp b/src/web/impl/ErrorHandling.hpp index fff6589d6..f1230f08d 100644 --- a/src/web/impl/ErrorHandling.hpp +++ b/src/web/impl/ErrorHandling.hpp @@ -111,7 +111,7 @@ public: sendInternalError() const { connection_->send( - boost::json::serialize(composeError(rpc::RippledError::rpcINTERNAL)), + boost::json::serialize(composeError(rpc::RippledError::RpcInternal)), boost::beast::http::status::internal_server_error ); } @@ -120,7 +120,7 @@ public: sendNotReadyError() const { connection_->send( - boost::json::serialize(composeError(rpc::RippledError::rpcNOT_READY)), boost::beast::http::status::ok + boost::json::serialize(composeError(rpc::RippledError::RpcNotReady)), boost::beast::http::status::ok ); } @@ -129,11 +129,11 @@ public: { if (connection_->upgraded) { connection_->send( - boost::json::serialize(rpc::makeError(rpc::RippledError::rpcTOO_BUSY)), boost::beast::http::status::ok + boost::json::serialize(rpc::makeError(rpc::RippledError::RpcTooBusy)), boost::beast::http::status::ok ); } else { connection_->send( - boost::json::serialize(rpc::makeError(rpc::RippledError::rpcTOO_BUSY)), + boost::json::serialize(rpc::makeError(rpc::RippledError::RpcTooBusy)), boost::beast::http::status::service_unavailable ); } @@ -143,7 +143,7 @@ public: sendJsonParsingError() const { if (connection_->upgraded) { - connection_->send(boost::json::serialize(rpc::makeError(rpc::RippledError::rpcBAD_SYNTAX))); + connection_->send(boost::json::serialize(rpc::makeError(rpc::RippledError::RpcBadSyntax))); } else { connection_->send( fmt::format("Unable to parse JSON from the request"), boost::beast::http::status::bad_request diff --git a/src/web/impl/HttpBase.hpp b/src/web/impl/HttpBase.hpp index aed5d7e9c..92041b872 100644 --- a/src/web/impl/HttpBase.hpp +++ b/src/web/impl/HttpBase.hpp @@ -287,7 +287,7 @@ public: return sender_(httpResponse( http::status::internal_server_error, "application/json", - boost::json::serialize(rpc::makeError(rpc::RippledError::rpcINTERNAL)) + boost::json::serialize(rpc::makeError(rpc::RippledError::RpcInternal)) )); } } @@ -298,7 +298,7 @@ public: sender_(httpResponse( http::status::service_unavailable, "text/plain", - boost::json::serialize(rpc::makeError(rpc::RippledError::rpcSLOW_DOWN)) + boost::json::serialize(rpc::makeError(rpc::RippledError::RpcSlowDown)) )); } diff --git a/src/web/impl/WsBase.hpp b/src/web/impl/WsBase.hpp index 320259c9a..38b9b6e62 100644 --- a/src/web/impl/WsBase.hpp +++ b/src/web/impl/WsBase.hpp @@ -167,7 +167,7 @@ public: void sendSlowDown(std::string const& request) override { - sendError(rpc::RippledError::rpcSLOW_DOWN, request); + sendError(rpc::RippledError::RpcSlowDown, request); } /** @@ -290,7 +290,7 @@ public: try { (*handler_)(requestStr, shared_from_this()); } catch (std::exception const&) { - sendError(rpc::RippledError::rpcINTERNAL, std::move(requestStr)); + sendError(rpc::RippledError::RpcInternal, std::move(requestStr)); } doRead(); diff --git a/src/web/ng/RPCServerHandler.hpp b/src/web/ng/RPCServerHandler.hpp index a0fa2f337..cba56575d 100644 --- a/src/web/ng/RPCServerHandler.hpp +++ b/src/web/ng/RPCServerHandler.hpp @@ -338,7 +338,7 @@ private: static Response makeSlowDownResponse(Request const& request, std::optional requestJson) { - auto error = rpc::makeError(rpc::RippledError::rpcSLOW_DOWN); + auto error = rpc::makeError(rpc::RippledError::RpcSlowDown); if (not request.isHttp()) { try { diff --git a/src/web/ng/impl/ErrorHandling.cpp b/src/web/ng/impl/ErrorHandling.cpp index 215cef225..808eefb6a 100644 --- a/src/web/ng/impl/ErrorHandling.cpp +++ b/src/web/ng/impl/ErrorHandling.cpp @@ -121,30 +121,30 @@ ErrorHelper::makeError(rpc::Status const& err) const Response ErrorHelper::makeInternalError() const { - return Response{http::status::internal_server_error, composeError(rpc::RippledError::rpcINTERNAL), rawRequest_}; + return Response{http::status::internal_server_error, composeError(rpc::RippledError::RpcInternal), rawRequest_}; } Response ErrorHelper::makeNotReadyError() const { - return Response{http::status::ok, composeError(rpc::RippledError::rpcNOT_READY), rawRequest_}; + return Response{http::status::ok, composeError(rpc::RippledError::RpcNotReady), rawRequest_}; } Response ErrorHelper::makeTooBusyError() const { if (not rawRequest_.get().isHttp()) { - return Response{http::status::too_many_requests, rpc::makeError(rpc::RippledError::rpcTOO_BUSY), rawRequest_}; + return Response{http::status::too_many_requests, rpc::makeError(rpc::RippledError::RpcTooBusy), rawRequest_}; } - return Response{http::status::service_unavailable, rpc::makeError(rpc::RippledError::rpcTOO_BUSY), rawRequest_}; + return Response{http::status::service_unavailable, rpc::makeError(rpc::RippledError::RpcTooBusy), rawRequest_}; } Response ErrorHelper::makeJsonParsingError() const { if (not rawRequest_.get().isHttp()) { - return Response{http::status::bad_request, rpc::makeError(rpc::RippledError::rpcBAD_SYNTAX), rawRequest_}; + return Response{http::status::bad_request, rpc::makeError(rpc::RippledError::RpcBadSyntax), rawRequest_}; } return Response{http::status::bad_request, fmt::format("Unable to parse JSON from the request"), rawRequest_}; diff --git a/tests/common/etl/FakeDiffProvider.hpp b/tests/common/etl/FakeDiffProvider.hpp index 6f76a485e..45dc8ccc1 100644 --- a/tests/common/etl/FakeDiffProvider.hpp +++ b/tests/common/etl/FakeDiffProvider.hpp @@ -36,7 +36,7 @@ struct DiffProvider { std::vector getLatestDiff() // NOLINT(readability-convert-member-functions-to-static) { - using namespace ripple; + using namespace xrpl; return { {.key = uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{'s'}}, @@ -53,7 +53,7 @@ struct DiffProvider { }; } - std::optional + std::optional nextKey(std::size_t keysSize) { // mock the result from doFetchSuccessorKey, be aware this function will be called from multiple threads @@ -68,7 +68,7 @@ struct DiffProvider { return std::nullopt; } - return ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}; + return xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}; } private: diff --git a/tests/common/util/BinaryTestObject.cpp b/tests/common/util/BinaryTestObject.cpp index c4ac50058..3d137d68e 100644 --- a/tests/common/util/BinaryTestObject.cpp +++ b/tests/common/util/BinaryTestObject.cpp @@ -62,20 +62,20 @@ createTxAndMetaBlobs(std::string metaStr, std::string txnStr) return {hexStringToBinaryString(metaStr), hexStringToBinaryString(txnStr)}; } -std::pair +std::pair createTxAndMeta(std::string hashStr, std::string metaStr, std::string txnStr) { - ripple::uint256 hash; + xrpl::uint256 hash; EXPECT_TRUE(hash.parseHex(hashStr)); auto const [metaBlob, txnBlob] = createTxAndMetaBlobs(metaStr, txnStr); - ripple::SerialIter it{txnBlob.data(), txnBlob.size()}; - return {ripple::STTx{it}, ripple::TxMeta{hash, kSEQ, metaBlob}}; + xrpl::SerialIter it{txnBlob.data(), txnBlob.size()}; + return {xrpl::STTx{it}, xrpl::TxMeta{hash, kSEQ, xrpl::Blob{metaBlob.begin(), metaBlob.end()}}}; } etl::model::Transaction -createTransaction(ripple::TxType type, std::string hashStr, std::string metaStr, std::string txnStr) +createTransaction(xrpl::TxType type, std::string hashStr, std::string metaStr, std::string txnStr) { auto const [sttx, meta] = createTxAndMeta(hashStr, metaStr, txnStr); return { @@ -83,7 +83,7 @@ createTransaction(ripple::TxType type, std::string hashStr, std::string metaStr, .metaRaw = "", .sttx = sttx, .meta = meta, - .id = ripple::uint256{"0000000000000000000000000000000000000000000000000000000000000001"}, + .id = xrpl::uint256{"0000000000000000000000000000000000000000000000000000000000000001"}, .key = "0000000000000000000000000000000000000000000000000000000000000001", .type = type }; @@ -104,7 +104,7 @@ createObject(etl::model::Object::ModType modType, std::string key) return { .key = binaryStringToUint256(hexStringToBinaryString(key)), .keyRaw = hexStringToBinaryString(key), - .data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{} : *ripple::strUnHex(kOBJ_BLOB), + .data = modType == etl::model::Object::ModType::Deleted ? xrpl::Blob{} : *xrpl::strUnHex(kOBJ_BLOB), .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" : hexStringToBinaryString(kOBJ_BLOB), .successor = hexStringToBinaryString(kOBJ_SUCC), .predecessor = hexStringToBinaryString(kOBJ_PRED), @@ -126,7 +126,7 @@ createObjectWithBookBase(etl::model::Object::ModType modType, std::string key) return { .key = binaryStringToUint256(hexStringToBinaryString(key)), .keyRaw = hexStringToBinaryString(key), - .data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{} : *ripple::strUnHex(kOBJ_BLOB), + .data = modType == etl::model::Object::ModType::Deleted ? xrpl::Blob{} : *xrpl::strUnHex(kOBJ_BLOB), .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" : hexStringToBinaryString(kOBJ_BLOB), .successor = hexStringToBinaryString(kOBJ_SUCC), .predecessor = hexStringToBinaryString(kOBJ_PRED), @@ -139,8 +139,8 @@ createObjectWithTwoNFTs() { std::string const url1 = "abcd1"; std::string const url2 = "abcd2"; - ripple::Blob const uri1Blob(url1.begin(), url1.end()); - ripple::Blob const uri2Blob(url2.begin(), url2.end()); + xrpl::Blob const uri1Blob(url1.begin(), url1.end()); + xrpl::Blob const uri2Blob(url2.begin(), url2.end()); constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; constexpr auto kNFT_ID = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000"; @@ -173,13 +173,13 @@ createObjectWithMPT() constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; auto const account = getAccountIdWithString(kACCOUNT); - auto const mptID = ripple::makeMptID(2, getAccountIdWithString(kACCOUNT)); + auto const mptID = xrpl::makeMptID(2, getAccountIdWithString(kACCOUNT)); auto const mptokenObject = createMpTokenObject(kACCOUNT, mptID); // key is a token made up from several fields described here: // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0033-multi-purpose-tokens#2121-mptoken-ledger-identifier constexpr auto kSPACE_KEY = 0x007F; - auto const keySha512Half = ripple::sha512Half(kSPACE_KEY, mptID, account); + auto const keySha512Half = xrpl::sha512Half(kSPACE_KEY, mptID, account); return { .key = {}, @@ -199,10 +199,8 @@ etl::model::BookSuccessor createSuccessor() { return { - .firstBook = - uint256ToString(ripple::uint256{"A000000000000000000000000000000000000000000000000000000000000000"}), - .bookBase = - uint256ToString(ripple::uint256{"A000000000000000000000000000000000000000000000000000000000000001"}), + .firstBook = uint256ToString(xrpl::uint256{"A000000000000000000000000000000000000000000000000000000000000000"}), + .bookBase = uint256ToString(xrpl::uint256{"A000000000000000000000000000000000000000000000000000000000000001"}), }; } diff --git a/tests/common/util/BinaryTestObject.hpp b/tests/common/util/BinaryTestObject.hpp index 5f6d2ad58..06329e9a3 100644 --- a/tests/common/util/BinaryTestObject.hpp +++ b/tests/common/util/BinaryTestObject.hpp @@ -146,7 +146,7 @@ static constexpr auto kDEFAULT_OBJ_KEY = "B00AA769C00726371689ED66A7CF57C2502F1B [[maybe_unused, nodiscard]] std::pair createTxAndMetaBlobs(std::string metaStr = kDEFAULT_TXN_META, std::string txnStr = kDEFAULT_TXN_HEX); -[[maybe_unused, nodiscard]] std::pair +[[maybe_unused, nodiscard]] std::pair createTxAndMeta( std::string hashStr = kDEFAULT_HASH, std::string metaStr = kDEFAULT_TXN_META, @@ -155,7 +155,7 @@ createTxAndMeta( [[maybe_unused, nodiscard]] etl::model::Transaction createTransaction( - ripple::TxType type, + xrpl::TxType type, std::string hashStr = kDEFAULT_HASH, std::string metaStr = kDEFAULT_TXN_META, std::string txnStr = kDEFAULT_TXN_HEX diff --git a/tests/common/util/MockBackend.hpp b/tests/common/util/MockBackend.hpp index a6447d5da..9fb27c3d1 100644 --- a/tests/common/util/MockBackend.hpp +++ b/tests/common/util/MockBackend.hpp @@ -45,16 +45,16 @@ struct MockBackend : public BackendInterface { } MOCK_METHOD( - std::optional, + std::optional, fetchLedgerBySequence, (std::uint32_t const, boost::asio::yield_context), (const, override) ); MOCK_METHOD( - std::optional, + std::optional, fetchLedgerByHash, - (ripple::uint256 const&, boost::asio::yield_context), + (xrpl::uint256 const&, boost::asio::yield_context), (const, override) ); @@ -68,21 +68,21 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( std::optional, fetchTransaction, - (ripple::uint256 const&, boost::asio::yield_context), + (xrpl::uint256 const&, boost::asio::yield_context), (const, override) ); MOCK_METHOD( std::vector, fetchTransactions, - (std::vector const&, boost::asio::yield_context), + (std::vector const&, boost::asio::yield_context), (const, override) ); MOCK_METHOD( data::TransactionsAndCursor, fetchAccountTransactions, - (ripple::AccountID const&, + (xrpl::AccountID const&, std::uint32_t const, bool, std::optional const&, @@ -98,7 +98,7 @@ struct MockBackend : public BackendInterface { ); MOCK_METHOD( - std::vector, + std::vector, fetchAllTransactionHashesInLedger, (std::uint32_t const, boost::asio::yield_context), (const, override) @@ -107,14 +107,14 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( std::optional, fetchNFT, - (ripple::uint256 const&, std::uint32_t const, boost::asio::yield_context), + (xrpl::uint256 const&, std::uint32_t const, boost::asio::yield_context), (const, override) ); MOCK_METHOD( data::TransactionsAndCursor, fetchNFTTransactions, - (ripple::uint256 const&, + (xrpl::uint256 const&, std::uint32_t const, bool const, std::optional const&, @@ -125,11 +125,11 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( data::NFTsAndCursor, fetchNFTsByIssuer, - (ripple::AccountID const& issuer, + (xrpl::AccountID const& issuer, std::optional const& taxon, std::uint32_t const ledgerSequence, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield), (const, override) ); @@ -137,12 +137,12 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( std::vector, doFetchLedgerObjects, - (std::vector const&, std::uint32_t const, boost::asio::yield_context), + (std::vector const&, std::uint32_t const, boost::asio::yield_context), (const, override) ); MOCK_METHOD( - std::vector, + std::vector, fetchAccountRoots, (std::uint32_t, std::uint32_t, std::uint32_t, boost::asio::yield_context), (const, override) @@ -151,14 +151,14 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( std::optional, doFetchLedgerObject, - (ripple::uint256 const&, std::uint32_t const, boost::asio::yield_context), + (xrpl::uint256 const&, std::uint32_t const, boost::asio::yield_context), (const, override) ); MOCK_METHOD( std::optional, doFetchLedgerObjectSeq, - (ripple::uint256 const&, std::uint32_t const, boost::asio::yield_context), + (xrpl::uint256 const&, std::uint32_t const, boost::asio::yield_context), (const, override) ); @@ -170,9 +170,9 @@ struct MockBackend : public BackendInterface { ); MOCK_METHOD( - std::optional, + std::optional, doFetchSuccessorKey, - (ripple::uint256, std::uint32_t const, boost::asio::yield_context), + (xrpl::uint256, std::uint32_t const, boost::asio::yield_context), (const, override) ); @@ -193,7 +193,7 @@ struct MockBackend : public BackendInterface { (const, override) ); - MOCK_METHOD(void, writeLedger, (ripple::LedgerHeader const&, std::string&&), (override)); + MOCK_METHOD(void, writeLedger, (xrpl::LedgerHeader const&, std::string&&), (override)); MOCK_METHOD(void, writeLedgerObject, (std::string&&, std::uint32_t const, std::string&&), (override)); @@ -233,9 +233,9 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( data::MPTHoldersAndCursor, fetchMPTHolders, - (ripple::uint192 const& mptID, + (xrpl::uint192 const& mptID, std::uint32_t const, - (std::optional const&), + (std::optional const&), std::uint32_t const, boost::asio::yield_context), (const, override) diff --git a/tests/common/util/MockLedgerCache.hpp b/tests/common/util/MockLedgerCache.hpp index 70bac9429..c8785a082 100644 --- a/tests/common/util/MockLedgerCache.hpp +++ b/tests/common/util/MockLedgerCache.hpp @@ -41,23 +41,23 @@ struct MockLedgerCache : data::LedgerCacheInterface { updateImp(a, b, c); } - MOCK_METHOD(std::optional, get, (ripple::uint256 const& a, uint32_t b), (const, override)); + MOCK_METHOD(std::optional, get, (xrpl::uint256 const& a, uint32_t b), (const, override)); MOCK_METHOD(void, update, (std::vector const&, uint32_t), (override)); - MOCK_METHOD(std::optional, getDeleted, (ripple::uint256 const&, uint32_t), (const, override)); + MOCK_METHOD(std::optional, getDeleted, (xrpl::uint256 const&, uint32_t), (const, override)); MOCK_METHOD( std::optional, getSuccessor, - (ripple::uint256 const& a, uint32_t b), + (xrpl::uint256 const& a, uint32_t b), (const, override) ); MOCK_METHOD( std::optional, getPredecessor, - (ripple::uint256 const& a, uint32_t b), + (xrpl::uint256 const& a, uint32_t b), (const, override) ); diff --git a/tests/common/util/MockLedgerPublisher.hpp b/tests/common/util/MockLedgerPublisher.hpp index 77b4d2278..8b8bc580e 100644 --- a/tests/common/util/MockLedgerPublisher.hpp +++ b/tests/common/util/MockLedgerPublisher.hpp @@ -30,7 +30,7 @@ struct MockLedgerPublisher : public etl::LedgerPublisherInterface { MOCK_METHOD(bool, publish, (uint32_t, std::optional, std::chrono::steady_clock::duration), (override)); - MOCK_METHOD(void, publish, (ripple::LedgerHeader const&), ()); + MOCK_METHOD(void, publish, (xrpl::LedgerHeader const&), ()); MOCK_METHOD(std::uint32_t, lastPublishAgeSeconds, (), (const)); MOCK_METHOD(std::chrono::time_point, getLastPublish, (), (const, override)); MOCK_METHOD(std::uint32_t, lastCloseAgeSeconds, (), (const, override)); diff --git a/tests/common/util/MockSubscriptionManager.hpp b/tests/common/util/MockSubscriptionManager.hpp index 9c8c03538..75481e2b4 100644 --- a/tests/common/util/MockSubscriptionManager.hpp +++ b/tests/common/util/MockSubscriptionManager.hpp @@ -48,14 +48,14 @@ struct MockSubscriptionManager : feed::SubscriptionManagerInterface { MOCK_METHOD( void, pubLedger, - (ripple::LedgerHeader const&, ripple::Fees const&, std::string const&, std::uint32_t), + (xrpl::LedgerHeader const&, xrpl::Fees const&, std::string const&, std::uint32_t), (override) ); MOCK_METHOD( void, pubBookChanges, - (ripple::LedgerHeader const&, std::vector const&), + (xrpl::LedgerHeader const&, std::vector const&), (override) ); @@ -65,15 +65,15 @@ struct MockSubscriptionManager : feed::SubscriptionManagerInterface { MOCK_METHOD(void, unsubTransactions, (feed::SubscriberSharedPtr const&), (override)); - MOCK_METHOD(void, pubTransaction, (data::TransactionAndMetadata const&, ripple::LedgerHeader const&), (override)); + MOCK_METHOD(void, pubTransaction, (data::TransactionAndMetadata const&, xrpl::LedgerHeader const&), (override)); - MOCK_METHOD(void, subAccount, (ripple::AccountID const&, feed::SubscriberSharedPtr const&), (override)); + MOCK_METHOD(void, subAccount, (xrpl::AccountID const&, feed::SubscriberSharedPtr const&), (override)); - MOCK_METHOD(void, unsubAccount, (ripple::AccountID const&, feed::SubscriberSharedPtr const&), (override)); + MOCK_METHOD(void, unsubAccount, (xrpl::AccountID const&, feed::SubscriberSharedPtr const&), (override)); - MOCK_METHOD(void, subBook, (ripple::Book const&, feed::SubscriberSharedPtr const&), (override)); + MOCK_METHOD(void, subBook, (xrpl::Book const&, feed::SubscriberSharedPtr const&), (override)); - MOCK_METHOD(void, unsubBook, (ripple::Book const&, feed::SubscriberSharedPtr const&), (override)); + MOCK_METHOD(void, unsubBook, (xrpl::Book const&, feed::SubscriberSharedPtr const&), (override)); MOCK_METHOD(void, subBookChanges, (feed::SubscriberSharedPtr const&), (override)); @@ -93,9 +93,9 @@ struct MockSubscriptionManager : feed::SubscriptionManagerInterface { MOCK_METHOD(void, forwardValidation, (boost::json::object const&), (override)); - MOCK_METHOD(void, subProposedAccount, (ripple::AccountID const&, feed::SubscriberSharedPtr const&), (override)); + MOCK_METHOD(void, subProposedAccount, (xrpl::AccountID const&, feed::SubscriberSharedPtr const&), (override)); - MOCK_METHOD(void, unsubProposedAccount, (ripple::AccountID const&, feed::SubscriberSharedPtr const&), (override)); + MOCK_METHOD(void, unsubProposedAccount, (xrpl::AccountID const&, feed::SubscriberSharedPtr const&), (override)); MOCK_METHOD(void, subProposedTransactions, (feed::SubscriberSharedPtr const&), (override)); diff --git a/tests/common/util/StringUtils.cpp b/tests/common/util/StringUtils.cpp index 974eb6441..07f58530e 100644 --- a/tests/common/util/StringUtils.cpp +++ b/tests/common/util/StringUtils.cpp @@ -30,7 +30,7 @@ std::string hexStringToBinaryString(std::string const& hex) { - auto const blob = ripple::strUnHex(hex); + auto const blob = xrpl::strUnHex(hex); std::string strBlob; for (auto c : *blob) @@ -39,14 +39,14 @@ hexStringToBinaryString(std::string const& hex) return strBlob; } -ripple::uint256 +xrpl::uint256 binaryStringToUint256(std::string const& bin) { - return ripple::uint256::fromVoid(static_cast(bin.data())); + return xrpl::uint256::fromVoid(static_cast(bin.data())); } std::string -ledgerHeaderToBinaryString(ripple::LedgerHeader const& info) +ledgerHeaderToBinaryString(xrpl::LedgerHeader const& info) { auto const blob = rpc::ledgerHeaderToBlob(info, true); std::string strBlob; diff --git a/tests/common/util/StringUtils.hpp b/tests/common/util/StringUtils.hpp index 4653995a6..8c55e4de2 100644 --- a/tests/common/util/StringUtils.hpp +++ b/tests/common/util/StringUtils.hpp @@ -28,8 +28,8 @@ std::string hexStringToBinaryString(std::string const& hex); -ripple::uint256 +xrpl::uint256 binaryStringToUint256(std::string const& bin); std::string -ledgerHeaderToBinaryString(ripple::LedgerHeader const& info); +ledgerHeaderToBinaryString(xrpl::LedgerHeader const& info); diff --git a/tests/common/util/TestObject.cpp b/tests/common/util/TestObject.cpp index 2db24dffd..da7871374 100644 --- a/tests/common/util/TestObject.cpp +++ b/tests/common/util/TestObject.cpp @@ -60,34 +60,34 @@ namespace { constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -ripple::Slice const kSLICE("test", 4); +xrpl::Slice const kSLICE("test", 4); } // namespace -ripple::AccountID +xrpl::AccountID getAccountIdWithString(std::string_view id) { - return util::parseBase58Wrapper(std::string(id)).value(); + return util::parseBase58Wrapper(std::string(id)).value(); } -ripple::uint256 +xrpl::uint256 getAccountKey(std::string_view id) { - return ripple::keylet::account(getAccountIdWithString(id)).key; + return xrpl::keylet::account(getAccountIdWithString(id)).key; } -ripple::uint256 -getAccountKey(ripple::AccountID const& acc) +xrpl::uint256 +getAccountKey(xrpl::AccountID const& acc) { - return ripple::keylet::account(acc).key; + return xrpl::keylet::account(acc).key; } -ripple::LedgerHeader -createLedgerHeader(std::string_view ledgerHash, ripple::LedgerIndex seq, std::optional age) +xrpl::LedgerHeader +createLedgerHeader(std::string_view ledgerHash, xrpl::LedgerIndex seq, std::optional age) { using namespace std::chrono; - auto ledgerHeader = ripple::LedgerHeader(); - ledgerHeader.hash = ripple::uint256{ledgerHash}; + auto ledgerHeader = xrpl::LedgerHeader(); + ledgerHeader.hash = xrpl::uint256{ledgerHash}; ledgerHeader.seq = seq; if (age) { @@ -95,28 +95,28 @@ createLedgerHeader(std::string_view ledgerHash, ripple::LedgerIndex seq, std::op // and the small time difference may lead to comparison bugs auto const now = duration_cast(system_clock::now().time_since_epoch()); auto const closeTime = (now - seconds{age.value()}).count() - kRIPPLE_EPOCH_START; - ledgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + ledgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; } return ledgerHeader; } -ripple::LedgerHeader -createLedgerHeaderWithUnixTime(std::string_view ledgerHash, ripple::LedgerIndex seq, uint64_t closeTimeUnixStamp) +xrpl::LedgerHeader +createLedgerHeaderWithUnixTime(std::string_view ledgerHash, xrpl::LedgerIndex seq, uint64_t closeTimeUnixStamp) { using namespace std::chrono; - auto ledgerHeader = ripple::LedgerHeader(); - ledgerHeader.hash = ripple::uint256{ledgerHash}; + auto ledgerHeader = xrpl::LedgerHeader(); + ledgerHeader.hash = xrpl::uint256{ledgerHash}; ledgerHeader.seq = seq; auto const closeTime = closeTimeUnixStamp - seconds{kRIPPLE_EPOCH_START}.count(); - ledgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + ledgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; return ledgerHeader; } -ripple::STObject +xrpl::STObject createLegacyFeeSettingLedgerObject( uint64_t base, uint32_t reserveInc, @@ -125,48 +125,43 @@ createLegacyFeeSettingLedgerObject( uint32_t flag ) { - ripple::STObject obj(ripple::sfFee); - obj.setFieldU16(ripple::sfLedgerEntryType, ripple::ltFEE_SETTINGS); - obj.setFieldU64(ripple::sfBaseFee, base); - obj.setFieldU32(ripple::sfReserveIncrement, reserveInc); - obj.setFieldU32(ripple::sfReserveBase, reserveBase); - obj.setFieldU32(ripple::sfReferenceFeeUnits, refFeeUnit); - obj.setFieldU32(ripple::sfFlags, flag); + xrpl::STObject obj(xrpl::sfFee); + obj.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltFEE_SETTINGS); + obj.setFieldU64(xrpl::sfBaseFee, base); + obj.setFieldU32(xrpl::sfReserveIncrement, reserveInc); + obj.setFieldU32(xrpl::sfReserveBase, reserveBase); + obj.setFieldU32(xrpl::sfReferenceFeeUnits, refFeeUnit); + obj.setFieldU32(xrpl::sfFlags, flag); return obj; } -ripple::STObject -createFeeSettingLedgerObject( - ripple::STAmount base, - ripple::STAmount reserveInc, - ripple::STAmount reserveBase, - uint32_t flag -) +xrpl::STObject +createFeeSettingLedgerObject(xrpl::STAmount base, xrpl::STAmount reserveInc, xrpl::STAmount reserveBase, uint32_t flag) { - ripple::STObject obj(ripple::sfFee); - obj.setFieldU16(ripple::sfLedgerEntryType, ripple::ltFEE_SETTINGS); - obj.setFieldAmount(ripple::sfBaseFeeDrops, base); - obj.setFieldAmount(ripple::sfReserveBaseDrops, reserveBase); - obj.setFieldAmount(ripple::sfReserveIncrementDrops, reserveInc); - obj.setFieldU32(ripple::sfFlags, flag); + xrpl::STObject obj(xrpl::sfFee); + obj.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltFEE_SETTINGS); + obj.setFieldAmount(xrpl::sfBaseFeeDrops, base); + obj.setFieldAmount(xrpl::sfReserveBaseDrops, reserveBase); + obj.setFieldAmount(xrpl::sfReserveIncrementDrops, reserveInc); + obj.setFieldU32(xrpl::sfFlags, flag); return obj; } -ripple::Blob +xrpl::Blob createLegacyFeeSettingBlob(uint64_t base, uint32_t reserveInc, uint32_t reserveBase, uint32_t refFeeUnit, uint32_t flag) { auto lo = createLegacyFeeSettingLedgerObject(base, reserveInc, reserveBase, refFeeUnit, flag); return lo.getSerializer().peekData(); } -ripple::Blob -createFeeSettingBlob(ripple::STAmount base, ripple::STAmount reserveInc, ripple::STAmount reserveBase, uint32_t flag) +xrpl::Blob +createFeeSettingBlob(xrpl::STAmount base, xrpl::STAmount reserveInc, xrpl::STAmount reserveBase, uint32_t flag) { auto lo = createFeeSettingLedgerObject(base, reserveInc, reserveBase, flag); return lo.getSerializer().peekData(); } -ripple::STObject +xrpl::STObject createPaymentTransactionObject( std::string_view accountId1, std::string_view accountId2, @@ -175,20 +170,20 @@ createPaymentTransactionObject( uint32_t seq ) { - ripple::STObject obj(ripple::sfTransaction); - obj.setFieldU16(ripple::sfTransactionType, ripple::ttPAYMENT); - auto account = util::parseBase58Wrapper(std::string(accountId1)); - obj.setAccountID(ripple::sfAccount, account.value()); - obj.setFieldAmount(ripple::sfAmount, ripple::STAmount(amount, false)); - obj.setFieldAmount(ripple::sfFee, ripple::STAmount(fee, false)); - auto account2 = util::parseBase58Wrapper(std::string(accountId2)); - obj.setAccountID(ripple::sfDestination, account2.value()); - obj.setFieldU32(ripple::sfSequence, seq); - obj.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject obj(xrpl::sfTransaction); + obj.setFieldU16(xrpl::sfTransactionType, xrpl::ttPAYMENT); + auto account = util::parseBase58Wrapper(std::string(accountId1)); + obj.setAccountID(xrpl::sfAccount, account.value()); + obj.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(amount, false)); + obj.setFieldAmount(xrpl::sfFee, xrpl::STAmount(fee, false)); + auto account2 = util::parseBase58Wrapper(std::string(accountId2)); + obj.setAccountID(xrpl::sfDestination, account2.value()); + obj.setFieldU32(xrpl::sfSequence, seq); + obj.setFieldVL(xrpl::sfSigningPubKey, kSLICE); return obj; } -ripple::STObject +xrpl::STObject createPaymentTransactionMetaObject( std::string_view accountId1, std::string_view accountId2, @@ -197,50 +192,50 @@ createPaymentTransactionMetaObject( uint32_t transactionIndex ) { - ripple::STObject finalFields(ripple::sfFinalFields); - finalFields.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId1)); - finalFields.setFieldAmount(ripple::sfBalance, ripple::STAmount(finalBalance1)); + xrpl::STObject finalFields(xrpl::sfFinalFields); + finalFields.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId1)); + finalFields.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(finalBalance1)); - ripple::STObject finalFields2(ripple::sfFinalFields); - finalFields2.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId2)); - finalFields2.setFieldAmount(ripple::sfBalance, ripple::STAmount(finalBalance2)); + xrpl::STObject finalFields2(xrpl::sfFinalFields); + finalFields2.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId2)); + finalFields2.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(finalBalance2)); - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{2}; - ripple::STObject node(ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltACCOUNT_ROOT); - node.emplace_back(std::move(finalFields)); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{2}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltACCOUNT_ROOT); + node.set(std::move(finalFields)); metaArray.push_back(node); - ripple::STObject node2(ripple::sfModifiedNode); - node2.setFieldU16(ripple::sfLedgerEntryType, ripple::ltACCOUNT_ROOT); - node2.emplace_back(std::move(finalFields2)); + xrpl::STObject node2(xrpl::sfModifiedNode); + node2.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltACCOUNT_ROOT); + node2.set(std::move(finalFields2)); metaArray.push_back(node2); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, transactionIndex); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, transactionIndex); return metaObj; } -ripple::STObject +xrpl::STObject createDidObject(std::string_view accountId, std::string_view didDoc, std::string_view uri, std::string_view data) { - ripple::STObject did(ripple::sfLedgerEntry); - did.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - did.setFieldU16(ripple::sfLedgerEntryType, ripple::ltDID); - did.setFieldU32(ripple::sfFlags, 0); - did.setFieldU64(ripple::sfOwnerNode, 0); - did.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - did.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); - ripple::Slice const sliceDoc(didDoc.data(), didDoc.size()); - did.setFieldVL(ripple::sfDIDDocument, sliceDoc); - ripple::Slice const sliceUri(uri.data(), uri.size()); - did.setFieldVL(ripple::sfURI, sliceUri); - ripple::Slice const sliceData(data.data(), data.size()); - did.setFieldVL(ripple::sfData, sliceData); + xrpl::STObject did(xrpl::sfLedgerEntry); + did.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + did.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltDID); + did.setFieldU32(xrpl::sfFlags, 0); + did.setFieldU64(xrpl::sfOwnerNode, 0); + did.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + did.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); + xrpl::Slice const sliceDoc(didDoc.data(), didDoc.size()); + did.setFieldVL(xrpl::sfDIDDocument, sliceDoc); + xrpl::Slice const sliceUri(uri.data(), uri.size()); + did.setFieldVL(xrpl::sfURI, sliceUri); + xrpl::Slice const sliceData(data.data(), data.size()); + did.setFieldVL(xrpl::sfData, sliceData); return did; } -ripple::STObject +xrpl::STObject createAccountRootObject( std::string_view accountId, uint32_t flag, @@ -250,27 +245,27 @@ createAccountRootObject( std::string_view previousTxnID, uint32_t previousTxnSeq, uint32_t transferRate, - std::optional ammID + std::optional ammID ) { - ripple::STObject accountRoot(ripple::sfAccount); - accountRoot.setFieldU16(ripple::sfLedgerEntryType, ripple::ltACCOUNT_ROOT); - accountRoot.setFieldU32(ripple::sfFlags, flag); - accountRoot.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - accountRoot.setFieldU32(ripple::sfSequence, seq); - accountRoot.setFieldAmount(ripple::sfBalance, ripple::STAmount(balance, false)); - accountRoot.setFieldU32(ripple::sfOwnerCount, ownerCount); - accountRoot.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{previousTxnID}); - accountRoot.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxnSeq); - accountRoot.setFieldU32(ripple::sfTransferRate, transferRate); + xrpl::STObject accountRoot(xrpl::sfAccount); + accountRoot.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltACCOUNT_ROOT); + accountRoot.setFieldU32(xrpl::sfFlags, flag); + accountRoot.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + accountRoot.setFieldU32(xrpl::sfSequence, seq); + accountRoot.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(balance, false)); + accountRoot.setFieldU32(xrpl::sfOwnerCount, ownerCount); + accountRoot.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{previousTxnID}); + accountRoot.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxnSeq); + accountRoot.setFieldU32(xrpl::sfTransferRate, transferRate); if (ammID) - accountRoot.setFieldH256(ripple::sfAMMID, *ammID); + accountRoot.setFieldH256(xrpl::sfAMMID, *ammID); return accountRoot; } -ripple::STObject +xrpl::STObject createCreateOfferTransactionObject( std::string_view accountId, int fee, @@ -282,47 +277,47 @@ createCreateOfferTransactionObject( bool reverse ) { - ripple::STObject obj(ripple::sfTransaction); - obj.setFieldU16(ripple::sfTransactionType, ripple::ttOFFER_CREATE); - auto account = util::parseBase58Wrapper(std::string(accountId)); - obj.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - obj.setFieldAmount(ripple::sfFee, amount); - obj.setFieldU32(ripple::sfSequence, seq); + xrpl::STObject obj(xrpl::sfTransaction); + obj.setFieldU16(xrpl::sfTransactionType, xrpl::ttOFFER_CREATE); + auto account = util::parseBase58Wrapper(std::string(accountId)); + obj.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + obj.setFieldAmount(xrpl::sfFee, amount); + obj.setFieldU32(xrpl::sfSequence, seq); // add amount - ripple::Issue const issue1( - ripple::Currency{currency}, util::parseBase58Wrapper(std::string(issuer)).value() + xrpl::Issue const issue1( + xrpl::Currency{currency}, util::parseBase58Wrapper(std::string(issuer)).value() ); if (reverse) { - obj.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(issue1, takerGets)); - obj.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(takerPays, false)); + obj.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(issue1, takerGets)); + obj.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(takerPays, false)); } else { - obj.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(issue1, takerGets)); - obj.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(takerPays, false)); + obj.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(issue1, takerGets)); + obj.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(takerPays, false)); } auto key = "test"; - ripple::Slice const slice(key, 4); - obj.setFieldVL(ripple::sfSigningPubKey, slice); + xrpl::Slice const slice(key, 4); + obj.setFieldVL(xrpl::sfSigningPubKey, slice); return obj; } -ripple::Issue +xrpl::Issue getIssue(std::string_view currency, std::string_view issuerId) { // standard currency if (currency.size() == 3) { - return ripple::Issue( - ripple::to_currency(std::string(currency)), - util::parseBase58Wrapper(std::string(issuerId)).value() + return xrpl::Issue( + xrpl::toCurrency(std::string(currency)), + util::parseBase58Wrapper(std::string(issuerId)).value() ); } - return ripple::Issue( - ripple::Currency{currency}, util::parseBase58Wrapper(std::string(issuerId)).value() + return xrpl::Issue( + xrpl::Currency{currency}, util::parseBase58Wrapper(std::string(issuerId)).value() ); } -ripple::STObject +xrpl::STObject createMetaDataForBookChange( std::string_view currency, std::string_view issueId, @@ -334,29 +329,29 @@ createMetaDataForBookChange( std::optional domain ) { - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::Issue const issue1 = getIssue(currency, issueId); - finalFields.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(issue1, finalTakerPays)); - finalFields.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(finalTakerGets, false)); + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::Issue const issue1 = getIssue(currency, issueId); + finalFields.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(issue1, finalTakerPays)); + finalFields.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(finalTakerGets, false)); if (domain.has_value()) - finalFields.setFieldH256(ripple::sfDomainID, ripple::uint256{*domain}); - ripple::STObject previousFields(ripple::sfPreviousFields); - previousFields.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(issue1, previousTakerPays)); - previousFields.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(previousTakerGets, false)); - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltOFFER); - node.emplace_back(std::move(finalFields)); - node.emplace_back(std::move(previousFields)); + finalFields.setFieldH256(xrpl::sfDomainID, xrpl::uint256{*domain}); + xrpl::STObject previousFields(xrpl::sfPreviousFields); + previousFields.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(issue1, previousTakerPays)); + previousFields.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(previousTakerGets, false)); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltOFFER); + node.set(std::move(finalFields)); + node.set(std::move(previousFields)); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, transactionIndex); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, transactionIndex); return metaObj; } -ripple::STObject +xrpl::STObject createMetaDataForCreateOffer( std::string_view currency, std::string_view issueId, @@ -366,28 +361,28 @@ createMetaDataForCreateOffer( bool reverse ) { - ripple::STObject finalFields(ripple::sfNewFields); - ripple::Issue const issue1 = getIssue(currency, issueId); + xrpl::STObject finalFields(xrpl::sfNewFields); + xrpl::Issue const issue1 = getIssue(currency, issueId); if (reverse) { - finalFields.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(issue1, finalTakerPays)); - finalFields.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(finalTakerGets, false)); + finalFields.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(issue1, finalTakerPays)); + finalFields.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(finalTakerGets, false)); } else { - finalFields.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(issue1, finalTakerPays)); - finalFields.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(finalTakerGets, false)); + finalFields.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(issue1, finalTakerPays)); + finalFields.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(finalTakerGets, false)); } - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfCreatedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltOFFER); - node.emplace_back(std::move(finalFields)); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfCreatedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltOFFER); + node.set(std::move(finalFields)); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, transactionIndex); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, transactionIndex); return metaObj; } -ripple::STObject +xrpl::STObject createMetaDataForCancelOffer( std::string_view currency, std::string_view issueId, @@ -396,34 +391,34 @@ createMetaDataForCancelOffer( int finalTakerPays ) { - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::Issue const issue1 = getIssue(currency, issueId); - finalFields.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(issue1, finalTakerPays)); - finalFields.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(finalTakerGets, false)); - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfDeletedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltOFFER); - node.emplace_back(std::move(finalFields)); + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::Issue const issue1 = getIssue(currency, issueId); + finalFields.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(issue1, finalTakerPays)); + finalFields.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(finalTakerGets, false)); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfDeletedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltOFFER); + node.set(std::move(finalFields)); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, transactionIndex); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, transactionIndex); return metaObj; } -ripple::STObject -createOwnerDirLedgerObject(std::vector indexes, std::string_view rootIndex) +xrpl::STObject +createOwnerDirLedgerObject(std::vector indexes, std::string_view rootIndex) { - ripple::STObject ownerDir(ripple::sfLedgerEntry); - ownerDir.setFieldU16(ripple::sfLedgerEntryType, ripple::ltDIR_NODE); - ownerDir.setFieldV256(ripple::sfIndexes, ripple::STVector256{indexes}); - ownerDir.setFieldH256(ripple::sfRootIndex, ripple::uint256{rootIndex}); - ownerDir.setFieldU32(ripple::sfFlags, 0); + xrpl::STObject ownerDir(xrpl::sfLedgerEntry); + ownerDir.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltDIR_NODE); + ownerDir.setFieldV256(xrpl::sfIndexes, xrpl::STVector256{indexes}); + ownerDir.setFieldH256(xrpl::sfRootIndex, xrpl::uint256{rootIndex}); + ownerDir.setFieldU32(xrpl::sfFlags, 0); return ownerDir; } -ripple::STObject +xrpl::STObject createPaymentChannelLedgerObject( std::string_view accountId, std::string_view destId, @@ -434,25 +429,25 @@ createPaymentChannelLedgerObject( uint32_t previousTxnSeq ) { - ripple::STObject channel(ripple::sfLedgerEntry); - channel.setFieldU16(ripple::sfLedgerEntryType, ripple::ltPAYCHAN); - channel.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - channel.setAccountID(ripple::sfDestination, getAccountIdWithString(destId)); - channel.setFieldAmount(ripple::sfAmount, ripple::STAmount(amount, false)); - channel.setFieldAmount(ripple::sfBalance, ripple::STAmount(balance, false)); - channel.setFieldU32(ripple::sfSettleDelay, settleDelay); - channel.setFieldU64(ripple::sfOwnerNode, 0); - channel.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{previousTxnId}); - channel.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxnSeq); - channel.setFieldU32(ripple::sfFlags, 0); + xrpl::STObject channel(xrpl::sfLedgerEntry); + channel.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltPAYCHAN); + channel.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + channel.setAccountID(xrpl::sfDestination, getAccountIdWithString(destId)); + channel.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(amount, false)); + channel.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(balance, false)); + channel.setFieldU32(xrpl::sfSettleDelay, settleDelay); + channel.setFieldU64(xrpl::sfOwnerNode, 0); + channel.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{previousTxnId}); + channel.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxnSeq); + channel.setFieldU32(xrpl::sfFlags, 0); uint8_t key[33] = {0}; key[0] = 2; // KeyType::secp256k1 - ripple::Slice const slice(key, 33); - channel.setFieldVL(ripple::sfPublicKey, slice); + xrpl::Slice const slice(key, 33); + channel.setFieldVL(xrpl::sfPublicKey, slice); return channel; } -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createRippleStateLedgerObject( std::string_view currency, std::string_view issuerId, @@ -466,18 +461,18 @@ createRippleStateLedgerObject( uint32_t flag ) { - auto line = ripple::STObject(ripple::sfLedgerEntry); - line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE); - line.setFieldU32(ripple::sfFlags, flag); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(currency, issuerId), balance)); - line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(getIssue(currency, highNodeAccountId), highLimit)); - line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(getIssue(currency, lowNodeAccountId), lowLimit)); - line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{previousTxnId}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxnSeq); + auto line = xrpl::STObject(xrpl::sfLedgerEntry); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldU32(xrpl::sfFlags, flag); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(getIssue(currency, issuerId), balance)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(getIssue(currency, highNodeAccountId), highLimit)); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(getIssue(currency, lowNodeAccountId), lowLimit)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{previousTxnId}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxnSeq); return line; } -ripple::STObject +xrpl::STObject createOfferLedgerObject( std::string_view account, int takerGets, @@ -490,190 +485,190 @@ createOfferLedgerObject( std::optional domain ) { - ripple::STObject offer(ripple::sfLedgerEntry); - offer.setFieldU16(ripple::sfLedgerEntryType, ripple::ltOFFER); - offer.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - offer.setFieldU32(ripple::sfSequence, 0); - offer.setFieldU32(ripple::sfFlags, 0); - ripple::Issue const issue1 = getIssue(getsCurrency, getsIssueId); - offer.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(issue1, takerGets)); - ripple::Issue const issue2 = getIssue(paysCurrency, paysIssueId); - offer.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(issue2, takerPays)); - offer.setFieldH256(ripple::sfBookDirectory, ripple::uint256{}); - offer.setFieldU64(ripple::sfBookNode, 0); - offer.setFieldU64(ripple::sfOwnerNode, 0); - offer.setFieldH256(ripple::sfBookDirectory, ripple::uint256{dirId}); - offer.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - offer.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + xrpl::STObject offer(xrpl::sfLedgerEntry); + offer.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltOFFER); + offer.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + offer.setFieldU32(xrpl::sfSequence, 0); + offer.setFieldU32(xrpl::sfFlags, 0); + xrpl::Issue const issue1 = getIssue(getsCurrency, getsIssueId); + offer.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(issue1, takerGets)); + xrpl::Issue const issue2 = getIssue(paysCurrency, paysIssueId); + offer.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(issue2, takerPays)); + offer.setFieldH256(xrpl::sfBookDirectory, xrpl::uint256{}); + offer.setFieldU64(xrpl::sfBookNode, 0); + offer.setFieldU64(xrpl::sfOwnerNode, 0); + offer.setFieldH256(xrpl::sfBookDirectory, xrpl::uint256{dirId}); + offer.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + offer.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); if (domain.has_value()) - offer.setFieldH256(ripple::sfDomainID, ripple::uint256{*domain}); + offer.setFieldH256(xrpl::sfDomainID, xrpl::uint256{*domain}); return offer; } -ripple::STObject +xrpl::STObject createTicketLedgerObject(std::string_view account, uint32_t sequence) { - ripple::STObject ticket(ripple::sfLedgerEntry); - ticket.setFieldU16(ripple::sfLedgerEntryType, ripple::ltTICKET); - ticket.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - ticket.setFieldU32(ripple::sfFlags, 0); - ticket.setFieldU64(ripple::sfOwnerNode, 0); - ticket.setFieldU32(ripple::sfTicketSequence, sequence); - ticket.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - ticket.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + xrpl::STObject ticket(xrpl::sfLedgerEntry); + ticket.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltTICKET); + ticket.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + ticket.setFieldU32(xrpl::sfFlags, 0); + ticket.setFieldU64(xrpl::sfOwnerNode, 0); + ticket.setFieldU32(xrpl::sfTicketSequence, sequence); + ticket.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + ticket.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); return ticket; } -ripple::STObject +xrpl::STObject createEscrowLedgerObject(std::string_view account, std::string_view dest) { - ripple::STObject escrow(ripple::sfLedgerEntry); - escrow.setFieldU16(ripple::sfLedgerEntryType, ripple::ltESCROW); - escrow.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - escrow.setAccountID(ripple::sfDestination, getAccountIdWithString(dest)); - escrow.setFieldAmount(ripple::sfAmount, ripple::STAmount(0, false)); - escrow.setFieldU64(ripple::sfOwnerNode, 0); - escrow.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - escrow.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); - escrow.setFieldU32(ripple::sfFlags, 0); + xrpl::STObject escrow(xrpl::sfLedgerEntry); + escrow.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltESCROW); + escrow.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + escrow.setAccountID(xrpl::sfDestination, getAccountIdWithString(dest)); + escrow.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(0, false)); + escrow.setFieldU64(xrpl::sfOwnerNode, 0); + escrow.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + escrow.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); + escrow.setFieldU32(xrpl::sfFlags, 0); return escrow; } -ripple::STObject +xrpl::STObject createCheckLedgerObject(std::string_view account, std::string_view dest) { - ripple::STObject check(ripple::sfLedgerEntry); - check.setFieldU16(ripple::sfLedgerEntryType, ripple::ltCHECK); - check.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - check.setAccountID(ripple::sfDestination, getAccountIdWithString(dest)); - check.setFieldU32(ripple::sfFlags, 0); - check.setFieldU64(ripple::sfOwnerNode, 0); - check.setFieldU64(ripple::sfDestinationNode, 0); - check.setFieldAmount(ripple::sfSendMax, ripple::STAmount(0, false)); - check.setFieldU32(ripple::sfSequence, 0); - check.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - check.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + xrpl::STObject check(xrpl::sfLedgerEntry); + check.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltCHECK); + check.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + check.setAccountID(xrpl::sfDestination, getAccountIdWithString(dest)); + check.setFieldU32(xrpl::sfFlags, 0); + check.setFieldU64(xrpl::sfOwnerNode, 0); + check.setFieldU64(xrpl::sfDestinationNode, 0); + check.setFieldAmount(xrpl::sfSendMax, xrpl::STAmount(0, false)); + check.setFieldU32(xrpl::sfSequence, 0); + check.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + check.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); return check; } -ripple::STObject +xrpl::STObject createDepositPreauthLedgerObjectByAuth(std::string_view account, std::string_view auth) { - ripple::STObject depositPreauth(ripple::sfLedgerEntry); - depositPreauth.setFieldU16(ripple::sfLedgerEntryType, ripple::ltDEPOSIT_PREAUTH); - depositPreauth.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - depositPreauth.setAccountID(ripple::sfAuthorize, getAccountIdWithString(auth)); - depositPreauth.setFieldU32(ripple::sfFlags, 0); - depositPreauth.setFieldU64(ripple::sfOwnerNode, 0); - depositPreauth.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - depositPreauth.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + xrpl::STObject depositPreauth(xrpl::sfLedgerEntry); + depositPreauth.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltDEPOSIT_PREAUTH); + depositPreauth.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + depositPreauth.setAccountID(xrpl::sfAuthorize, getAccountIdWithString(auth)); + depositPreauth.setFieldU32(xrpl::sfFlags, 0); + depositPreauth.setFieldU64(xrpl::sfOwnerNode, 0); + depositPreauth.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + depositPreauth.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); return depositPreauth; } -ripple::STObject +xrpl::STObject createDepositPreauthLedgerObjectByAuthCredentials( std::string_view account, std::string_view issuer, std::string_view credType ) { - ripple::STObject depositPreauth(ripple::sfLedgerEntry); - depositPreauth.setFieldU16(ripple::sfLedgerEntryType, ripple::ltDEPOSIT_PREAUTH); - depositPreauth.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); + xrpl::STObject depositPreauth(xrpl::sfLedgerEntry); + depositPreauth.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltDEPOSIT_PREAUTH); + depositPreauth.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); depositPreauth.setFieldArray( - ripple::sfAuthorizeCredentials, + xrpl::sfAuthorizeCredentials, createAuthCredentialArray(std::vector{issuer}, std::vector{credType}) ); - depositPreauth.setFieldU32(ripple::sfFlags, 0); - depositPreauth.setFieldU64(ripple::sfOwnerNode, 0); - depositPreauth.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - depositPreauth.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + depositPreauth.setFieldU32(xrpl::sfFlags, 0); + depositPreauth.setFieldU64(xrpl::sfOwnerNode, 0); + depositPreauth.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + depositPreauth.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); return depositPreauth; } data::NFT -createNft(std::string_view tokenID, std::string_view account, ripple::LedgerIndex seq, ripple::Blob uri, bool isBurned) +createNft(std::string_view tokenID, std::string_view account, xrpl::LedgerIndex seq, xrpl::Blob uri, bool isBurned) { - return data::NFT{ripple::uint256(tokenID), seq, getAccountIdWithString(account), uri, isBurned}; + return data::NFT{xrpl::uint256(tokenID), seq, getAccountIdWithString(account), uri, isBurned}; } -ripple::STObject +xrpl::STObject createNftBuyOffer(std::string_view tokenID, std::string_view account) { - ripple::STObject offer(ripple::sfLedgerEntry); - offer.setFieldH256(ripple::sfNFTokenID, ripple::uint256{tokenID}); - offer.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); - offer.setFieldU32(ripple::sfFlags, 0u); - offer.setFieldAmount(ripple::sfAmount, ripple::STAmount{123}); - offer.setFieldU64(ripple::sfOwnerNode, 0ul); - offer.setAccountID(ripple::sfOwner, getAccountIdWithString(account)); - offer.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - offer.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0u); - offer.setFieldU64(ripple::sfNFTokenOfferNode, 0ul); + xrpl::STObject offer(xrpl::sfLedgerEntry); + offer.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{tokenID}); + offer.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); + offer.setFieldU32(xrpl::sfFlags, 0u); + offer.setFieldAmount(xrpl::sfAmount, xrpl::STAmount{123}); + offer.setFieldU64(xrpl::sfOwnerNode, 0ul); + offer.setAccountID(xrpl::sfOwner, getAccountIdWithString(account)); + offer.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + offer.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0u); + offer.setFieldU64(xrpl::sfNFTokenOfferNode, 0ul); return offer; } -ripple::STObject +xrpl::STObject createNftSellOffer(std::string_view tokenID, std::string_view account) { - ripple::STObject offer(ripple::sfLedgerEntry); - offer.setFieldH256(ripple::sfNFTokenID, ripple::uint256{tokenID}); - offer.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); - offer.setFieldU32(ripple::sfFlags, 0u); - offer.setFieldAmount(ripple::sfAmount, ripple::STAmount{123}); - offer.setFieldU64(ripple::sfOwnerNode, 0ul); - offer.setAccountID(ripple::sfOwner, getAccountIdWithString(account)); - offer.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - offer.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0u); - offer.setFieldU64(ripple::sfNFTokenOfferNode, 0ul); + xrpl::STObject offer(xrpl::sfLedgerEntry); + offer.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{tokenID}); + offer.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); + offer.setFieldU32(xrpl::sfFlags, 0u); + offer.setFieldAmount(xrpl::sfAmount, xrpl::STAmount{123}); + offer.setFieldU64(xrpl::sfOwnerNode, 0ul); + offer.setAccountID(xrpl::sfOwner, getAccountIdWithString(account)); + offer.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + offer.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0u); + offer.setFieldU64(xrpl::sfNFTokenOfferNode, 0ul); return offer; } -ripple::STObject +xrpl::STObject createSignerLists(std::vector> const& signers) { - auto signerlists = ripple::STObject(ripple::sfLedgerEntry); - signerlists.setFieldU16(ripple::sfLedgerEntryType, ripple::ltSIGNER_LIST); - signerlists.setFieldU32(ripple::sfFlags, 0); - signerlists.setFieldU64(ripple::sfOwnerNode, 0); - signerlists.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256()); - signerlists.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); - signerlists.setFieldU32(ripple::sfSignerListID, 0); + auto signerlists = xrpl::STObject(xrpl::sfLedgerEntry); + signerlists.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltSIGNER_LIST); + signerlists.setFieldU32(xrpl::sfFlags, 0); + signerlists.setFieldU64(xrpl::sfOwnerNode, 0); + signerlists.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256()); + signerlists.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); + signerlists.setFieldU32(xrpl::sfSignerListID, 0); uint32_t quorum = 0; - ripple::STArray list; + xrpl::STArray list; for (auto const& signer : signers) { - auto entry = ripple::STObject(ripple::sfSignerEntry); - entry.setAccountID(ripple::sfAccount, getAccountIdWithString(signer.first)); - entry.setFieldU16(ripple::sfSignerWeight, signer.second); + auto entry = xrpl::STObject(xrpl::sfSignerEntry); + entry.setAccountID(xrpl::sfAccount, getAccountIdWithString(signer.first)); + entry.setFieldU16(xrpl::sfSignerWeight, signer.second); quorum += signer.second; list.push_back(std::move(entry)); } - signerlists.setFieldU32(ripple::sfSignerQuorum, quorum); - signerlists.setFieldArray(ripple::sfSignerEntries, list); + signerlists.setFieldU32(xrpl::sfSignerQuorum, quorum); + signerlists.setFieldArray(xrpl::sfSignerEntries, list); return signerlists; } -ripple::STObject +xrpl::STObject createNftTokenPage( std::vector> const& tokens, - std::optional previousPage + std::optional previousPage ) { - auto tokenPage = ripple::STObject(ripple::sfLedgerEntry); - tokenPage.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); - tokenPage.setFieldU32(ripple::sfFlags, 0); - tokenPage.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256()); - tokenPage.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + auto tokenPage = xrpl::STObject(xrpl::sfLedgerEntry); + tokenPage.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); + tokenPage.setFieldU32(xrpl::sfFlags, 0); + tokenPage.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256()); + tokenPage.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); if (previousPage) - tokenPage.setFieldH256(ripple::sfPreviousPageMin, *previousPage); - ripple::STArray list; + tokenPage.setFieldH256(xrpl::sfPreviousPageMin, *previousPage); + xrpl::STArray list; for (auto const& token : tokens) { - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{token.first.c_str()}); - entry.setFieldVL(ripple::sfURI, ripple::Slice(token.second.c_str(), token.second.size())); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{token.first.c_str()}); + entry.setFieldVL(xrpl::sfURI, xrpl::Slice(token.second.c_str(), token.second.size())); list.push_back(std::move(entry)); } - tokenPage.setFieldArray(ripple::sfNFTokens, list); + tokenPage.setFieldArray(xrpl::sfNFTokens, list); return tokenPage; } @@ -687,50 +682,50 @@ createMintNftTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_MINT); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_MINT); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); // required field for ttNFTOKEN_MINT - tx.setFieldU32(ripple::sfNFTokenTaxon, nfTokenTaxon); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldU32(xrpl::sfNFTokenTaxon, nfTokenTaxon); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::STArray nftArray1{2}; + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::STArray nftArray1{2}; // finalFields contain new NFT while previousFields does not - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); char const* url = "testurl"; - entry.setFieldVL(ripple::sfURI, ripple::Slice(url, 7)); + entry.setFieldVL(xrpl::sfURI, xrpl::Slice(url, 7)); nftArray1.push_back(entry); - auto entry2 = ripple::STObject(ripple::sfNFToken); - entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{kINDEX1}); - entry2.setFieldVL(ripple::sfURI, ripple::Slice(url, 7)); + auto entry2 = xrpl::STObject(xrpl::sfNFToken); + entry2.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{kINDEX1}); + entry2.setFieldVL(xrpl::sfURI, xrpl::Slice(url, 7)); nftArray1.push_back(entry2); - finalFields.setFieldArray(ripple::sfNFTokens, nftArray1); + finalFields.setFieldArray(xrpl::sfNFTokens, nftArray1); nftArray1.erase(nftArray1.begin()); - ripple::STObject previousFields(ripple::sfPreviousFields); - previousFields.setFieldArray(ripple::sfNFTokens, nftArray1); + xrpl::STObject previousFields(xrpl::sfPreviousFields); + previousFields.setFieldArray(xrpl::sfNFTokens, nftArray1); - node.emplace_back(std::move(finalFields)); - node.emplace_back(std::move(previousFields)); + node.set(std::move(finalFields)); + node.set(std::move(previousFields)); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -750,52 +745,52 @@ createMintNftTxWithMetadataOfCreatedNode( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_MINT); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_MINT); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); // required field for ttNFTOKEN_MINT - tx.setFieldU32(ripple::sfNFTokenTaxon, nfTokenTaxon); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldU32(xrpl::sfNFTokenTaxon, nfTokenTaxon); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); if (uri) - tx.setFieldVL(ripple::sfURI, ripple::Slice(uri->data(), uri->size())); + tx.setFieldVL(xrpl::sfURI, xrpl::Slice(uri->data(), uri->size())); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfCreatedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfCreatedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject newFields(ripple::sfNewFields); - ripple::STArray nftArray1{1}; + xrpl::STObject newFields(xrpl::sfNewFields); + xrpl::STArray nftArray1{1}; if (nftID) { // finalFields contain new NFT while previousFields does not - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{*nftID}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{*nftID}); if (uri) - entry.setFieldVL(ripple::sfURI, ripple::Slice(uri->data(), uri->size())); + entry.setFieldVL(xrpl::sfURI, xrpl::Slice(uri->data(), uri->size())); nftArray1.push_back(entry); } - newFields.setFieldArray(ripple::sfNFTokens, nftArray1); - node.emplace_back(std::move(newFields)); + newFields.setFieldArray(xrpl::sfNFTokens, nftArray1); + node.set(std::move(newFields)); if (pageIndex) - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{*pageIndex}); + node.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{*pageIndex}); // add a ledger object ahead of nft page - ripple::STObject node2(ripple::sfCreatedNode); - node2.setFieldU16(ripple::sfLedgerEntryType, ripple::ltACCOUNT_ROOT); + xrpl::STObject node2(xrpl::sfCreatedNode); + node2.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltACCOUNT_ROOT); metaArray.push_back(node2); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -804,56 +799,56 @@ createMintNftTxWithMetadataOfCreatedNode( } data::TransactionAndMetadata -createNftModifyTxWithMetadata(std::string_view accountId, std::string_view nftID, ripple::Blob uri) +createNftModifyTxWithMetadata(std::string_view accountId, std::string_view nftID, xrpl::Blob uri) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_MODIFY); - auto account = ripple::parseBase58(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(10, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); - tx.setFieldU32(ripple::sfSequence, 100); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_MODIFY); + auto account = xrpl::parseBase58(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(10, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); + tx.setFieldU32(xrpl::sfSequence, 100); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); if (!uri.empty()) // sfURI should be absent if empty - tx.setFieldVL(ripple::sfURI, uri); + tx.setFieldVL(xrpl::sfURI, uri); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::STArray nftArray1{1}; - ripple::STArray nftArray2{1}; + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::STArray nftArray1{1}; + xrpl::STArray nftArray2{1}; // finalFields contain new NFT while previousFields does not - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); if (!uri.empty()) - entry.setFieldVL(ripple::sfURI, uri); + entry.setFieldVL(xrpl::sfURI, uri); nftArray1.push_back(entry); - auto entry2 = ripple::STObject(ripple::sfNFToken); - entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + auto entry2 = xrpl::STObject(xrpl::sfNFToken); + entry2.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); char const* url = "previous"; - entry2.setFieldVL(ripple::sfURI, ripple::Slice(url, 7)); + entry2.setFieldVL(xrpl::sfURI, xrpl::Slice(url, 7)); nftArray2.push_back(entry2); - finalFields.setFieldArray(ripple::sfNFTokens, nftArray1); + finalFields.setFieldArray(xrpl::sfNFTokens, nftArray1); - ripple::STObject previousFields(ripple::sfPreviousFields); - previousFields.setFieldArray(ripple::sfNFTokens, nftArray2); + xrpl::STObject previousFields(xrpl::sfPreviousFields); + previousFields.setFieldArray(xrpl::sfNFTokens, nftArray2); - node.emplace_back(std::move(finalFields)); - node.emplace_back(std::move(previousFields)); + node.set(std::move(finalFields)); + node.set(std::move(previousFields)); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -865,40 +860,40 @@ data::TransactionAndMetadata createNftBurnTxWithMetadataOfDeletedNode(std::string_view accountId, std::string_view nftID) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_BURN); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_BURN); auto account = getAccountIdWithString(accountId); - tx.setAccountID(ripple::sfAccount, account); - auto amount = ripple::STAmount(10, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); - tx.setFieldU32(ripple::sfSequence, 100); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setAccountID(xrpl::sfAccount, account); + auto amount = xrpl::STAmount(10, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); + tx.setFieldU32(xrpl::sfSequence, 100); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfDeletedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfDeletedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); // deleted node should contain finalFields - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::STArray nftArray{1}; - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::STArray nftArray{1}; + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); nftArray.push_back(entry); - finalFields.setFieldArray(ripple::sfNFTokens, nftArray); + finalFields.setFieldArray(xrpl::sfNFTokens, nftArray); - node.emplace_back(std::move(finalFields)); + node.set(std::move(finalFields)); // add a ledger object ahead of nft page - ripple::STObject node2(ripple::sfCreatedNode); - node2.setFieldU16(ripple::sfLedgerEntryType, ripple::ltACCOUNT_ROOT); + xrpl::STObject node2(xrpl::sfCreatedNode); + node2.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltACCOUNT_ROOT); metaArray.push_back(node2); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -910,36 +905,36 @@ data::TransactionAndMetadata createNftBurnTxWithMetadataOfModifiedNode(std::string_view accountId, std::string_view nftID) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_BURN); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_BURN); auto account = getAccountIdWithString(accountId); - tx.setAccountID(ripple::sfAccount, account); - auto amount = ripple::STAmount(10, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); - tx.setFieldU32(ripple::sfSequence, 100); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setAccountID(xrpl::sfAccount, account); + auto amount = xrpl::STAmount(10, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); + tx.setFieldU32(xrpl::sfSequence, 100); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::STArray nftArray{1}; - ripple::STObject previousFields(ripple::sfPreviousFields); - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::STArray nftArray{1}; + xrpl::STObject previousFields(xrpl::sfPreviousFields); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); nftArray.push_back(entry); - previousFields.setFieldArray(ripple::sfNFTokens, nftArray); + previousFields.setFieldArray(xrpl::sfNFTokens, nftArray); - node.emplace_back(std::move(previousFields)); - node.emplace_back(std::move(finalFields)); + node.set(std::move(previousFields)); + node.set(std::move(finalFields)); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -957,34 +952,34 @@ createAcceptNftBuyerOfferTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_ACCEPT_OFFER); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldH256(ripple::sfNFTokenBuyOffer, ripple::uint256{offerId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_ACCEPT_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldH256(xrpl::sfNFTokenBuyOffer, xrpl::uint256{offerId}); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta // create deletedNode with ltNFTOKEN_OFFER - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfDeletedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfDeletedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); - ripple::STObject finalFields(ripple::sfFinalFields); - finalFields.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); + xrpl::STObject finalFields(xrpl::sfFinalFields); + finalFields.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); // for buyer offer, the offer owner is the nft's new owner - finalFields.setAccountID(ripple::sfOwner, account.value()); + finalFields.setAccountID(xrpl::sfOwner, account.value()); - node.emplace_back(std::move(finalFields)); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{offerId}); + node.set(std::move(finalFields)); + node.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{offerId}); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1004,78 +999,78 @@ createAcceptNftSellerOfferTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_ACCEPT_OFFER); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldH256(ripple::sfNFTokenSellOffer, ripple::uint256{offerId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_ACCEPT_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldH256(xrpl::sfNFTokenSellOffer, xrpl::uint256{offerId}); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta // create deletedNode with ltNFTOKEN_OFFER - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfDeletedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfDeletedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); - ripple::STObject finalFields(ripple::sfFinalFields); - finalFields.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); + xrpl::STObject finalFields(xrpl::sfFinalFields); + finalFields.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); // offer owner is not the nft's new owner for seller offer, we need to create other nodes for processing new owner - finalFields.setAccountID(ripple::sfOwner, account.value()); + finalFields.setAccountID(xrpl::sfOwner, account.value()); - node.emplace_back(finalFields); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{offerId}); + node.set(std::move(finalFields)); + node.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{offerId}); metaArray.push_back(node); // new owner's nft page node changed: 1 new nft page node added 2 old nft page node modified if (isNewPageCreated) { - ripple::STObject node2(ripple::sfCreatedNode); - node2.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject node2(xrpl::sfCreatedNode); + node2.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject newFields(ripple::sfNewFields); - ripple::STArray nftArray1{1}; + xrpl::STObject newFields(xrpl::sfNewFields); + xrpl::STArray nftArray1{1}; - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); nftArray1.push_back(entry); - newFields.setFieldArray(ripple::sfNFTokens, nftArray1); - node2.emplace_back(std::move(newFields)); - node2.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{pageIndex}); + newFields.setFieldArray(xrpl::sfNFTokens, nftArray1); + node2.set(std::move(newFields)); + node2.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{pageIndex}); metaArray.push_back(node2); } else { - ripple::STObject node2(ripple::sfModifiedNode); - node2.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject node2(xrpl::sfModifiedNode); + node2.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STArray nftArray1{2}; + xrpl::STArray nftArray1{2}; // finalFields contain new NFT while previousFields does not - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); nftArray1.push_back(entry); - auto entry2 = ripple::STObject(ripple::sfNFToken); - entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{kINDEX1}); + auto entry2 = xrpl::STObject(xrpl::sfNFToken); + entry2.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{kINDEX1}); nftArray1.push_back(entry2); - finalFields.setFieldArray(ripple::sfNFTokens, nftArray1); + finalFields.setFieldArray(xrpl::sfNFTokens, nftArray1); nftArray1.erase(nftArray1.begin()); - ripple::STObject previousFields(ripple::sfPreviousFields); - previousFields.setFieldArray(ripple::sfNFTokens, nftArray1); + xrpl::STObject previousFields(xrpl::sfPreviousFields); + previousFields.setFieldArray(xrpl::sfNFTokens, nftArray1); - node2.emplace_back(std::move(finalFields)); - node2.emplace_back(std::move(previousFields)); - node2.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{pageIndex}); + node2.set(std::move(finalFields)); + node2.set(std::move(previousFields)); + node2.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{pageIndex}); metaArray.push_back(node2); } - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1093,40 +1088,38 @@ createCancelNftOffersTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_CANCEL_OFFER); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfSequence, seq); - ripple::STVector256 offers; + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_CANCEL_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfSequence, seq); + xrpl::STVector256 offers; offers.resize(nftOffers.size()); - std::ranges::transform(nftOffers, offers.begin(), [&](auto const& nftId) { - return ripple::uint256{nftId.c_str()}; - }); - tx.setFieldV256(ripple::sfNFTokenOffers, offers); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + std::ranges::transform(nftOffers, offers.begin(), [&](auto const& nftId) { return xrpl::uint256{nftId.c_str()}; }); + tx.setFieldV256(xrpl::sfNFTokenOffers, offers); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta // create deletedNode with ltNFTOKEN_OFFER // reuse the offer id as nft id - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{nftOffers.size()}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{nftOffers.size()}; for (auto const& nftId : nftOffers) { - ripple::STObject node(ripple::sfDeletedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); + xrpl::STObject node(xrpl::sfDeletedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); - ripple::STObject finalFields(ripple::sfFinalFields); - finalFields.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId.c_str()}); + xrpl::STObject finalFields(xrpl::sfFinalFields); + finalFields.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId.c_str()}); - node.emplace_back(std::move(finalFields)); + node.set(std::move(finalFields)); metaArray.push_back(node); } - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1145,31 +1138,31 @@ createCreateNftOfferTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_CREATE_OFFER); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - auto price = ripple::STAmount(offerPrice, false); - tx.setFieldAmount(ripple::sfAmount, price); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_CREATE_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + auto price = xrpl::STAmount(offerPrice, false); + tx.setFieldAmount(xrpl::sfAmount, price); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta // create createdNode with LedgerIndex - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; - ripple::STObject node(ripple::sfCreatedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{offerId}); + xrpl::STObject node(xrpl::sfCreatedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); + node.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{offerId}); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1184,43 +1177,43 @@ createOracleSetTxWithMetadata( uint32_t fee, uint32_t docId, std::uint32_t lastUpdateTime, - ripple::STArray priceDataSeries, + xrpl::STArray priceDataSeries, std::string_view oracleIndex, bool created, std::string_view previousTxnId ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttORACLE_SET); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfLastUpdateTime, lastUpdateTime); - tx.setFieldU32(ripple::sfOracleDocumentID, docId); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); - tx.setFieldArray(ripple::sfPriceDataSeries, priceDataSeries); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttORACLE_SET); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfLastUpdateTime, lastUpdateTime); + tx.setFieldU32(xrpl::sfOracleDocumentID, docId); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); + tx.setFieldArray(xrpl::sfPriceDataSeries, priceDataSeries); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; - ripple::STObject node(created ? ripple::sfCreatedNode : ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltORACLE); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{oracleIndex}); - node.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{previousTxnId}); - ripple::STObject fields(created ? ripple::sfNewFields : ripple::sfFinalFields); - fields.setFieldU32(ripple::sfOracleDocumentID, docId); - fields.setFieldU32(ripple::sfLastUpdateTime, lastUpdateTime); - fields.setFieldArray(ripple::sfPriceDataSeries, priceDataSeries); - node.emplace_back(std::move(fields)); + xrpl::STObject node(created ? xrpl::sfCreatedNode : xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltORACLE); + node.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{oracleIndex}); + node.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{previousTxnId}); + xrpl::STObject fields(created ? xrpl::sfNewFields : xrpl::sfFinalFields); + fields.setFieldU32(xrpl::sfOracleDocumentID, docId); + fields.setFieldU32(xrpl::sfLastUpdateTime, lastUpdateTime); + fields.setFieldArray(xrpl::sfPriceDataSeries, priceDataSeries); + node.set(std::move(fields)); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1228,28 +1221,28 @@ createOracleSetTxWithMetadata( return ret; } -ripple::STObject -createAmendmentsObject(std::vector const& enabledAmendments) +xrpl::STObject +createAmendmentsObject(std::vector const& enabledAmendments) { - auto amendments = ripple::STObject(ripple::sfLedgerEntry); - amendments.setFieldU16(ripple::sfLedgerEntryType, ripple::ltAMENDMENTS); - amendments.setFieldU32(ripple::sfFlags, 0); - ripple::STVector256 const list(enabledAmendments); - amendments.setFieldV256(ripple::sfAmendments, list); + auto amendments = xrpl::STObject(xrpl::sfLedgerEntry); + amendments.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltAMENDMENTS); + amendments.setFieldU32(xrpl::sfFlags, 0); + xrpl::STVector256 const list(enabledAmendments); + amendments.setFieldV256(xrpl::sfAmendments, list); return amendments; } -ripple::STObject +xrpl::STObject createBrokenAmendmentsObject() { - auto amendments = ripple::STObject(ripple::sfLedgerEntry); - amendments.setFieldU16(ripple::sfLedgerEntryType, ripple::ltAMENDMENTS); - amendments.setFieldU32(ripple::sfFlags, 0); + auto amendments = xrpl::STObject(xrpl::sfLedgerEntry); + amendments.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltAMENDMENTS); + amendments.setFieldU32(xrpl::sfFlags, 0); // Note: no sfAmendments present return amendments; } -ripple::STObject +xrpl::STObject createAmmObject( std::string_view accountId, std::string_view assetCurrency, @@ -1262,23 +1255,23 @@ createAmmObject( uint64_t ownerNode ) { - auto amm = ripple::STObject(ripple::sfLedgerEntry); - amm.setFieldU16(ripple::sfLedgerEntryType, ripple::ltAMM); - amm.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - amm.setFieldU16(ripple::sfTradingFee, tradingFee); - amm.setFieldU64(ripple::sfOwnerNode, ownerNode); - amm.setFieldIssue(ripple::sfAsset, ripple::STIssue{ripple::sfAsset, getIssue(assetCurrency, assetIssuer)}); - amm.setFieldIssue(ripple::sfAsset2, ripple::STIssue{ripple::sfAsset2, getIssue(asset2Currency, asset2Issuer)}); - ripple::Issue const issue1( - ripple::Currency{lpTokenBalanceIssueCurrency}, - util::parseBase58Wrapper(std::string(accountId)).value() + auto amm = xrpl::STObject(xrpl::sfLedgerEntry); + amm.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltAMM); + amm.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + amm.setFieldU16(xrpl::sfTradingFee, tradingFee); + amm.setFieldU64(xrpl::sfOwnerNode, ownerNode); + amm.setFieldIssue(xrpl::sfAsset, xrpl::STIssue{xrpl::sfAsset, getIssue(assetCurrency, assetIssuer)}); + amm.setFieldIssue(xrpl::sfAsset2, xrpl::STIssue{xrpl::sfAsset2, getIssue(asset2Currency, asset2Issuer)}); + xrpl::Issue const issue1( + xrpl::Currency{lpTokenBalanceIssueCurrency}, + util::parseBase58Wrapper(std::string(accountId)).value() ); - amm.setFieldAmount(ripple::sfLPTokenBalance, ripple::STAmount(issue1, lpTokenBalanceIssueAmount)); - amm.setFieldU32(ripple::sfFlags, 0); + amm.setFieldAmount(xrpl::sfLPTokenBalance, xrpl::STAmount(issue1, lpTokenBalanceIssueAmount)); + amm.setFieldU32(xrpl::sfFlags, 0); return amm; } -ripple::STObject +xrpl::STObject createBridgeObject( std::string_view accountId, std::string_view lockingDoor, @@ -1287,34 +1280,34 @@ createBridgeObject( std::string_view issuingIssuer ) { - auto bridge = ripple::STObject(ripple::sfLedgerEntry); - bridge.setFieldU16(ripple::sfLedgerEntryType, ripple::ltBRIDGE); - bridge.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - bridge.setFieldAmount(ripple::sfSignatureReward, ripple::STAmount(10, false)); - bridge.setFieldU64(ripple::sfXChainClaimID, 100); - bridge.setFieldU64(ripple::sfXChainAccountCreateCount, 100); - bridge.setFieldU64(ripple::sfXChainAccountClaimCount, 100); - bridge.setFieldU64(ripple::sfOwnerNode, 100); - bridge.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - bridge.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); - bridge.setFieldU32(ripple::sfFlags, 0); - Json::Value lockingIssue; + auto bridge = xrpl::STObject(xrpl::sfLedgerEntry); + bridge.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltBRIDGE); + bridge.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + bridge.setFieldAmount(xrpl::sfSignatureReward, xrpl::STAmount(10, false)); + bridge.setFieldU64(xrpl::sfXChainClaimID, 100); + bridge.setFieldU64(xrpl::sfXChainAccountCreateCount, 100); + bridge.setFieldU64(xrpl::sfXChainAccountClaimCount, 100); + bridge.setFieldU64(xrpl::sfOwnerNode, 100); + bridge.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + bridge.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); + bridge.setFieldU32(xrpl::sfFlags, 0); + json::Value lockingIssue; lockingIssue["currency"] = "XRP"; - Json::Value issuingIssue; + json::Value issuingIssue; issuingIssue["currency"] = std::string(issuingCurrency); issuingIssue["issuer"] = std::string(issuingIssuer); - bridge[ripple::sfXChainBridge] = ripple::STXChainBridge( + bridge[xrpl::sfXChainBridge] = xrpl::STXChainBridge( getAccountIdWithString(lockingDoor), - ripple::issueFromJson(lockingIssue), + xrpl::issueFromJson(lockingIssue), getAccountIdWithString(issuingDoor), - ripple::issueFromJson(issuingIssue) + xrpl::issueFromJson(issuingIssue) ); - bridge.setFieldU32(ripple::sfFlags, 0); + bridge.setFieldU32(xrpl::sfFlags, 0); return bridge; } -ripple::STObject +xrpl::STObject createChainOwnedClaimIdObject( std::string_view accountId, std::string_view lockingDoor, @@ -1324,34 +1317,34 @@ createChainOwnedClaimIdObject( std::string_view otherChainSource ) { - auto chainOwnedClaimID = ripple::STObject(ripple::sfLedgerEntry); - chainOwnedClaimID.setFieldU16(ripple::sfLedgerEntryType, ripple::ltXCHAIN_OWNED_CLAIM_ID); - chainOwnedClaimID.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - chainOwnedClaimID.setFieldAmount(ripple::sfSignatureReward, ripple::STAmount(10, false)); - chainOwnedClaimID.setFieldU64(ripple::sfXChainClaimID, 100); - chainOwnedClaimID.setFieldU64(ripple::sfOwnerNode, 100); - chainOwnedClaimID.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - chainOwnedClaimID.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); - chainOwnedClaimID.setFieldU32(ripple::sfFlags, 0); - Json::Value lockingIssue; + auto chainOwnedClaimID = xrpl::STObject(xrpl::sfLedgerEntry); + chainOwnedClaimID.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltXCHAIN_OWNED_CLAIM_ID); + chainOwnedClaimID.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + chainOwnedClaimID.setFieldAmount(xrpl::sfSignatureReward, xrpl::STAmount(10, false)); + chainOwnedClaimID.setFieldU64(xrpl::sfXChainClaimID, 100); + chainOwnedClaimID.setFieldU64(xrpl::sfOwnerNode, 100); + chainOwnedClaimID.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + chainOwnedClaimID.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); + chainOwnedClaimID.setFieldU32(xrpl::sfFlags, 0); + json::Value lockingIssue; lockingIssue["currency"] = "XRP"; - Json::Value issuingIssue; + json::Value issuingIssue; issuingIssue["currency"] = std::string(issuingCurrency); issuingIssue["issuer"] = std::string(issuingIssuer); - chainOwnedClaimID[ripple::sfXChainBridge] = ripple::STXChainBridge( + chainOwnedClaimID[xrpl::sfXChainBridge] = xrpl::STXChainBridge( getAccountIdWithString(lockingDoor), - ripple::issueFromJson(lockingIssue), + xrpl::issueFromJson(lockingIssue), getAccountIdWithString(issuingDoor), - ripple::issueFromJson(issuingIssue) + xrpl::issueFromJson(issuingIssue) ); - chainOwnedClaimID.setFieldU32(ripple::sfFlags, 0); - chainOwnedClaimID.setAccountID(ripple::sfOtherChainSource, getAccountIdWithString(otherChainSource)); - chainOwnedClaimID.setFieldArray(ripple::sfXChainClaimAttestations, ripple::STArray{}); + chainOwnedClaimID.setFieldU32(xrpl::sfFlags, 0); + chainOwnedClaimID.setAccountID(xrpl::sfOtherChainSource, getAccountIdWithString(otherChainSource)); + chainOwnedClaimID.setFieldArray(xrpl::sfXChainClaimAttestations, xrpl::STArray{}); return chainOwnedClaimID; } -ripple::STObject +xrpl::STObject createChainOwnedCreateAccountClaimId( std::string_view accountId, std::string_view lockingDoor, @@ -1360,88 +1353,91 @@ createChainOwnedCreateAccountClaimId( std::string_view issuingIssuer ) { - auto chainOwnedCreateAccountClaimID = ripple::STObject(ripple::sfLedgerEntry); - chainOwnedCreateAccountClaimID.setFieldU16(ripple::sfLedgerEntryType, ripple::ltXCHAIN_OWNED_CLAIM_ID); - chainOwnedCreateAccountClaimID.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - chainOwnedCreateAccountClaimID.setFieldU64(ripple::sfXChainAccountCreateCount, 100); - chainOwnedCreateAccountClaimID.setFieldU64(ripple::sfOwnerNode, 100); - chainOwnedCreateAccountClaimID.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - chainOwnedCreateAccountClaimID.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); - chainOwnedCreateAccountClaimID.setFieldU32(ripple::sfFlags, 0); - Json::Value lockingIssue; + auto chainOwnedCreateAccountClaimID = xrpl::STObject(xrpl::sfLedgerEntry); + chainOwnedCreateAccountClaimID.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltXCHAIN_OWNED_CLAIM_ID); + chainOwnedCreateAccountClaimID.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + chainOwnedCreateAccountClaimID.setFieldU64(xrpl::sfXChainAccountCreateCount, 100); + chainOwnedCreateAccountClaimID.setFieldU64(xrpl::sfOwnerNode, 100); + chainOwnedCreateAccountClaimID.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + chainOwnedCreateAccountClaimID.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); + chainOwnedCreateAccountClaimID.setFieldU32(xrpl::sfFlags, 0); + json::Value lockingIssue; lockingIssue["currency"] = "XRP"; - Json::Value issuingIssue; + json::Value issuingIssue; issuingIssue["currency"] = std::string(issuingCurrency); issuingIssue["issuer"] = std::string(issuingIssuer); - chainOwnedCreateAccountClaimID[ripple::sfXChainBridge] = ripple::STXChainBridge( + chainOwnedCreateAccountClaimID[xrpl::sfXChainBridge] = xrpl::STXChainBridge( getAccountIdWithString(lockingDoor), - ripple::issueFromJson(lockingIssue), + xrpl::issueFromJson(lockingIssue), getAccountIdWithString(issuingDoor), - ripple::issueFromJson(issuingIssue) + xrpl::issueFromJson(issuingIssue) ); - chainOwnedCreateAccountClaimID.setFieldU32(ripple::sfFlags, 0); - chainOwnedCreateAccountClaimID.setFieldArray(ripple::sfXChainCreateAccountAttestations, ripple::STArray{}); + chainOwnedCreateAccountClaimID.setFieldU32(xrpl::sfFlags, 0); + chainOwnedCreateAccountClaimID.setFieldArray(xrpl::sfXChainCreateAccountAttestations, xrpl::STArray{}); return chainOwnedCreateAccountClaimID; } void -ammAddVoteSlot(ripple::STObject& amm, ripple::AccountID const& accountId, uint16_t tradingFee, uint32_t voteWeight) +ammAddVoteSlot(xrpl::STObject& amm, xrpl::AccountID const& accountId, uint16_t tradingFee, uint32_t voteWeight) { - if (!amm.isFieldPresent(ripple::sfVoteSlots)) - amm.setFieldArray(ripple::sfVoteSlots, ripple::STArray{}); + if (!amm.isFieldPresent(xrpl::sfVoteSlots)) + amm.setFieldArray(xrpl::sfVoteSlots, xrpl::STArray{}); - auto& arr = amm.peekFieldArray(ripple::sfVoteSlots); - auto slot = ripple::STObject(ripple::sfVoteEntry); - slot.setAccountID(ripple::sfAccount, accountId); - slot.setFieldU16(ripple::sfTradingFee, tradingFee); - slot.setFieldU32(ripple::sfVoteWeight, voteWeight); + auto& arr = amm.peekFieldArray(xrpl::sfVoteSlots); + auto slot = xrpl::STObject(xrpl::sfVoteEntry); + slot.setAccountID(xrpl::sfAccount, accountId); + slot.setFieldU16(xrpl::sfTradingFee, tradingFee); + slot.setFieldU32(xrpl::sfVoteWeight, voteWeight); arr.push_back(slot); } void ammSetAuctionSlot( - ripple::STObject& amm, - ripple::AccountID const& accountId, - ripple::STAmount price, + xrpl::STObject& amm, + xrpl::AccountID const& accountId, + xrpl::STAmount price, uint16_t discountedFee, uint32_t expiration, - std::vector const& authAccounts + std::vector const& authAccounts ) { ASSERT(expiration >= 24 * 3600, "Expiration must be at least 24 hours"); - if (!amm.isFieldPresent(ripple::sfAuctionSlot)) - amm.makeFieldPresent(ripple::sfAuctionSlot); + if (!amm.isFieldPresent(xrpl::sfAuctionSlot)) + amm.makeFieldPresent(xrpl::sfAuctionSlot); - auto& auctionSlot = amm.peekFieldObject(ripple::sfAuctionSlot); - auctionSlot.setAccountID(ripple::sfAccount, accountId); - auctionSlot.setFieldAmount(ripple::sfPrice, price); - auctionSlot.setFieldU16(ripple::sfDiscountedFee, discountedFee); - auctionSlot.setFieldU32(ripple::sfExpiration, expiration); + auto& auctionSlot = amm.peekFieldObject(xrpl::sfAuctionSlot); + auctionSlot.setAccountID(xrpl::sfAccount, accountId); + auctionSlot.setFieldAmount(xrpl::sfPrice, price); + auctionSlot.setFieldU16(xrpl::sfDiscountedFee, discountedFee); + auctionSlot.setFieldU32(xrpl::sfExpiration, expiration); if (not authAccounts.empty()) { - ripple::STArray accounts; + xrpl::STArray accounts; for (auto const& acc : authAccounts) { - ripple::STObject authAcc(ripple::sfAuthAccount); - authAcc.setAccountID(ripple::sfAccount, acc); + xrpl::STObject authAcc(xrpl::sfAuthAccount); + authAcc.setAccountID(xrpl::sfAccount, acc); accounts.push_back(authAcc); } - auctionSlot.setFieldArray(ripple::sfAuthAccounts, accounts); + auctionSlot.setFieldArray(xrpl::sfAuthAccounts, accounts); } } -ripple::Currency +xrpl::Currency createLptCurrency(std::string_view assetCurrency, std::string_view asset2Currency) { - return ripple::ammLPTCurrency( - ripple::to_currency(std::string(assetCurrency)), ripple::to_currency(std::string(asset2Currency)) + // ammLPTCurrency now takes Assets; the issuer is irrelevant to the LPToken currency hash + // (only the underlying currencies are hashed), so a fixed account is used for both. + return xrpl::ammLPTCurrency( + xrpl::Issue{xrpl::toCurrency(std::string(assetCurrency)), xrpl::xrpAccount()}, + xrpl::Issue{xrpl::toCurrency(std::string(asset2Currency)), xrpl::xrpAccount()} ); } -ripple::STObject +xrpl::STObject createMptIssuanceObject( std::string_view accountId, std::uint32_t seq, @@ -1456,105 +1452,105 @@ createMptIssuanceObject( std::optional mutableFlags ) { - ripple::STObject mptIssuance(ripple::sfLedgerEntry); - mptIssuance.setAccountID(ripple::sfIssuer, getAccountIdWithString(accountId)); - mptIssuance.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN_ISSUANCE); - mptIssuance.setFieldU32(ripple::sfSequence, seq); - mptIssuance.setFieldU64(ripple::sfOwnerNode, 0); - mptIssuance.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - mptIssuance.setFieldU32(ripple::sfFlags, flags); - mptIssuance.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); - mptIssuance.setFieldU64(ripple::sfOutstandingAmount, outstandingAmount); + xrpl::STObject mptIssuance(xrpl::sfLedgerEntry); + mptIssuance.setAccountID(xrpl::sfIssuer, getAccountIdWithString(accountId)); + mptIssuance.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN_ISSUANCE); + mptIssuance.setFieldU32(xrpl::sfSequence, seq); + mptIssuance.setFieldU64(xrpl::sfOwnerNode, 0); + mptIssuance.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + mptIssuance.setFieldU32(xrpl::sfFlags, flags); + mptIssuance.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); + mptIssuance.setFieldU64(xrpl::sfOutstandingAmount, outstandingAmount); if (transferFee.has_value()) - mptIssuance.setFieldU16(ripple::sfTransferFee, *transferFee); + mptIssuance.setFieldU16(xrpl::sfTransferFee, *transferFee); if (assetScale.has_value()) - mptIssuance.setFieldU8(ripple::sfAssetScale, *assetScale); + mptIssuance.setFieldU8(xrpl::sfAssetScale, *assetScale); if (maxAmount.has_value()) - mptIssuance.setFieldU64(ripple::sfMaximumAmount, *maxAmount); + mptIssuance.setFieldU64(xrpl::sfMaximumAmount, *maxAmount); if (lockedAmount.has_value()) - mptIssuance.setFieldU64(ripple::sfLockedAmount, *lockedAmount); + mptIssuance.setFieldU64(xrpl::sfLockedAmount, *lockedAmount); if (metadata.has_value()) { - ripple::Slice const sliceMetadata(metadata->data(), metadata->size()); - mptIssuance.setFieldVL(ripple::sfMPTokenMetadata, sliceMetadata); + xrpl::Slice const sliceMetadata(metadata->data(), metadata->size()); + mptIssuance.setFieldVL(xrpl::sfMPTokenMetadata, sliceMetadata); } if (domainId.has_value()) - mptIssuance.setFieldH256(ripple::sfDomainID, ripple::uint256{*domainId}); + mptIssuance.setFieldH256(xrpl::sfDomainID, xrpl::uint256{*domainId}); if (mutableFlags.has_value()) - mptIssuance.setFieldU32(ripple::sfMutableFlags, *mutableFlags); + mptIssuance.setFieldU32(xrpl::sfMutableFlags, *mutableFlags); return mptIssuance; } -ripple::STObject +xrpl::STObject createMpTokenObject( std::string_view accountId, - ripple::uint192 issuanceID, + xrpl::uint192 issuanceID, std::uint64_t mptAmount, std::uint32_t flags, std::optional lockedAmount ) { - ripple::STObject mptoken(ripple::sfLedgerEntry); - mptoken.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - mptoken[ripple::sfMPTokenIssuanceID] = issuanceID; - mptoken.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN); - mptoken.setFieldU32(ripple::sfFlags, flags); - mptoken.setFieldU64(ripple::sfOwnerNode, 0); - mptoken.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - mptoken.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + xrpl::STObject mptoken(xrpl::sfLedgerEntry); + mptoken.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + mptoken[xrpl::sfMPTokenIssuanceID] = issuanceID; + mptoken.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN); + mptoken.setFieldU32(xrpl::sfFlags, flags); + mptoken.setFieldU64(xrpl::sfOwnerNode, 0); + mptoken.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + mptoken.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); if (mptAmount != 0u) - mptoken.setFieldU64(ripple::sfMPTAmount, mptAmount); + mptoken.setFieldU64(xrpl::sfMPTAmount, mptAmount); if (lockedAmount.has_value()) - mptoken.setFieldU64(ripple::sfLockedAmount, *lockedAmount); + mptoken.setFieldU64(xrpl::sfLockedAmount, *lockedAmount); return mptoken; } -ripple::STObject +xrpl::STObject createMPTIssuanceCreateTx(std::string_view accountId, uint32_t fee, uint32_t seq) { - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttMPTOKEN_ISSUANCE_CREATE); - tx.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - tx.setFieldAmount(ripple::sfFee, ripple::STAmount(fee, false)); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttMPTOKEN_ISSUANCE_CREATE); + tx.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + tx.setFieldAmount(xrpl::sfFee, xrpl::STAmount(fee, false)); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); return tx; } data::TransactionAndMetadata createMPTIssuanceCreateTxWithMetadata(std::string_view accountId, uint32_t fee, uint32_t seq) { - ripple::STObject const tx = createMPTIssuanceCreateTx(accountId, fee, seq); + xrpl::STObject const tx = createMPTIssuanceCreateTx(accountId, fee, seq); - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); - ripple::STObject newFields(ripple::sfNewFields); - newFields.setAccountID(ripple::sfIssuer, getAccountIdWithString(accountId)); - newFields.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN_ISSUANCE); - newFields.setFieldU32(ripple::sfFlags, 0); - newFields.setFieldU32(ripple::sfSequence, seq); - newFields.setFieldU64(ripple::sfOwnerNode, 0); - newFields.setFieldU64(ripple::sfMaximumAmount, 0); - newFields.setFieldU64(ripple::sfOutstandingAmount, 0); - newFields.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - newFields.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + xrpl::STObject newFields(xrpl::sfNewFields); + newFields.setAccountID(xrpl::sfIssuer, getAccountIdWithString(accountId)); + newFields.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN_ISSUANCE); + newFields.setFieldU32(xrpl::sfFlags, 0); + newFields.setFieldU32(xrpl::sfSequence, seq); + newFields.setFieldU64(xrpl::sfOwnerNode, 0); + newFields.setFieldU64(xrpl::sfMaximumAmount, 0); + newFields.setFieldU64(xrpl::sfOutstandingAmount, 0); + newFields.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + newFields.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); std::string_view const metadata = "test-meta"; - ripple::Slice const sliceMetadata(metadata.data(), metadata.size()); - newFields.setFieldVL(ripple::sfMPTokenMetadata, sliceMetadata); + xrpl::Slice const sliceMetadata(metadata.data(), metadata.size()); + newFields.setFieldVL(xrpl::sfMPTokenMetadata, sliceMetadata); - ripple::STObject createdNode(ripple::sfCreatedNode); - createdNode.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN_ISSUANCE); - createdNode.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{}); - createdNode.emplace_back(std::move(newFields)); + xrpl::STObject createdNode(xrpl::sfCreatedNode); + createdNode.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN_ISSUANCE); + createdNode.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{}); + createdNode.set(std::move(newFields)); - ripple::STArray affectedNodes(ripple::sfAffectedNodes); + xrpl::STArray affectedNodes(xrpl::sfAffectedNodes); affectedNodes.push_back(std::move(createdNode)); - metaObj.setFieldArray(ripple::sfAffectedNodes, affectedNodes); + metaObj.setFieldArray(xrpl::sfAffectedNodes, affectedNodes); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1562,28 +1558,28 @@ createMPTIssuanceCreateTxWithMetadata(std::string_view accountId, uint32_t fee, return ret; } -ripple::STObject +xrpl::STObject createMPTokenAuthorizeTx( std::string_view accountId, - ripple::uint192 const& mptIssuanceID, + xrpl::uint192 const& mptIssuanceID, uint32_t fee, uint32_t seq, std::optional holder, std::optional flags ) { - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttMPTOKEN_AUTHORIZE); - tx.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - tx[ripple::sfMPTokenIssuanceID] = mptIssuanceID; - tx.setFieldAmount(ripple::sfFee, ripple::STAmount(fee, false)); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttMPTOKEN_AUTHORIZE); + tx.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + tx[xrpl::sfMPTokenIssuanceID] = mptIssuanceID; + tx.setFieldAmount(xrpl::sfFee, xrpl::STAmount(fee, false)); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); if (holder) - tx.setAccountID(ripple::sfHolder, getAccountIdWithString(*holder)); + tx.setAccountID(xrpl::sfHolder, getAccountIdWithString(*holder)); if (flags) - tx.setFieldU32(ripple::sfFlags, *flags); + tx.setFieldU32(xrpl::sfFlags, *flags); return tx; } @@ -1591,30 +1587,30 @@ createMPTokenAuthorizeTx( data::TransactionAndMetadata createMPTokenAuthorizeTxWithMetadata( std::string_view accountId, - ripple::uint192 const& mptIssuanceID, + xrpl::uint192 const& mptIssuanceID, uint32_t fee, uint32_t seq ) { - ripple::STObject const tx = createMPTokenAuthorizeTx(accountId, mptIssuanceID, fee, seq); + xrpl::STObject const tx = createMPTokenAuthorizeTx(accountId, mptIssuanceID, fee, seq); - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); - ripple::STObject finalFields(ripple::sfFinalFields); - finalFields.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN); - finalFields[ripple::sfMPTokenIssuanceID] = mptIssuanceID; - finalFields.setFieldU64(ripple::sfMPTAmount, 0); + xrpl::STObject finalFields(xrpl::sfFinalFields); + finalFields.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN); + finalFields[xrpl::sfMPTokenIssuanceID] = mptIssuanceID; + finalFields.setFieldU64(xrpl::sfMPTAmount, 0); - ripple::STObject modifiedNode(ripple::sfModifiedNode); - modifiedNode.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN); - modifiedNode.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{}); - modifiedNode.emplace_back(std::move(finalFields)); + xrpl::STObject modifiedNode(xrpl::sfModifiedNode); + modifiedNode.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN); + modifiedNode.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{}); + modifiedNode.set(std::move(finalFields)); - ripple::STArray affectedNodes(ripple::sfAffectedNodes); + xrpl::STArray affectedNodes(xrpl::sfAffectedNodes); affectedNodes.push_back(std::move(modifiedNode)); - metaObj.setFieldArray(ripple::sfAffectedNodes, affectedNodes); + metaObj.setFieldArray(xrpl::sfAffectedNodes, affectedNodes); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1622,109 +1618,109 @@ createMPTokenAuthorizeTxWithMetadata( return ret; } -ripple::STObject +xrpl::STObject createPermissionedDomainObject( std::string_view accountId, std::string_view ledgerIndex, - ripple::LedgerIndex seq, + xrpl::LedgerIndex seq, uint64_t ownerNode, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ) { - ripple::STObject object(ripple::sfLedgerEntry); - object.setFieldH256(ripple::sfLedgerIndex, ripple::uint256(ledgerIndex)); - object.setAccountID(ripple::sfOwner, getAccountIdWithString(accountId)); - object.setFieldU32(ripple::sfSequence, seq); - object.setFieldArray(ripple::sfAcceptedCredentials, ripple::STArray{}); - object.setFieldU64(ripple::sfOwnerNode, ownerNode); - object.setFieldH256(ripple::sfPreviousTxnID, previousTxId); - object.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxSeq); - object.setFieldU32(ripple::sfFlags, 0); - object.setFieldU16(ripple::sfLedgerEntryType, ripple::ltPERMISSIONED_DOMAIN); + xrpl::STObject object(xrpl::sfLedgerEntry); + object.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(ledgerIndex)); + object.setAccountID(xrpl::sfOwner, getAccountIdWithString(accountId)); + object.setFieldU32(xrpl::sfSequence, seq); + object.setFieldArray(xrpl::sfAcceptedCredentials, xrpl::STArray{}); + object.setFieldU64(xrpl::sfOwnerNode, ownerNode); + object.setFieldH256(xrpl::sfPreviousTxnID, previousTxId); + object.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxSeq); + object.setFieldU32(xrpl::sfFlags, 0); + object.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltPERMISSIONED_DOMAIN); return object; } -ripple::STObject +xrpl::STObject createDelegateObject( std::string_view accountId, std::string_view authorize, std::string_view ledgerIndex, uint64_t ownerNode, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ) { - ripple::STObject object(ripple::sfLedgerEntry); + xrpl::STObject object(xrpl::sfLedgerEntry); - object.setFieldH256(ripple::sfLedgerIndex, ripple::uint256(ledgerIndex)); - object.setFieldU16(ripple::sfLedgerEntryType, ripple::ltDELEGATE); - object.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId)); - object.setAccountID(ripple::sfAuthorize, getAccountIdWithString(authorize)); - object.setFieldArray(ripple::sfPermissions, ripple::STArray{}); - object.setFieldU64(ripple::sfOwnerNode, ownerNode); - object.setFieldH256(ripple::sfPreviousTxnID, previousTxId); - object.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxSeq); - object.setFieldU32(ripple::sfFlags, 0); + object.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(ledgerIndex)); + object.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltDELEGATE); + object.setAccountID(xrpl::sfAccount, getAccountIdWithString(accountId)); + object.setAccountID(xrpl::sfAuthorize, getAccountIdWithString(authorize)); + object.setFieldArray(xrpl::sfPermissions, xrpl::STArray{}); + object.setFieldU64(xrpl::sfOwnerNode, ownerNode); + object.setFieldH256(xrpl::sfPreviousTxnID, previousTxId); + object.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxSeq); + object.setFieldU32(xrpl::sfFlags, 0); return object; } -ripple::STObject +xrpl::STObject createOraclePriceData( uint64_t assetPrice, - ripple::Currency baseAssetCurrency, - ripple::Currency quoteAssetCurrency, + xrpl::Currency baseAssetCurrency, + xrpl::Currency quoteAssetCurrency, uint8_t scale ) { - auto priceData = ripple::STObject(ripple::sfPriceData); - priceData.setFieldU64(ripple::sfAssetPrice, assetPrice); - priceData.setFieldCurrency(ripple::sfBaseAsset, ripple::STCurrency{ripple::sfBaseAsset, baseAssetCurrency}); - priceData.setFieldCurrency(ripple::sfQuoteAsset, ripple::STCurrency{ripple::sfQuoteAsset, quoteAssetCurrency}); - priceData.setFieldU8(ripple::sfScale, scale); + auto priceData = xrpl::STObject(xrpl::sfPriceData); + priceData.setFieldU64(xrpl::sfAssetPrice, assetPrice); + priceData.setFieldCurrency(xrpl::sfBaseAsset, xrpl::STCurrency{xrpl::sfBaseAsset, baseAssetCurrency}); + priceData.setFieldCurrency(xrpl::sfQuoteAsset, xrpl::STCurrency{xrpl::sfQuoteAsset, quoteAssetCurrency}); + priceData.setFieldU8(xrpl::sfScale, scale); return priceData; } -ripple::STArray -createPriceDataSeries(std::vector const& series) +xrpl::STArray +createPriceDataSeries(std::vector const& series) { - return ripple::STArray{series.begin(), series.end()}; + return xrpl::STArray{series.begin(), series.end()}; } -ripple::STObject +xrpl::STObject createOracleObject( std::string_view accountId, std::string_view provider, uint64_t ownerNode, uint32_t lastUpdateTime, - ripple::Blob uri, - ripple::Blob assetClass, + xrpl::Blob uri, + xrpl::Blob assetClass, uint32_t previousTxSeq, - ripple::uint256 previousTxId, - ripple::STArray priceDataSeries + xrpl::uint256 previousTxId, + xrpl::STArray priceDataSeries ) { - auto ledgerObject = ripple::STObject(ripple::sfLedgerEntry); - ledgerObject.setFieldU16(ripple::sfLedgerEntryType, ripple::ltORACLE); - ledgerObject.setFieldU32(ripple::sfFlags, 0); - ledgerObject.setAccountID(ripple::sfOwner, getAccountIdWithString(accountId)); - ledgerObject.setFieldVL(ripple::sfProvider, ripple::Blob{provider.begin(), provider.end()}); - ledgerObject.setFieldU64(ripple::sfOwnerNode, ownerNode); - ledgerObject.setFieldU32(ripple::sfLastUpdateTime, lastUpdateTime); - ledgerObject.setFieldVL(ripple::sfURI, uri); - ledgerObject.setFieldVL(ripple::sfAssetClass, assetClass); - ledgerObject.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxSeq); - ledgerObject.setFieldH256(ripple::sfPreviousTxnID, previousTxId); - ledgerObject.setFieldArray(ripple::sfPriceDataSeries, priceDataSeries); + auto ledgerObject = xrpl::STObject(xrpl::sfLedgerEntry); + ledgerObject.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltORACLE); + ledgerObject.setFieldU32(xrpl::sfFlags, 0); + ledgerObject.setAccountID(xrpl::sfOwner, getAccountIdWithString(accountId)); + ledgerObject.setFieldVL(xrpl::sfProvider, xrpl::Blob{provider.begin(), provider.end()}); + ledgerObject.setFieldU64(xrpl::sfOwnerNode, ownerNode); + ledgerObject.setFieldU32(xrpl::sfLastUpdateTime, lastUpdateTime); + ledgerObject.setFieldVL(xrpl::sfURI, uri); + ledgerObject.setFieldVL(xrpl::sfAssetClass, assetClass); + ledgerObject.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxSeq); + ledgerObject.setFieldH256(xrpl::sfPreviousTxnID, previousTxId); + ledgerObject.setFieldArray(xrpl::sfPriceDataSeries, priceDataSeries); return ledgerObject; } // acc2 issue credential for acc1 so acc2 is issuer -ripple::STObject +xrpl::STObject createCredentialObject( std::string_view acc1, std::string_view acc2, @@ -1733,70 +1729,71 @@ createCredentialObject( std::optional expiration ) { - ripple::STObject credObj(ripple::sfCredential); - credObj.setFieldU16(ripple::sfLedgerEntryType, ripple::ltCREDENTIAL); - credObj.setFieldVL(ripple::sfCredentialType, ripple::Blob{credType.begin(), credType.end()}); - credObj.setAccountID(ripple::sfSubject, getAccountIdWithString(acc1)); - credObj.setAccountID(ripple::sfIssuer, getAccountIdWithString(acc2)); + xrpl::STObject credObj(xrpl::sfCredential); + credObj.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltCREDENTIAL); + credObj.setFieldVL(xrpl::sfCredentialType, xrpl::Blob{credType.begin(), credType.end()}); + credObj.setAccountID(xrpl::sfSubject, getAccountIdWithString(acc1)); + credObj.setAccountID(xrpl::sfIssuer, getAccountIdWithString(acc2)); if (expiration.has_value()) - credObj.setFieldU32(ripple::sfExpiration, expiration.value()); + credObj.setFieldU32(xrpl::sfExpiration, expiration.value()); if (accept) { - credObj.setFieldU32(ripple::sfFlags, ripple::lsfAccepted); + credObj.setFieldU32(xrpl::sfFlags, xrpl::lsfAccepted); } else { - credObj.setFieldU32(ripple::sfFlags, 0); + credObj.setFieldU32(xrpl::sfFlags, 0); } - credObj.setFieldU64(ripple::sfSubjectNode, 0); - credObj.setFieldU64(ripple::sfIssuerNode, 0); - credObj.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - credObj.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + credObj.setFieldU64(xrpl::sfSubjectNode, 0); + credObj.setFieldU64(xrpl::sfIssuerNode, 0); + credObj.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + credObj.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); return credObj; } -ripple::STArray +xrpl::STArray createAuthCredentialArray(std::vector issuer, std::vector credType) { - ripple::STArray arr; + xrpl::STArray arr; ASSERT(issuer.size() == credType.size(), "issuer and credtype vector must be same length"); for (std::size_t i = 0; i < issuer.size(); ++i) { - auto credential = ripple::STObject::makeInnerObject(ripple::sfCredential); - credential.setAccountID(ripple::sfIssuer, getAccountIdWithString(issuer[i])); - credential.setFieldVL(ripple::sfCredentialType, ripple::strUnHex(std::string(credType[i])).value()); + auto credential = xrpl::STObject::makeInnerObject(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, getAccountIdWithString(issuer[i])); + credential.setFieldVL(xrpl::sfCredentialType, xrpl::strUnHex(std::string(credType[i])).value()); arr.push_back(credential); } return arr; } -ripple::STObject +xrpl::STObject createVault( std::string_view owner, std::string_view account, - ripple::LedgerIndex seq, + xrpl::LedgerIndex seq, std::string_view assetCurrency, std::string_view assetIssuer, - ripple::uint192 shareMPTID, + xrpl::uint192 shareMPTID, uint64_t ownerNode, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ) { - auto vault = ripple::STObject(ripple::sfLedgerEntry); - vault.setAccountID(ripple::sfOwner, getAccountIdWithString(owner)); - vault.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - vault.setFieldU32(ripple::sfSequence, seq); - vault.setFieldU64(ripple::sfOwnerNode, ownerNode); - vault.setFieldH256(ripple::sfPreviousTxnID, previousTxId); - vault.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxSeq); + auto vault = xrpl::STObject(xrpl::sfLedgerEntry); + vault.setAccountID(xrpl::sfOwner, getAccountIdWithString(owner)); + vault.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + vault.setFieldU32(xrpl::sfSequence, seq); + vault.setFieldU64(xrpl::sfOwnerNode, ownerNode); + vault.setFieldH256(xrpl::sfPreviousTxnID, previousTxId); + vault.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxSeq); - vault.setFieldIssue(ripple::sfAsset, ripple::STIssue{ripple::sfAsset, getIssue(assetCurrency, assetIssuer)}); - vault[ripple::sfShareMPTID] = shareMPTID; - vault.setFieldNumber(ripple::sfAssetsTotal, ripple::STNumber{ripple::sfAssetsTotal, 300}); - vault.setFieldNumber(ripple::sfAssetsAvailable, ripple::STNumber{ripple::sfAssetsAvailable, 300}); - vault.setFieldNumber(ripple::sfLossUnrealized, ripple::STNumber{ripple::sfLossUnrealized, 1}); - vault.setFieldU8(ripple::sfWithdrawalPolicy, 200); + vault.setFieldIssue(xrpl::sfAsset, xrpl::STIssue{xrpl::sfAsset, getIssue(assetCurrency, assetIssuer)}); + vault[xrpl::sfShareMPTID] = shareMPTID; + vault.setFieldNumber(xrpl::sfAssetsTotal, xrpl::STNumber{xrpl::sfAssetsTotal, 300}); + vault.setFieldNumber(xrpl::sfAssetsAvailable, xrpl::STNumber{xrpl::sfAssetsAvailable, 300}); + // sfLossUnrealized is SoeDefault; explicitly setting it to its default value is rejected + // by applyTemplate in newer libxrpl, so it is left unset. + vault.setFieldU8(xrpl::sfWithdrawalPolicy, 200); - vault.setFieldU32(ripple::sfFlags, 0); - vault.setFieldU16(ripple::sfLedgerEntryType, ripple::ltVAULT); + vault.setFieldU32(xrpl::sfFlags, 0); + vault.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltVAULT); return vault; } diff --git a/tests/common/util/TestObject.hpp b/tests/common/util/TestObject.hpp index e06fa62b2..d79102467 100644 --- a/tests/common/util/TestObject.hpp +++ b/tests/common/util/TestObject.hpp @@ -45,37 +45,37 @@ /* * Create AccountID object with string */ -[[nodiscard]] ripple::AccountID +[[nodiscard]] xrpl::AccountID getAccountIdWithString(std::string_view id); /** * Create AccountID object with string and return its key */ -[[nodiscard]] ripple::uint256 +[[nodiscard]] xrpl::uint256 getAccountKey(std::string_view id); /* * Gets the account key from an account id */ -[[nodiscard]] ripple::uint256 -getAccountKey(ripple::AccountID const& acc); +[[nodiscard]] xrpl::uint256 +getAccountKey(xrpl::AccountID const& acc); /* * Create a simple ledgerHeader object with only hash and seq */ -[[nodiscard]] ripple::LedgerHeader -createLedgerHeader(std::string_view ledgerHash, ripple::LedgerIndex seq, std::optional age = std::nullopt); +[[nodiscard]] xrpl::LedgerHeader +createLedgerHeader(std::string_view ledgerHash, xrpl::LedgerIndex seq, std::optional age = std::nullopt); /* * Create a simple ledgerHeader object with hash, seq and unix timestamp */ -[[nodiscard]] ripple::LedgerHeader -createLedgerHeaderWithUnixTime(std::string_view ledgerHash, ripple::LedgerIndex seq, uint64_t closeTimeUnixStamp); +[[nodiscard]] xrpl::LedgerHeader +createLedgerHeaderWithUnixTime(std::string_view ledgerHash, xrpl::LedgerIndex seq, uint64_t closeTimeUnixStamp); /* * Create a Legacy (pre XRPFees amendment) FeeSetting ledger object */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createLegacyFeeSettingLedgerObject( uint64_t base, uint32_t reserveInc, @@ -87,18 +87,13 @@ createLegacyFeeSettingLedgerObject( /* * Create a FeeSetting ledger object */ -ripple::STObject -createFeeSettingLedgerObject( - ripple::STAmount base, - ripple::STAmount reserveInc, - ripple::STAmount reserveBase, - uint32_t flag -); +xrpl::STObject +createFeeSettingLedgerObject(xrpl::STAmount base, xrpl::STAmount reserveInc, xrpl::STAmount reserveBase, uint32_t flag); /* * Create a Legacy (pre XRPFees amendment) FeeSetting ledger object and return its blob */ -[[nodiscard]] ripple::Blob +[[nodiscard]] xrpl::Blob createLegacyFeeSettingBlob( uint64_t base, uint32_t reserveInc, @@ -110,13 +105,13 @@ createLegacyFeeSettingBlob( /* * Create a FeeSetting ledger object and return its blob */ -ripple::Blob -createFeeSettingBlob(ripple::STAmount base, ripple::STAmount reserveInc, ripple::STAmount reserveBase, uint32_t flag); +xrpl::Blob +createFeeSettingBlob(xrpl::STAmount base, xrpl::STAmount reserveInc, xrpl::STAmount reserveBase, uint32_t flag); /* * Create a payment transaction object */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createPaymentTransactionObject( std::string_view accountId1, std::string_view accountId2, @@ -125,7 +120,7 @@ createPaymentTransactionObject( uint32_t seq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createPaymentTransactionMetaObject( std::string_view accountId1, std::string_view accountId2, @@ -137,7 +132,7 @@ createPaymentTransactionMetaObject( /* * Create an account root ledger object */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createAccountRootObject( std::string_view accountId, uint32_t flag, @@ -147,7 +142,7 @@ createAccountRootObject( std::string_view previousTxnID, uint32_t previousTxnSeq, uint32_t transferRate = 0, - std::optional ammID = std::nullopt + std::optional ammID = std::nullopt ); /* @@ -155,7 +150,7 @@ createAccountRootObject( * Taker pay is XRP * If reverse is true, taker gets is XRP */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createCreateOfferTransactionObject( std::string_view accountId, int fee, @@ -170,13 +165,13 @@ createCreateOfferTransactionObject( /* * Return an issue object with given currency and issue account */ -[[nodiscard]] ripple::Issue +[[nodiscard]] xrpl::Issue getIssue(std::string_view currency, std::string_view issuerId); /* * Create a offer change meta data */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createMetaDataForBookChange( std::string_view currency, std::string_view issueId, @@ -193,7 +188,7 @@ createMetaDataForBookChange( * finalTakerGets is XRP * If reverse is true, finalTakerPays is XRP */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createMetaDataForCreateOffer( std::string_view currency, std::string_view issueId, @@ -206,7 +201,7 @@ createMetaDataForCreateOffer( /* * Meta data for removing a offer object */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createMetaDataForCancelOffer( std::string_view currency, std::string_view issueId, @@ -218,13 +213,13 @@ createMetaDataForCancelOffer( /* * Create a owner dir ledger object */ -[[nodiscard]] ripple::STObject -createOwnerDirLedgerObject(std::vector indexes, std::string_view rootIndex); +[[nodiscard]] xrpl::STObject +createOwnerDirLedgerObject(std::vector indexes, std::string_view rootIndex); /* * Create a payment channel ledger object */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createPaymentChannelLedgerObject( std::string_view accountId, std::string_view destId, @@ -235,7 +230,7 @@ createPaymentChannelLedgerObject( uint32_t previousTxnSeq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createRippleStateLedgerObject( std::string_view currency, std::string_view issuerId, @@ -249,7 +244,7 @@ createRippleStateLedgerObject( uint32_t flag = 0 ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createOfferLedgerObject( std::string_view account, int takerGets, @@ -262,19 +257,19 @@ createOfferLedgerObject( std::optional domain = std::nullopt ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createTicketLedgerObject(std::string_view account, uint32_t sequence); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createEscrowLedgerObject(std::string_view account, std::string_view dest); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createCheckLedgerObject(std::string_view account, std::string_view dest); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createDepositPreauthLedgerObjectByAuth(std::string_view account, std::string_view auth); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createDepositPreauthLedgerObjectByAuthCredentials( std::string_view account, std::string_view issuer, @@ -285,24 +280,24 @@ createDepositPreauthLedgerObjectByAuthCredentials( createNft( std::string_view tokenID, std::string_view account, - ripple::LedgerIndex seq = 1234u, - ripple::Blob uri = ripple::Blob{'u', 'r', 'i'}, + xrpl::LedgerIndex seq = 1234u, + xrpl::Blob uri = xrpl::Blob{'u', 'r', 'i'}, bool isBurned = false ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createNftBuyOffer(std::string_view tokenID, std::string_view account); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createNftSellOffer(std::string_view tokenID, std::string_view account); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createSignerLists(std::vector> const& signers); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createNftTokenPage( std::vector> const& tokens, - std::optional previousPage + std::optional previousPage ); /** @@ -332,7 +327,7 @@ createMintNftTxWithMetadataOfCreatedNode( ); [[nodiscard]] data::TransactionAndMetadata -createNftModifyTxWithMetadata(std::string_view accountId, std::string_view nftID, ripple::Blob uri); +createNftModifyTxWithMetadata(std::string_view accountId, std::string_view nftID, xrpl::Blob uri); /** * Create NFToken burn tx, tx causes a nft page node deleted @@ -384,13 +379,13 @@ createCreateNftOfferTxWithMetadata( std::string_view offerId ); -[[nodiscard]] ripple::STObject -createAmendmentsObject(std::vector const& enabledAmendments); +[[nodiscard]] xrpl::STObject +createAmendmentsObject(std::vector const& enabledAmendments); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createBrokenAmendmentsObject(); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createAmmObject( std::string_view accountId, std::string_view assetCurrency, @@ -403,7 +398,7 @@ createAmmObject( uint64_t ownerNode = 0u ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createBridgeObject( std::string_view accountId, std::string_view lockingDoor, @@ -412,7 +407,7 @@ createBridgeObject( std::string_view issuingIssuer ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createChainOwnedClaimIdObject( std::string_view accountId, std::string_view lockingDoor, @@ -422,7 +417,7 @@ createChainOwnedClaimIdObject( std::string_view otherChainSource ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createChainOwnedCreateAccountClaimId( std::string_view accountId, std::string_view lockingDoor, @@ -432,25 +427,25 @@ createChainOwnedCreateAccountClaimId( ); void -ammAddVoteSlot(ripple::STObject& amm, ripple::AccountID const& accountId, uint16_t tradingFee, uint32_t voteWeight); +ammAddVoteSlot(xrpl::STObject& amm, xrpl::AccountID const& accountId, uint16_t tradingFee, uint32_t voteWeight); void ammSetAuctionSlot( - ripple::STObject& amm, - ripple::AccountID const& accountId, - ripple::STAmount price, + xrpl::STObject& amm, + xrpl::AccountID const& accountId, + xrpl::STAmount price, uint16_t discountedFee, uint32_t expiration, - std::vector const& authAccounts = {} + std::vector const& authAccounts = {} ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createDidObject(std::string_view accountId, std::string_view didDoc, std::string_view uri, std::string_view data); -[[nodiscard]] ripple::Currency +[[nodiscard]] xrpl::Currency createLptCurrency(std::string_view assetCurrency, std::string_view asset2Currency); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createMptIssuanceObject( std::string_view accountId, std::uint32_t seq, @@ -465,26 +460,26 @@ createMptIssuanceObject( std::optional mutableFlags = std::nullopt ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createMpTokenObject( std::string_view accountId, - ripple::uint192 issuanceID, + xrpl::uint192 issuanceID, std::uint64_t mptAmount = 1, std::uint32_t flags = 0, std::optional lockedAmount = std::nullopt ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createMPTIssuanceCreateTx(std::string_view accountId, uint32_t fee, uint32_t seq); [[nodiscard]] data::TransactionAndMetadata createMPTIssuanceCreateTxWithMetadata(std::string_view accountId, uint32_t fee, uint32_t seq); [[nodiscard]] -ripple::STObject +xrpl::STObject createMPTokenAuthorizeTx( std::string_view accountId, - ripple::uint192 const& mptIssuanceID, + xrpl::uint192 const& mptIssuanceID, uint32_t fee, uint32_t seq, std::optional holder = std::nullopt, @@ -495,53 +490,53 @@ createMPTokenAuthorizeTx( data::TransactionAndMetadata createMPTokenAuthorizeTxWithMetadata( std::string_view accountId, - ripple::uint192 const& mptIssuanceID, + xrpl::uint192 const& mptIssuanceID, uint32_t fee, uint32_t seq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createPermissionedDomainObject( std::string_view accountId, std::string_view ledgerIndex, - ripple::LedgerIndex seq, + xrpl::LedgerIndex seq, uint64_t ownerNode, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createDelegateObject( std::string_view accountId, std::string_view authorize, std::string_view ledgerIndex, uint64_t ownerNode, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createOraclePriceData( uint64_t assetPrice, - ripple::Currency baseAssetCurrency, - ripple::Currency quoteAssetCurrency, + xrpl::Currency baseAssetCurrency, + xrpl::Currency quoteAssetCurrency, uint8_t scale ); -[[nodiscard]] ripple::STArray -createPriceDataSeries(std::vector const& series); +[[nodiscard]] xrpl::STArray +createPriceDataSeries(std::vector const& series); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createOracleObject( std::string_view accountId, std::string_view provider, uint64_t ownerNode, uint32_t lastUpdateTime, - ripple::Blob uri, - ripple::Blob assetClass, + xrpl::Blob uri, + xrpl::Blob assetClass, uint32_t previousTxSeq, - ripple::uint256 previousTxId, - ripple::STArray priceDataSeries + xrpl::uint256 previousTxId, + xrpl::STArray priceDataSeries ); [[nodiscard]] data::TransactionAndMetadata @@ -551,13 +546,13 @@ createOracleSetTxWithMetadata( uint32_t fee, uint32_t docId, std::uint32_t lastUpdateTime, - ripple::STArray priceDataSeries, + xrpl::STArray priceDataSeries, std::string_view oracleIndex, bool created, std::string_view previousTxnId ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createCredentialObject( std::string_view acc1, std::string_view acc2, @@ -566,18 +561,18 @@ createCredentialObject( std::optional expiration = std::nullopt ); -[[nodiscard]] ripple::STArray +[[nodiscard]] xrpl::STArray createAuthCredentialArray(std::vector issuer, std::vector credType); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createVault( std::string_view owner, std::string_view account, - ripple::LedgerIndex seq, + xrpl::LedgerIndex seq, std::string_view assetCurrency, std::string_view assetIssuer, - ripple::uint192 shareMPTID, + xrpl::uint192 shareMPTID, uint64_t ownerNode, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ); diff --git a/tests/integration/data/cassandra/BackendTests.cpp b/tests/integration/data/cassandra/BackendTests.cpp index 04909575f..e172af7d3 100644 --- a/tests/integration/data/cassandra/BackendTests.cpp +++ b/tests/integration/data/cassandra/BackendTests.cpp @@ -48,6 +48,7 @@ #include #include #include +#include #include #include #include @@ -158,7 +159,7 @@ TEST_F(BackendCassandraTest, Basic) "CE5AA29652EFFD80AC59CD91416E4E13DBBE"; std::string rawHeaderBlob = hexStringToBinaryString(rawHeader); - ripple::LedgerHeader const lgrInfo = util::deserializeHeader(ripple::makeSlice(rawHeaderBlob)); + xrpl::LedgerHeader const lgrInfo = util::deserializeHeader(xrpl::makeSlice(rawHeaderBlob)); backend_->writeLedger(lgrInfo, std::move(rawHeaderBlob)); backend_->writeSuccessor(uint256ToString(data::kFIRST_KEY), lgrInfo.seq, uint256ToString(data::kLAST_KEY)); @@ -392,7 +393,7 @@ TEST_F(BackendCassandraTest, Basic) std::string const nftTxnHashHex = "6C7F69A6D25A13AC4A2E9145999F45D4674F939900017A96885FDC2757" "E9284E"; - ripple::uint256 nftID; + xrpl::uint256 nftID; EXPECT_TRUE(nftID.parseHex( "000800006203F49C21D5D6E022CB16DE3538F248662" "FC73CEF7FF5C60000002C" @@ -403,7 +404,7 @@ TEST_F(BackendCassandraTest, Basic) std::string const hashBlob = hexStringToBinaryString(hashHex); std::string accountBlob = hexStringToBinaryString(accountHex); std::string const accountIndexBlob = hexStringToBinaryString(accountIndexHex); - std::vector affectedAccounts; + std::vector affectedAccounts; std::string nftTxnBlob = hexStringToBinaryString(nftTxnHex); std::string const nftTxnMetaBlob = hexStringToBinaryString(nftTxnMeta); @@ -415,9 +416,9 @@ TEST_F(BackendCassandraTest, Basic) lgrInfoNext.parentHash = lgrInfoNext.hash; lgrInfoNext.hash++; - ripple::uint256 hash256; + xrpl::uint256 hash256; EXPECT_TRUE(hash256.parseHex(hashHex)); - ripple::TxMeta const txMeta{hash256, lgrInfoNext.seq, metaBlob}; + xrpl::TxMeta const txMeta{hash256, lgrInfoNext.seq, xrpl::Blob{metaBlob.begin(), metaBlob.end()}}; auto accountsSet = txMeta.getAffectedAccounts(); for (auto& a : accountsSet) { affectedAccounts.push_back(a); @@ -425,11 +426,13 @@ TEST_F(BackendCassandraTest, Basic) std::vector accountTxData; accountTxData.emplace_back(txMeta, hash256); - ripple::uint256 nftHash256; + xrpl::uint256 nftHash256; EXPECT_TRUE(nftHash256.parseHex(nftTxnHashHex)); - ripple::TxMeta const nftTxMeta{nftHash256, lgrInfoNext.seq, nftTxnMetaBlob}; - ripple::SerialIter it{nftTxnBlob.data(), nftTxnBlob.size()}; - ripple::STTx const sttx{it}; + xrpl::TxMeta const nftTxMeta{ + nftHash256, lgrInfoNext.seq, xrpl::Blob{nftTxnMetaBlob.begin(), nftTxnMetaBlob.end()} + }; + xrpl::SerialIter it{nftTxnBlob.data(), nftTxnBlob.size()}; + xrpl::STTx const sttx{it}; auto const [parsedNFTTxsRef, parsedNFT] = etl::getNFTDataFromTx(nftTxMeta, sttx); // need to copy the nft txns so we can std::move later std::vector parsedNFTTxs; @@ -479,7 +482,7 @@ TEST_F(BackendCassandraTest, Basic) ); auto hashes = backend_->fetchAllTransactionHashesInLedger(lgrInfoNext.seq, yield); EXPECT_EQ(hashes.size(), 1); - EXPECT_EQ(ripple::strHex(hashes[0]), hashHex); + EXPECT_EQ(xrpl::strHex(hashes[0]), hashHex); for (auto& a : affectedAccounts) { auto [accountTransactions, cursor] = backend_->fetchAccountTransactions(a, 100, true, {}, yield); EXPECT_EQ(accountTransactions.size(), 1); @@ -493,7 +496,7 @@ TEST_F(BackendCassandraTest, Basic) EXPECT_EQ(nftTxns[0], nftTxns[0]); EXPECT_FALSE(cursor); - ripple::uint256 key256; + xrpl::uint256 key256; EXPECT_TRUE(key256.parseHex(accountIndexHex)); auto obj = backend_->fetchLedgerObject(key256, lgrInfoNext.seq, yield); EXPECT_TRUE(obj); @@ -530,7 +533,7 @@ TEST_F(BackendCassandraTest, Basic) auto txns = backend_->fetchAllTransactionsInLedger(lgrInfoNext.seq, yield); EXPECT_EQ(txns.size(), 0); - ripple::uint256 key256; + xrpl::uint256 key256; EXPECT_TRUE(key256.parseHex(accountIndexHex)); auto obj = backend_->fetchLedgerObject(key256, lgrInfoNext.seq, yield); EXPECT_TRUE(obj); @@ -570,7 +573,7 @@ TEST_F(BackendCassandraTest, Basic) auto txns = backend_->fetchAllTransactionsInLedger(lgrInfoNext.seq, yield); EXPECT_EQ(txns.size(), 0); - ripple::uint256 key256; + xrpl::uint256 key256; EXPECT_TRUE(key256.parseHex(accountIndexHex)); auto obj = backend_->fetchLedgerObject(key256, lgrInfoNext.seq, yield); EXPECT_FALSE(obj); @@ -585,12 +588,12 @@ TEST_F(BackendCassandraTest, Basic) auto generateObjects = [](size_t numObjects, uint32_t ledgerSequence) { std::vector> res{numObjects}; - ripple::uint256 key; + xrpl::uint256 key; key = ledgerSequence * 100000ul; for (auto& blob : res) { ++key; - std::string const keyStr{reinterpret_cast(key.data()), ripple::uint256::size()}; + std::string const keyStr{reinterpret_cast(key.data()), xrpl::uint256::size()}; blob.first = keyStr; blob.second = std::to_string(ledgerSequence) + keyStr; } @@ -604,11 +607,11 @@ TEST_F(BackendCassandraTest, Basic) }; auto generateTxns = [](size_t numTxns, uint32_t ledgerSequence) { std::vector> res{numTxns}; - ripple::uint256 base; + xrpl::uint256 base; base = ledgerSequence * 100000ul; for (auto& blob : res) { ++base; - std::string const hashStr{reinterpret_cast(base.data()), ripple::uint256::size()}; + std::string const hashStr{reinterpret_cast(base.data()), xrpl::uint256::size()}; std::string const txnStr = "tx" + std::to_string(ledgerSequence) + hashStr; std::string const metaStr = "meta" + std::to_string(ledgerSequence) + hashStr; blob = std::make_tuple(hashStr, txnStr, metaStr); @@ -616,8 +619,8 @@ TEST_F(BackendCassandraTest, Basic) return res; }; auto generateAccounts = [](uint32_t ledgerSequence, uint32_t numAccounts) { - std::vector accounts; - ripple::AccountID base; + std::vector accounts; + xrpl::AccountID base; base = ledgerSequence * 998765ul; for (size_t i = 0; i < numAccounts; ++i) { ++base; @@ -744,7 +747,7 @@ TEST_F(BackendCassandraTest, Basic) EXPECT_STREQ(reinterpret_cast(meta.data()), static_cast(expMeta.data())); } } - std::vector keys; + std::vector keys; for (auto [key, obj] : objs) { auto retObj = backend_->fetchLedgerObject(binaryStringToUint256(key), seq, yield); if (obj.size()) { @@ -785,9 +788,9 @@ TEST_F(BackendCassandraTest, Basic) for (auto const& obj : objs) { bool found = false; for (auto const& retObj : retObjs) { - if (ripple::strHex(obj.first) == ripple::strHex(retObj.key)) { + if (xrpl::strHex(obj.first) == xrpl::strHex(retObj.key)) { found = true; - ASSERT_EQ(ripple::strHex(obj.second), ripple::strHex(retObj.blob)); + ASSERT_EQ(xrpl::strHex(obj.second), xrpl::strHex(retObj.blob)); } } if (found != (obj.second.size() != 0)) @@ -798,8 +801,8 @@ TEST_F(BackendCassandraTest, Basic) std::map>> state; std::map>> allTxns; std::unordered_map> allTxnsMap; - std::map>> allAccountTx; - std::map lgrInfos; + std::map>> allAccountTx; + std::map lgrInfos; for (size_t i = 0; i < 10; ++i) { lgrInfoNext = generateNextLedger(lgrInfoNext); auto objs = generateObjects(25, lgrInfoNext.seq); @@ -808,7 +811,7 @@ TEST_F(BackendCassandraTest, Basic) for (auto rec : accountTx) { for (auto account : rec.accounts) { allAccountTx[lgrInfoNext.seq][account].emplace_back( - reinterpret_cast(rec.txHash.data()), ripple::uint256::size() + reinterpret_cast(rec.txHash.data()), xrpl::uint256::size() ); } } @@ -839,7 +842,7 @@ TEST_F(BackendCassandraTest, Basic) for (auto rec : accountTx) { for (auto account : rec.accounts) { allAccountTx[lgrInfoNext.seq][account].emplace_back( - reinterpret_cast(rec.txHash.data()), ripple::uint256::size() + reinterpret_cast(rec.txHash.data()), xrpl::uint256::size() ); } } @@ -878,7 +881,7 @@ TEST_F(BackendCassandraTest, Basic) }; auto flattenAccountTx = [&](uint32_t max) { - std::unordered_map>> + std::unordered_map>> accountTx; for (auto const& [seq, map] : allAccountTx) { if (seq > max) @@ -927,7 +930,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) std::string rawHeaderBlob = hexStringToBinaryString(kRAWHEADER); std::string accountBlob = hexStringToBinaryString(accountHex); std::string const accountIndexBlob = hexStringToBinaryString(accountIndexHex); - ripple::LedgerHeader const lgrInfo = util::deserializeHeader(ripple::makeSlice(rawHeaderBlob)); + xrpl::LedgerHeader const lgrInfo = util::deserializeHeader(xrpl::makeSlice(rawHeaderBlob)); backend_->startWrites(); backend_->writeLedger(lgrInfo, std::move(rawHeaderBlob)); @@ -1003,7 +1006,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) backend_->writeLedger(lgrInfoNext, ledgerHeaderToBinaryString(lgrInfoNext)); backend_->writeLedgerObject(std::string{accountIndexBlob}, lgrInfoNext.seq, std::string{accountBlob}); - auto key = ripple::uint256::fromVoidChecked(accountIndexBlob); + auto key = xrpl::uint256::fromVoidChecked(accountIndexBlob); backend_->cache().update( {{.key = *key, .blob = {accountBlob.begin(), accountBlob.end()}}}, lgrInfoNext.seq ); @@ -1020,7 +1023,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) auto retLgr = backend_->fetchLedgerBySequence(lgrInfoNext.seq, yield); EXPECT_TRUE(retLgr); EXPECT_EQ(ledgerHeaderToBlob(*retLgr), ledgerHeaderToBlob(lgrInfoNext)); - ripple::uint256 key256; + xrpl::uint256 key256; EXPECT_TRUE(key256.parseHex(accountIndexHex)); auto obj = backend_->fetchLedgerObject(key256, lgrInfoNext.seq, yield); EXPECT_TRUE(obj); @@ -1042,7 +1045,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) backend_->writeLedger(lgrInfoNext, ledgerHeaderToBinaryString(lgrInfoNext)); std::shuffle(accountBlob.begin(), accountBlob.end(), randomEngine_); - auto key = ripple::uint256::fromVoidChecked(accountIndexBlob); + auto key = xrpl::uint256::fromVoidChecked(accountIndexBlob); backend_->cache().update( {{.key = *key, .blob = {accountBlob.begin(), accountBlob.end()}}}, lgrInfoNext.seq ); @@ -1058,7 +1061,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) auto retLgr = backend_->fetchLedgerBySequence(lgrInfoNext.seq, yield); EXPECT_TRUE(retLgr); - ripple::uint256 key256; + xrpl::uint256 key256; EXPECT_TRUE(key256.parseHex(accountIndexHex)); auto obj = backend_->fetchLedgerObject(key256, lgrInfoNext.seq, yield); EXPECT_TRUE(obj); @@ -1081,7 +1084,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) lgrInfoNext.accountHash = ~(lgrInfoNext.accountHash ^ lgrInfoNext.txHash); backend_->writeLedger(lgrInfoNext, ledgerHeaderToBinaryString(lgrInfoNext)); - auto key = ripple::uint256::fromVoidChecked(accountIndexBlob); + auto key = xrpl::uint256::fromVoidChecked(accountIndexBlob); backend_->cache().update({{.key = *key, .blob = {}}}, lgrInfoNext.seq); backend_->writeLedgerObject(std::string{accountIndexBlob}, lgrInfoNext.seq, std::string{}); backend_->writeSuccessor( @@ -1098,7 +1101,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) auto retLgr = backend_->fetchLedgerBySequence(lgrInfoNext.seq, yield); EXPECT_TRUE(retLgr); - ripple::uint256 key256; + xrpl::uint256 key256; EXPECT_TRUE(key256.parseHex(accountIndexHex)); auto obj = backend_->fetchLedgerObject(key256, lgrInfoNext.seq, yield); EXPECT_FALSE(obj); @@ -1113,12 +1116,12 @@ TEST_F(BackendCassandraTest, CacheIntegration) auto generateObjects = [](size_t numObjects, uint64_t ledgerSequence) { std::vector> res{numObjects}; - ripple::uint256 key; + xrpl::uint256 key; key = ledgerSequence * 100000; for (auto& blob : res) { ++key; - std::string const keyStr{reinterpret_cast(key.data()), ripple::uint256::size()}; + std::string const keyStr{reinterpret_cast(key.data()), xrpl::uint256::size()}; blob.first = keyStr; blob.second = std::to_string(ledgerSequence) + keyStr; } @@ -1146,7 +1149,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) std::vector cacheUpdates; for (auto [key, obj] : objs) { backend_->writeLedgerObject(std::string{key}, lgrInfo.seq, std::string{obj}); - auto key256 = ripple::uint256::fromVoidChecked(key); + auto key256 = xrpl::uint256::fromVoidChecked(key); cacheUpdates.push_back({*key256, {obj.begin(), obj.end()}}); } backend_->cache().update(cacheUpdates, lgrInfo.seq); @@ -1195,7 +1198,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) << "; lgrInfo hash:" << lgrInfo.hash << "; retLgr parentHash:" << retLgr->parentHash << "; lgr Info parentHash:" << lgrInfo.parentHash; - std::vector keys; + std::vector keys; for (auto [key, obj] : objs) { auto retObj = backend_->fetchLedgerObject(binaryStringToUint256(key), seq, yield); if (obj.size()) { @@ -1234,9 +1237,9 @@ TEST_F(BackendCassandraTest, CacheIntegration) for (auto const& obj : objs) { bool found = false; for (auto const& retObj : retObjs) { - if (ripple::strHex(obj.first) == ripple::strHex(retObj.key)) { + if (xrpl::strHex(obj.first) == xrpl::strHex(retObj.key)) { found = true; - ASSERT_EQ(ripple::strHex(obj.second), ripple::strHex(retObj.blob)); + ASSERT_EQ(xrpl::strHex(obj.second), xrpl::strHex(retObj.blob)); } } if (found != (obj.second.size() != 0)) @@ -1245,7 +1248,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) }; std::map>> state; - std::map lgrInfos; + std::map lgrInfos; for (size_t i = 0; i < 10; ++i) { lgrInfoNext = generateNextLedger(lgrInfoNext); auto objs = generateObjects(25, lgrInfoNext.seq); @@ -1327,7 +1330,7 @@ TEST_F(CacheBackendCassandraTest, CacheFetchLedgerBySeq) { runSpawn([&](boost::asio::yield_context yield) { auto rawHeaderBlob = hexStringToBinaryString(kRAWHEADER); - ripple::LedgerHeader const lgrInfo = util::deserializeHeader(ripple::makeSlice(rawHeaderBlob)); + xrpl::LedgerHeader const lgrInfo = util::deserializeHeader(xrpl::makeSlice(rawHeaderBlob)); backend_->writeLedger(lgrInfo, std::move(rawHeaderBlob)); auto const testLedgerSeq = lgrInfo.seq; diff --git a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp index 482639e3f..f1af4e403 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp +++ b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp @@ -238,21 +238,21 @@ TEST_F(MigrationCassandraManagerTxTableTest, MigrateExampleTransactionsMigrator) EXPECT_EQ(newTableSize, gTransactionsRawData.size()); // check a few tx types - auto const getTxType = [&](ripple::uint256 const& txHash) -> std::optional { + auto const getTxType = [&](xrpl::uint256 const& txHash) -> std::optional { return data::synchronous([&](auto ctx) { return testMigrationBackend_->fetchTxTypeViaID(uint256ToString(txHash), ctx); }); }; - auto txType = getTxType(ripple::uint256("CEECF7E516F8A53C5D32A357B737ED54D3186FDD510B1973D908AD8D93AD8E00")); + auto txType = getTxType(xrpl::uint256("CEECF7E516F8A53C5D32A357B737ED54D3186FDD510B1973D908AD8D93AD8E00")); EXPECT_TRUE(txType.has_value()); EXPECT_EQ(txType.value(), "OracleSet"); - txType = getTxType(ripple::uint256("35DBFB1A88DE17EBD2BCE37F6E1FD6D3B9887C92B7933ED2FCF2A84E9138B7CA")); + txType = getTxType(xrpl::uint256("35DBFB1A88DE17EBD2BCE37F6E1FD6D3B9887C92B7933ED2FCF2A84E9138B7CA")); EXPECT_TRUE(txType.has_value()); EXPECT_EQ(txType.value(), "Payment"); - txType = getTxType(ripple::uint256("FCACE9D00625FA3BCC5316078324EA153EC8551243AC1701D496CC1CA2B8A474")); + txType = getTxType(xrpl::uint256("FCACE9D00625FA3BCC5316078324EA153EC8551243AC1701D496CC1CA2B8A474")); EXPECT_TRUE(txType.has_value()); EXPECT_EQ(txType.value(), "AMMCreate"); @@ -320,13 +320,13 @@ TEST_F(MigrationCassandraManagerLedgerTableTest, MigrateExampleLedgerMigrator) }; EXPECT_EQ( - getAccountHash(5619393), ripple::uint256("D1DE0F83A6858DF52811E31FE97B8449A4DD55A7D9E0023FE5DC2B335E4C49E8") + getAccountHash(5619393), xrpl::uint256("D1DE0F83A6858DF52811E31FE97B8449A4DD55A7D9E0023FE5DC2B335E4C49E8") ); EXPECT_EQ( - getAccountHash(5619394), ripple::uint256("3FEF485204772F03842AA8757B4631E8F146E17AD9762E0552540A517DD38A24") + getAccountHash(5619394), xrpl::uint256("3FEF485204772F03842AA8757B4631E8F146E17AD9762E0552540A517DD38A24") ); EXPECT_EQ( - getAccountHash(5619395), ripple::uint256("D0A61C158AD8941868666AD51C4662EEAAA2A141BF0F4435BC22B9BC6783AF65") + getAccountHash(5619395), xrpl::uint256("D0A61C158AD8941868666AD51C4662EEAAA2A141BF0F4435BC22B9BC6783AF65") ); } diff --git a/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp b/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp index f66a9e485..8a75ac362 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp +++ b/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp @@ -197,7 +197,7 @@ public: * @param ctx The boost asio context * @return The account hash if found, otherwise std::nullopt */ - std::optional + std::optional fetchAccountHashViaSequence(std::uint64_t sequence, boost::asio::yield_context ctx) { static auto kFETCH_ACCOUNT_HASH = [this]() { @@ -220,7 +220,7 @@ public: return std::nullopt; } - for (auto const& [accountHash] : data::cassandra::extract(result)) { + for (auto const& [accountHash] : data::cassandra::extract(result)) { return accountHash; } return std::nullopt; diff --git a/tests/integration/migration/cassandra/ExampleObjectsMigrator.cpp b/tests/integration/migration/cassandra/ExampleObjectsMigrator.cpp index 01c01b9d9..d9d0ec124 100644 --- a/tests/integration/migration/cassandra/ExampleObjectsMigrator.cpp +++ b/tests/integration/migration/cassandra/ExampleObjectsMigrator.cpp @@ -43,12 +43,12 @@ ExampleObjectsMigrator::runMigration(std::shared_ptr const& backend, ut auto const jobsFullScan = config.get("full_scan_jobs"); auto const cursorPerJobsFullScan = config.get("cursors_per_job"); - std::unordered_set idx; + std::unordered_set idx; migration::cassandra::impl::ObjectsScanner scanner( {.ctxThreadsNum = ctxFullScanThreads, .jobsNum = jobsFullScan, .cursorsPerJob = cursorPerJobsFullScan}, - migration::cassandra::impl::ObjectsAdapter(backend, [&](std::uint32_t, std::optional sle) { + migration::cassandra::impl::ObjectsAdapter(backend, [&](std::uint32_t, std::optional sle) { if (sle.has_value()) { - if (sle->getType() == ripple::ltACCOUNT_ROOT) { + if (sle->getType() == xrpl::ltACCOUNT_ROOT) { if (!idx.contains(sle->key())) { ExampleObjectsMigrator::accountCount++; } diff --git a/tests/integration/migration/cassandra/ExampleTransactionsMigrator.cpp b/tests/integration/migration/cassandra/ExampleTransactionsMigrator.cpp index bcf8c9fb2..07769db55 100644 --- a/tests/integration/migration/cassandra/ExampleTransactionsMigrator.cpp +++ b/tests/integration/migration/cassandra/ExampleTransactionsMigrator.cpp @@ -51,9 +51,9 @@ ExampleTransactionsMigrator::runMigration( util::Mutex hashSet; migration::cassandra::impl::TransactionsScanner scanner( {.ctxThreadsNum = ctxFullScanThreads, .jobsNum = jobsFullScan, .cursorsPerJob = cursorPerJobsFullScan}, - migration::cassandra::impl::TransactionsAdapter(backend, [&](ripple::STTx const& tx, ripple::TxMeta const&) { - hashSet.lock()->insert(ripple::to_string(tx.getTransactionID())); - auto const json = tx.getJson(ripple::JsonOptions::none); + migration::cassandra::impl::TransactionsAdapter(backend, [&](xrpl::STTx const& tx, xrpl::TxMeta const&) { + hashSet.lock()->insert(xrpl::to_string(tx.getTransactionID())); + auto const json = tx.getJson(xrpl::JsonOptions::Values::None); auto const txType = json["TransactionType"].asString(); backend->writeTxIndexExample(uint256ToString(tx.getTransactionID()), txType); }) diff --git a/tests/unit/app/WebHandlersTests.cpp b/tests/unit/app/WebHandlersTests.cpp index 58b9f0623..1ce892e53 100644 --- a/tests/unit/app/WebHandlersTests.cpp +++ b/tests/unit/app/WebHandlersTests.cpp @@ -228,7 +228,7 @@ TEST_F(RequestHandlerTest, RpcHandlerThrows) auto const body = boost::json::parse(httpResponse.body()).as_object(); EXPECT_EQ(body.at("error").as_string(), "internal"); - EXPECT_EQ(body.at("error_code").as_int64(), rpc::RippledError::rpcINTERNAL); + EXPECT_EQ(body.at("error_code").as_int64(), rpc::RippledError::RpcInternal); EXPECT_EQ(body.at("status").as_string(), "error"); }); } diff --git a/tests/unit/data/AmendmentCenterTests.cpp b/tests/unit/data/AmendmentCenterTests.cpp index c5d2b1d48..381e1bab3 100644 --- a/tests/unit/data/AmendmentCenterTests.cpp +++ b/tests/unit/data/AmendmentCenterTests.cpp @@ -32,8 +32,8 @@ #include #include +#include #include -#include #include #include @@ -49,23 +49,23 @@ struct AmendmentCenterTest : util::prometheus::WithPrometheus, MockBackendTest, // we forgot to register in data::Amendments. TEST_F(AmendmentCenterTest, AllAmendmentsFromLibXRPLAreSupported) { - for (auto const& [name, _] : ripple::allAmendments()) { + for (auto const& [name, _] : xrpl::allAmendments()) { EXPECT_TRUE(amendmentCenter.isSupported(name)) << "XRPL amendment not supported by Clio: " << name; } - ASSERT_EQ(amendmentCenter.getSupported().size(), ripple::allAmendments().size()); - ASSERT_EQ(amendmentCenter.getAll().size(), ripple::allAmendments().size()); + ASSERT_EQ(amendmentCenter.getSupported().size(), xrpl::allAmendments().size()); + ASSERT_EQ(amendmentCenter.getAll().size(), xrpl::allAmendments().size()); } TEST_F(AmendmentCenterTest, Accessors) { { auto const am = amendmentCenter.getAmendment("DisallowIncoming"); - EXPECT_EQ(am.feature, ripple::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF")); + EXPECT_EQ(am.feature, xrpl::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF")); } { auto const am = amendmentCenter["DisallowIncoming"]; - EXPECT_EQ(am.feature, ripple::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF")); + EXPECT_EQ(am.feature, xrpl::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF")); } auto const a = amendmentCenter[Amendments::Flow]; @@ -79,7 +79,7 @@ TEST_F(AmendmentCenterTest, IsEnabled) EXPECT_FALSE(amendmentCenter.isSupported("unknown")); auto const amendments = createAmendmentsObject({Amendments::fixUniversalNumber}); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amendments().key, kSEQ, testing::_)) .WillRepeatedly(testing::Return(amendments.getSerializer().peekData())); EXPECT_TRUE(amendmentCenter.isEnabled("fixUniversalNumber", kSEQ)); @@ -90,7 +90,7 @@ TEST_F(AmendmentCenterTest, IsEnabled) TEST_F(AmendmentCenterTest, IsMultipleEnabled) { auto const amendments = createAmendmentsObject({Amendments::fixUniversalNumber}); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amendments().key, kSEQ, testing::_)) .WillOnce(testing::Return(amendments.getSerializer().peekData())); runSpawn([this](auto yield) { @@ -106,7 +106,7 @@ TEST_F(AmendmentCenterTest, IsMultipleEnabled) TEST_F(AmendmentCenterTest, IsEnabledReturnsFalseWhenAmendmentsLedgerObjectUnavailable) { - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amendments().key, kSEQ, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([this](auto yield) { @@ -117,7 +117,7 @@ TEST_F(AmendmentCenterTest, IsEnabledReturnsFalseWhenAmendmentsLedgerObjectUnava TEST_F(AmendmentCenterTest, IsEnabledReturnsFalseWhenNoAmendments) { auto const amendments = createBrokenAmendmentsObject(); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amendments().key, kSEQ, testing::_)) .WillOnce(testing::Return(amendments.getSerializer().peekData())); runSpawn([this](auto yield) { EXPECT_FALSE(amendmentCenter.isEnabled(yield, "irrelevant", kSEQ)); }); @@ -125,7 +125,7 @@ TEST_F(AmendmentCenterTest, IsEnabledReturnsFalseWhenNoAmendments) TEST_F(AmendmentCenterTest, IsEnabledReturnsVectorOfFalseWhenAmendmentsLedgerObjectUnavailable) { - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amendments().key, kSEQ, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([this](auto yield) { @@ -141,7 +141,7 @@ TEST_F(AmendmentCenterTest, IsEnabledReturnsVectorOfFalseWhenAmendmentsLedgerObj TEST_F(AmendmentCenterTest, IsEnabledReturnsVectorOfFalseWhenNoAmendments) { auto const amendments = createBrokenAmendmentsObject(); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amendments().key, kSEQ, testing::_)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amendments().key, kSEQ, testing::_)) .WillOnce(testing::Return(amendments.getSerializer().peekData())); runSpawn([this](auto yield) { @@ -157,7 +157,7 @@ TEST(AmendmentTest, GenerateAmendmentId) { // https://xrpl.org/known-amendments.html#disallowincoming refer to the published id EXPECT_EQ( - ripple::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF"), + xrpl::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF"), Amendment::getAmendmentId("DisallowIncoming") ); } @@ -185,11 +185,11 @@ TEST_F(AmendmentKeyTest, Convertible) std::string const s1 = first; EXPECT_EQ(s1, key1); - ripple::uint256 const k1 = first; - ripple::uint256 const k2 = second; + xrpl::uint256 const k1 = first; + xrpl::uint256 const k2 = second; - EXPECT_EQ(k1, ripple::uint256{"7E365F775657DC0EB960E6295A1F44B3F67479F54D5D12C5D87E6DB234F072E3"}); - EXPECT_EQ(k2, ripple::uint256{"B4F33541E0E2FC2F7AA17D2D2E6A9B424809123485251D3413E91CC462309772"}); + EXPECT_EQ(k1, xrpl::uint256{"7E365F775657DC0EB960E6295A1F44B3F67479F54D5D12C5D87E6DB234F072E3"}); + EXPECT_EQ(k2, xrpl::uint256{"B4F33541E0E2FC2F7AA17D2D2E6A9B424809123485251D3413E91CC462309772"}); }); } diff --git a/tests/unit/data/BackendInterfaceTests.cpp b/tests/unit/data/BackendInterfaceTests.cpp index a6430348f..e129352c9 100644 --- a/tests/unit/data/BackendInterfaceTests.cpp +++ b/tests/unit/data/BackendInterfaceTests.cpp @@ -54,7 +54,7 @@ struct BackendInterfaceTest : WithPrometheus, MockBackendTestNaggy, SyncAsioCont TEST_F(BackendInterfaceTest, FetchFeesSuccessPath) { - using namespace ripple; + using namespace xrpl; // New fee setting (after XRPFees amendment) EXPECT_CALL(*backend_, doFetchLedgerObject(keylet::fees().key, kMAX_SEQ, _)) @@ -72,7 +72,7 @@ TEST_F(BackendInterfaceTest, FetchFeesSuccessPath) TEST_F(BackendInterfaceTest, FetchFeesLegacySuccessPath) { - using namespace ripple; + using namespace xrpl; // Legacy fee setting (before XRPFees amendment) EXPECT_CALL(*backend_, doFetchLedgerObject(keylet::fees().key, kMAX_SEQ, _)) @@ -90,7 +90,7 @@ TEST_F(BackendInterfaceTest, FetchFeesLegacySuccessPath) TEST_F(BackendInterfaceTest, FetchLedgerPageSuccessPath) { - using namespace ripple; + using namespace xrpl; auto state = etl::SystemState{}; backend_->setCorruptionDetector(etl::CorruptionDetector{state, backend_->cache()}); @@ -107,7 +107,7 @@ TEST_F(BackendInterfaceTest, FetchLedgerPageSuccessPath) TEST_F(BackendInterfaceTest, FetchLedgerPageDisablesCacheOnMissingData) { - using namespace ripple; + using namespace xrpl; auto state = etl::SystemState{}; backend_->setCorruptionDetector(etl::CorruptionDetector{state, backend_->cache()}); @@ -138,7 +138,7 @@ TEST_F(BackendInterfaceTest, FetchLedgerPageDisablesCacheOnMissingData) TEST_F(BackendInterfaceTest, FetchLedgerPageWithoutCorruptionDetectorDoesNotDisableCacheOnMissingData) { - using namespace ripple; + using namespace xrpl; EXPECT_FALSE(backend_->cache().isDisabled()); EXPECT_CALL(*backend_, doFetchSuccessorKey(_, _, _)) diff --git a/tests/unit/data/LedgerCacheTests.cpp b/tests/unit/data/LedgerCacheTests.cpp index 289c59610..77c6fce6e 100644 --- a/tests/unit/data/LedgerCacheTests.cpp +++ b/tests/unit/data/LedgerCacheTests.cpp @@ -74,8 +74,8 @@ TEST_F(LedgerCachePrometheusMetricTest, setFull) } struct LedgerCacheSaveLoadTest : LedgerCacheTest { - ripple::uint256 const key1{1}; - ripple::uint256 const key2{2}; + xrpl::uint256 const key1{1}; + xrpl::uint256 const key2{2}; std::vector const objs{ etl::model::Object{ .key = key1, diff --git a/tests/unit/data/cassandra/SettingsProviderTests.cpp b/tests/unit/data/cassandra/SettingsProviderTests.cpp index 8fe36392d..8492fa5bb 100644 --- a/tests/unit/data/cassandra/SettingsProviderTests.cpp +++ b/tests/unit/data/cassandra/SettingsProviderTests.cpp @@ -40,7 +40,6 @@ using namespace util; using namespace util::config; using namespace std; -namespace json = boost::json; using namespace data::cassandra; @@ -82,7 +81,7 @@ class SettingsProviderTest : virtual public ::testing::Test {}; TEST_F(SettingsProviderTest, Defaults) { auto const cfg = - getParseSettingsConfig(json::parse(R"JSON({"database.cassandra.contact_points": "127.0.0.1"})JSON")); + getParseSettingsConfig(boost::json::parse(R"JSON({"database.cassandra.contact_points": "127.0.0.1"})JSON")); SettingsProvider const provider{cfg.getObject("database.cassandra")}; auto const settings = provider.getSettings(); @@ -111,7 +110,7 @@ TEST_F(SettingsProviderTest, Defaults) TEST_F(SettingsProviderTest, SimpleConfig) { - auto const cfg = getParseSettingsConfig(json::parse(R"JSON({ + auto const cfg = getParseSettingsConfig(boost::json::parse(R"JSON({ "database.cassandra.contact_points": "123.123.123.123", "database.cassandra.port": 1234, "database.cassandra.keyspace": "test", @@ -136,7 +135,7 @@ TEST_F(SettingsProviderTest, SimpleConfig) TEST_F(SettingsProviderTest, DriverOptionalOptionsSpecified) { - auto const cfg = getParseSettingsConfig(json::parse(R"JSON({ + auto const cfg = getParseSettingsConfig(boost::json::parse(R"JSON({ "database.cassandra.contact_points": "123.123.123.123", "database.cassandra.queue_size_io": 2 })JSON")); @@ -148,8 +147,9 @@ TEST_F(SettingsProviderTest, DriverOptionalOptionsSpecified) TEST_F(SettingsProviderTest, SecureBundleConfig) { - auto const cfg = - getParseSettingsConfig(json::parse(R"JSON({"database.cassandra.secure_connect_bundle": "bundleData"})JSON")); + auto const cfg = getParseSettingsConfig( + boost::json::parse(R"JSON({"database.cassandra.secure_connect_bundle": "bundleData"})JSON") + ); SettingsProvider const provider{cfg.getObject("database.cassandra")}; auto const settings = provider.getSettings(); @@ -162,7 +162,7 @@ TEST_F(SettingsProviderTest, CertificateConfig) { TmpFile const file{"certificateData"}; auto const cfg = getParseSettingsConfig( - json::parse( + boost::json::parse( fmt::format( R"JSON({{ "database.cassandra.contact_points": "127.0.0.1", diff --git a/tests/unit/data/impl/LedgerCacheFileTests.cpp b/tests/unit/data/impl/LedgerCacheFileTests.cpp index d7fbc44d2..4808102ce 100644 --- a/tests/unit/data/impl/LedgerCacheFileTests.cpp +++ b/tests/unit/data/impl/LedgerCacheFileTests.cpp @@ -161,8 +161,8 @@ struct LedgerCacheFileTestBase : ::testing::Test { data.latestSeq = kLATEST_SEQUENCE; for (size_t i = 0; i < mapSize; ++i) { - ripple::uint256 key; - std::memset(key.data(), static_cast(i), ripple::uint256::size()); + xrpl::uint256 key; + std::memset(key.data(), static_cast(i), xrpl::uint256::size()); data::LedgerCache::CacheEntry entry; entry.seq = static_cast(1000 + i); @@ -173,8 +173,8 @@ struct LedgerCacheFileTestBase : ::testing::Test { } for (size_t i = 0; i < deletedSize; ++i) { - ripple::uint256 key; - std::memset(key.data(), static_cast(i + 200), ripple::uint256::size()); + xrpl::uint256 key; + std::memset(key.data(), static_cast(i + 200), xrpl::uint256::size()); data::LedgerCache::CacheEntry entry; entry.seq = static_cast(2000 + i); @@ -531,16 +531,16 @@ TEST_F(LedgerCacheFileEdgeCaseTest, SpecialKeyPatterns) LedgerCacheFile::Data testData; testData.latestSeq = 100; - ripple::uint256 zeroKey; - std::memset(zeroKey.data(), 0, ripple::uint256::size()); + xrpl::uint256 zeroKey; + std::memset(zeroKey.data(), 0, xrpl::uint256::size()); testData.map.emplace(zeroKey, data::LedgerCache::CacheEntry{.seq = 1, .blob = {1, 2, 3}}); - ripple::uint256 onesKey; - std::memset(onesKey.data(), 0xFF, ripple::uint256::size()); + xrpl::uint256 onesKey; + std::memset(onesKey.data(), 0xFF, xrpl::uint256::size()); testData.map.emplace(onesKey, data::LedgerCache::CacheEntry{.seq = 2, .blob = {4, 5, 6}}); - ripple::uint256 altKey; - for (size_t i = 0; i < ripple::uint256::size(); ++i) { + xrpl::uint256 altKey; + for (size_t i = 0; i < xrpl::uint256::size(); ++i) { altKey.data()[i] = static_cast(((i % 2) != 0u) ? 0xAA : 0x55); } testData.deleted.emplace(altKey, data::LedgerCache::CacheEntry{.seq = 3, .blob = {7, 8, 9}}); @@ -579,10 +579,10 @@ TEST_F(LedgerCacheFileEdgeCaseTest, SequenceNumber) LedgerCacheFile::Data testData; testData.latestSeq = 0; - ripple::uint256 key1, key2, key3; - std::memset(key1.data(), 1, ripple::uint256::size()); - std::memset(key2.data(), 2, ripple::uint256::size()); - std::memset(key3.data(), 3, ripple::uint256::size()); + xrpl::uint256 key1, key2, key3; + std::memset(key1.data(), 1, xrpl::uint256::size()); + std::memset(key2.data(), 2, xrpl::uint256::size()); + std::memset(key3.data(), 3, xrpl::uint256::size()); testData.map.emplace(key1, data::LedgerCache::CacheEntry{.seq = 0, .blob = {1}}); testData.map.emplace(key2, data::LedgerCache::CacheEntry{.seq = std::numeric_limits::max(), .blob = {2}}); diff --git a/tests/unit/etl/CacheLoaderSettingsTests.cpp b/tests/unit/etl/CacheLoaderSettingsTests.cpp index 1989ce1de..296f72028 100644 --- a/tests/unit/etl/CacheLoaderSettingsTests.cpp +++ b/tests/unit/etl/CacheLoaderSettingsTests.cpp @@ -29,7 +29,6 @@ #include #include -namespace json = boost::json; using namespace etl; using namespace testing; using namespace util::config; @@ -73,7 +72,7 @@ TEST_F(CacheLoaderSettingsTest, DefaultSettingsParsedCorrectly) TEST_F(CacheLoaderSettingsTest, NumThreadsCorrectlyPropagatedThroughConfig) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"io_threads": 42})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"io_threads": 42})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.numThreads, 42); @@ -81,7 +80,7 @@ TEST_F(CacheLoaderSettingsTest, NumThreadsCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, NumDiffsCorrectlyPropagatedThroughConfig) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"num_diffs": 42}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"num_diffs": 42}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.numCacheDiffs, 42); @@ -89,7 +88,7 @@ TEST_F(CacheLoaderSettingsTest, NumDiffsCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, NumMarkersCorrectlyPropagatedThroughConfig) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"num_markers": 42}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"num_markers": 42}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.numCacheMarkers, 42); @@ -97,7 +96,7 @@ TEST_F(CacheLoaderSettingsTest, NumMarkersCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, PageFetchSizeCorrectlyPropagatedThroughConfig) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"page_fetch_size": 42}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"page_fetch_size": 42}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.cachePageFetchSize, 42); @@ -105,7 +104,7 @@ TEST_F(CacheLoaderSettingsTest, PageFetchSizeCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, SyncLoadStyleCorrectlyPropagatedThroughConfig) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "sYNC"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "sYNC"}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.loadStyle, CacheLoaderSettings::LoadStyle::SYNC); @@ -114,7 +113,7 @@ TEST_F(CacheLoaderSettingsTest, SyncLoadStyleCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, AsyncLoadStyleCorrectlyPropagatedThroughConfig) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "aSynC"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "aSynC"}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.loadStyle, CacheLoaderSettings::LoadStyle::ASYNC); @@ -124,14 +123,14 @@ TEST_F(CacheLoaderSettingsTest, AsyncLoadStyleCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, NoLoadStyleCorrectlyPropagatedThroughConfig) { { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "nONe"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "nONe"}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.loadStyle, CacheLoaderSettings::LoadStyle::NONE); EXPECT_TRUE(settings.isDisabled()); } { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "nO"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "nO"}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.loadStyle, CacheLoaderSettings::LoadStyle::NONE); @@ -143,7 +142,7 @@ TEST_F(CacheLoaderSettingsTest, CacheFilePathCorrectlyPropagatedThroughConfig) { static constexpr auto kCACHE_FILE_PATH = "/path/to/cache.dat"; auto const jsonStr = fmt::format(R"JSON({{"cache": {{"file": {{"path": "{}"}}}}}})JSON", kCACHE_FILE_PATH); - auto const cfg = getParseCacheConfig(json::parse(jsonStr)); + auto const cfg = getParseCacheConfig(boost::json::parse(jsonStr)); auto const settings = makeCacheLoaderSettings(cfg); ASSERT_TRUE(settings.cacheFileSettings.has_value()); @@ -163,7 +162,7 @@ TEST_F(CacheLoaderSettingsTest, MaxSequenceLagPropagatedThoughConfig) auto const seq = 1234; auto const jsonStr = fmt::format(R"JSON({{"cache": {{"file": {{"path": "doesnt_matter", "max_sequence_age": {} }}}}}})JSON", seq); - auto const cfg = getParseCacheConfig(json::parse(jsonStr)); + auto const cfg = getParseCacheConfig(boost::json::parse(jsonStr)); auto const settings = makeCacheLoaderSettings(cfg); ASSERT_TRUE(settings.cacheFileSettings.has_value()); diff --git a/tests/unit/etl/CacheLoaderTests.cpp b/tests/unit/etl/CacheLoaderTests.cpp index b1bc1b483..b8294dc9e 100644 --- a/tests/unit/etl/CacheLoaderTests.cpp +++ b/tests/unit/etl/CacheLoaderTests.cpp @@ -42,7 +42,6 @@ #include #include -namespace json = boost::json; using namespace etl; using namespace util; using namespace data; @@ -285,7 +284,7 @@ TEST_P(ParametrizedCacheLoaderTest, CacheDisabledLeadsToCancellation) // TEST_F(CacheLoaderTest, SyncCacheLoaderWaitsTillFullyLoaded) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "sync"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "sync"}})JSON")); CacheLoader<> loader{cfg, backend_, cache}; auto const diffs = diffProvider.getLatestDiff(); @@ -311,7 +310,7 @@ TEST_F(CacheLoaderTest, SyncCacheLoaderWaitsTillFullyLoaded) TEST_F(CacheLoaderTest, AsyncCacheLoaderCanBeStopped) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "async"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "async"}})JSON")); CacheLoader loader{cfg, backend_, cache}; auto const diffs = diffProvider.getLatestDiff(); @@ -339,7 +338,7 @@ TEST_F(CacheLoaderTest, AsyncCacheLoaderCanBeStopped) TEST_F(CacheLoaderTest, DisabledCacheLoaderDoesNotLoadCache) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "none"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "none"}})JSON")); CacheLoader loader{cfg, backend_, cache}; EXPECT_CALL(cache, updateImp).Times(0); @@ -351,7 +350,7 @@ TEST_F(CacheLoaderTest, DisabledCacheLoaderDoesNotLoadCache) TEST_F(CacheLoaderTest, DisabledCacheLoaderCanCallStopAndWait) { - auto const cfg = getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "none"}})JSON")); + auto const cfg = getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"load": "none"}})JSON")); CacheLoader loader{cfg, backend_, cache}; EXPECT_CALL(cache, updateImp).Times(0); @@ -373,7 +372,7 @@ struct CacheLoaderFromFileTest : CacheLoaderTest { std::string const filePath = "./cache.bin"; uint32_t const maxSequenceLag = 10; ClioConfigDefinition const cfg = getParseCacheConfig( - json::parse( + boost::json::parse( fmt::format( R"JSON({{"cache": {{"load": "sync", "file": {{"path": "{}", "max_sequence_age": {}}}}}}})JSON", filePath, @@ -428,8 +427,9 @@ TEST_F(CacheLoaderFromFileTest, FailureBackToNormalLoad) TEST_F(CacheLoaderFromFileTest, DontLoadWhenCacheIsDisabled) { - auto const disabledCacheCfg = - getParseCacheConfig(json::parse(R"JSON({"cache": {"load": "none", "file": {"path": "/tmp/cache.bin"}}})JSON")); + auto const disabledCacheCfg = getParseCacheConfig( + boost::json::parse(R"JSON({"cache": {"load": "none", "file": {"path": "/tmp/cache.bin"}}})JSON") + ); CacheLoader loaderWithCacheDisabled{disabledCacheCfg, backend_, cache}; EXPECT_CALL(cache, isFull).WillOnce(Return(false)); diff --git a/tests/unit/etl/CorruptionDetectorTests.cpp b/tests/unit/etl/CorruptionDetectorTests.cpp index 40fda8ad3..7c594f624 100644 --- a/tests/unit/etl/CorruptionDetectorTests.cpp +++ b/tests/unit/etl/CorruptionDetectorTests.cpp @@ -33,7 +33,7 @@ struct CorruptionDetectorTest : WithPrometheus {}; TEST_F(CorruptionDetectorTest, DisableCacheOnCorruption) { - using namespace ripple; + using namespace xrpl; auto state = etl::SystemState{}; auto cache = MockLedgerCache{}; auto detector = etl::CorruptionDetector{state, cache}; diff --git a/tests/unit/etl/CursorFromAccountProviderTests.cpp b/tests/unit/etl/CursorFromAccountProviderTests.cpp index 34e71d315..2cce27731 100644 --- a/tests/unit/etl/CursorFromAccountProviderTests.cpp +++ b/tests/unit/etl/CursorFromAccountProviderTests.cpp @@ -37,16 +37,16 @@ namespace { constexpr auto kSEQ = 30; -std::vector const kACCOUNT_ROOTS = { - ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, - ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, - ripple::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, - ripple::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, - ripple::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, - ripple::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, - ripple::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, - ripple::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, - ripple::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, +std::vector const kACCOUNT_ROOTS = { + xrpl::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, + xrpl::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, + xrpl::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, + xrpl::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, + xrpl::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, + xrpl::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, + xrpl::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, + xrpl::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, + xrpl::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, }; struct CursorFromAccountProviderTests : util::prometheus::WithPrometheus, MockBackendTestNaggy {}; diff --git a/tests/unit/etl/CursorFromDiffProviderTests.cpp b/tests/unit/etl/CursorFromDiffProviderTests.cpp index 27d5ee992..e21fd5228 100644 --- a/tests/unit/etl/CursorFromDiffProviderTests.cpp +++ b/tests/unit/etl/CursorFromDiffProviderTests.cpp @@ -38,33 +38,33 @@ namespace { constexpr auto kSEQ = 30; std::vector const kDIFFS_FOR_SEQ = { - {.key = ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, + {.key = xrpl::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{}}, // This object is removed in Seq while it exists in Seq-1 - {.key = ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB95"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F9D"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB95"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F9D"}, .blob = Blob{'s'}}, }; std::vector const kDIFFS_FOR_SEQ_MINUS1 = { - {.key = ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD1301"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E12"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F03"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, + {.key = xrpl::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD1301"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E12"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F03"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, .blob = Blob{'s'}}, // This object is changed in both Seq and Seq-1 - {.key = ripple::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E05"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B386"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE447"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CED8"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB99"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F90"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E05"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B386"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE447"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CED8"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB99"}, .blob = Blob{'s'}}, + {.key = xrpl::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F90"}, .blob = Blob{'s'}}, }; struct CursorFromDiffProviderTests : util::prometheus::WithPrometheus, MockBackendTestNaggy {}; diff --git a/tests/unit/etl/ETLServiceTests.cpp b/tests/unit/etl/ETLServiceTests.cpp index 253009459..775b4595a 100644 --- a/tests/unit/etl/ETLServiceTests.cpp +++ b/tests/unit/etl/ETLServiceTests.cpp @@ -102,7 +102,7 @@ struct MockExtractor : etl::ExtractorInterface { struct MockLoader : etl::LoaderInterface { using ExpectedType = std::expected; MOCK_METHOD(ExpectedType, load, (etl::model::LedgerData const&), (override)); - MOCK_METHOD(std::optional, loadInitialLedger, (etl::model::LedgerData const&), (override)); + MOCK_METHOD(std::optional, loadInitialLedger, (etl::model::LedgerData const&), (override)); }; struct MockCacheLoader : etl::CacheLoaderInterface { @@ -307,7 +307,7 @@ TEST_F(ETLServiceTests, RunWithEmptyDatabase) EXPECT_CALL(*extractor_, extractLedgerOnly(kSEQ)).WillOnce(testing::Return(ledgerData)); EXPECT_CALL(*balancer_, loadInitialLedger(kSEQ, testing::_, testing::_)) .WillOnce(testing::Return(std::vector{})); - EXPECT_CALL(*loader_, loadInitialLedger).WillOnce(testing::Return(ripple::LedgerHeader{})); + EXPECT_CALL(*loader_, loadInitialLedger).WillOnce(testing::Return(xrpl::LedgerHeader{})); EXPECT_CALL(*backend_, hardFetchLedgerRange) .InSequence(s) .WillOnce(testing::Return(data::LedgerRange{.minSequence = 1, .maxSequence = kSEQ})); diff --git a/tests/unit/etl/ETLStateTests.cpp b/tests/unit/etl/ETLStateTests.cpp index 7603430f8..4ac630ae5 100644 --- a/tests/unit/etl/ETLStateTests.cpp +++ b/tests/unit/etl/ETLStateTests.cpp @@ -27,7 +27,6 @@ #include -namespace json = boost::json; using namespace util; using namespace testing; @@ -44,7 +43,7 @@ TEST_F(ETLStateTest, Error) TEST_F(ETLStateTest, NetworkIdValid) { - auto const json = json::parse( + auto const json = boost::json::parse( R"JSON({ "result": { "info": { @@ -61,7 +60,7 @@ TEST_F(ETLStateTest, NetworkIdValid) TEST_F(ETLStateTest, NetworkIdInvalid) { - auto const json = json::parse( + auto const json = boost::json::parse( R"JSON({ "result": { "info": { @@ -78,7 +77,7 @@ TEST_F(ETLStateTest, NetworkIdInvalid) TEST_F(ETLStateTest, ResponseHasError) { - auto const json = json::parse( + auto const json = boost::json::parse( R"JSON({ "error": "error" })JSON" diff --git a/tests/unit/etl/ExtractionTests.cpp b/tests/unit/etl/ExtractionTests.cpp index 5ae691410..6c62b44eb 100644 --- a/tests/unit/etl/ExtractionTests.cpp +++ b/tests/unit/etl/ExtractionTests.cpp @@ -55,9 +55,9 @@ TEST_F(ExtractionModelTests, LedgerDataCopyableAndEquatable) { auto const first = etl::model::LedgerData{ .transactions = - {util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER)}, + {util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER)}, .objects = {util::createObject(), util::createObject(), util::createObject()}, .successors = std::vector{{.firstBook = "first", .bookBase = "base"}}, .edgeKeys = std::vector{"key1", "key2"}, @@ -108,11 +108,11 @@ TEST_F(ExtractionModelTests, LedgerDataCopyableAndEquatable) TEST_F(ExtractionModelTests, TransactionIsEquatable) { - auto const tx = std::vector{util::createTransaction(ripple::TxType::ttNFTOKEN_BURN)}; + auto const tx = std::vector{util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN)}; auto other = tx; EXPECT_EQ(tx, other); - other.push_back(util::createTransaction(ripple::TxType::ttNFTOKEN_ACCEPT_OFFER)); + other.push_back(util::createTransaction(xrpl::TxType::ttNFTOKEN_ACCEPT_OFFER)); EXPECT_NE(tx, other); } @@ -124,7 +124,7 @@ TEST_F(ExtractionModelTests, ObjectCopyableAndEquatable) { auto third = other; - third.key = ripple::uint256{42}; + third.key = xrpl::uint256{42}; EXPECT_NE(obj, third); } { @@ -194,7 +194,7 @@ TEST_F(ExtractionTests, OneTransaction) { using namespace etl::impl; - auto expected = util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER); + auto expected = util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER); auto original = org::xrpl::rpc::v1::TransactionAndMetadata(); auto [metaRaw, txRaw] = util::createTxAndMetaBlobs(); @@ -212,7 +212,7 @@ TEST_F(ExtractionTests, MultipleTransactions) { using namespace etl::impl; - auto expected = util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER); + auto expected = util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER); auto original = org::xrpl::rpc::v1::TransactionAndMetadata(); auto [metaRaw, txRaw] = util::createTxAndMetaBlobs(); @@ -249,8 +249,8 @@ TEST_F(ExtractionTests, OneObject) ); auto res = extractObj(original); - EXPECT_EQ(ripple::strHex(res.key), ripple::strHex(expected.keyRaw)); - EXPECT_EQ(ripple::strHex(res.data), ripple::strHex(expected.dataRaw)); + EXPECT_EQ(xrpl::strHex(res.key), xrpl::strHex(expected.keyRaw)); + EXPECT_EQ(xrpl::strHex(res.data), xrpl::strHex(expected.dataRaw)); EXPECT_EQ(res.predecessor, uint256ToString(data::kLAST_KEY)); EXPECT_EQ(res.successor, uint256ToString(data::kFIRST_KEY)); EXPECT_EQ(res.type, expected.type); @@ -271,8 +271,8 @@ TEST_F(ExtractionTests, OneObjectWithSuccessorAndPredecessor) ); auto res = extractObj(original); - EXPECT_EQ(ripple::strHex(res.key), ripple::strHex(expected.keyRaw)); - EXPECT_EQ(ripple::strHex(res.data), ripple::strHex(expected.dataRaw)); + EXPECT_EQ(xrpl::strHex(res.key), xrpl::strHex(expected.keyRaw)); + EXPECT_EQ(xrpl::strHex(res.data), xrpl::strHex(expected.dataRaw)); EXPECT_EQ(res.predecessor, expected.predecessor); EXPECT_EQ(res.successor, expected.successor); EXPECT_EQ(res.type, expected.type); @@ -300,8 +300,8 @@ TEST_F(ExtractionTests, MultipleObjects) EXPECT_EQ(res.size(), 10); for (auto const& obj : res) { - EXPECT_EQ(ripple::strHex(obj.key), ripple::strHex(expected.keyRaw)); - EXPECT_EQ(ripple::strHex(obj.data), ripple::strHex(expected.dataRaw)); + EXPECT_EQ(xrpl::strHex(obj.key), xrpl::strHex(expected.keyRaw)); + EXPECT_EQ(xrpl::strHex(obj.data), xrpl::strHex(expected.dataRaw)); EXPECT_EQ(obj.predecessor, uint256ToString(data::kLAST_KEY)); EXPECT_EQ(obj.successor, uint256ToString(data::kFIRST_KEY)); EXPECT_EQ(obj.type, expected.type); @@ -318,8 +318,8 @@ TEST_F(ExtractionTests, OneSuccessor) original.set_book_base(expected.bookBase); auto res = extractSuccessor(original); - EXPECT_EQ(ripple::strHex(res.firstBook), ripple::strHex(expected.firstBook)); - EXPECT_EQ(ripple::strHex(res.bookBase), ripple::strHex(expected.bookBase)); + EXPECT_EQ(xrpl::strHex(res.firstBook), xrpl::strHex(expected.firstBook)); + EXPECT_EQ(xrpl::strHex(res.bookBase), xrpl::strHex(expected.bookBase)); } TEST_F(ExtractionTests, MultipleSuccessors) diff --git a/tests/unit/etl/GrpcSourceTests.cpp b/tests/unit/etl/GrpcSourceTests.cpp index 336547059..d1a6e03f3 100644 --- a/tests/unit/etl/GrpcSourceTests.cpp +++ b/tests/unit/etl/GrpcSourceTests.cpp @@ -75,8 +75,8 @@ struct GrpcSourceTests : virtual public ::testing::Test, tests::util::WithMockXr } class KeyStore { - std::vector keys_; - using Store = std::map, std::greater<>>; + std::vector keys_; + using Store = std::map, std::greater<>>; util::Mutex store_; @@ -89,7 +89,7 @@ struct GrpcSourceTests : virtual public ::testing::Test, tests::util::WithMockXr auto store = store_.lock(); for (auto mi = 0uz; mi < markers.size(); ++mi) { for (auto i = 0uz; i < totalPerMarker; ++i) { - auto const mapKey = ripple::strHex(markers.at(mi)).substr(0, 2); + auto const mapKey = xrpl::strHex(markers.at(mi)).substr(0, 2); store->operator[](mapKey).push(keys_.at((mi * totalPerMarker) + i)); } } @@ -100,7 +100,7 @@ struct GrpcSourceTests : virtual public ::testing::Test, tests::util::WithMockXr { auto store = store_.lock(); - auto const mapKey = ripple::strHex(marker).substr(0, 2); + auto const mapKey = xrpl::strHex(marker).substr(0, 2); auto it = store->lower_bound(mapKey); ASSERT(it != store->end(), "Lower bound not found for '{}'", mapKey); @@ -119,7 +119,7 @@ struct GrpcSourceTests : virtual public ::testing::Test, tests::util::WithMockXr { auto store = store_.lock(); - auto const mapKey = ripple::strHex(marker).substr(0, 2); + auto const mapKey = xrpl::strHex(marker).substr(0, 2); auto it = store->lower_bound(mapKey); ASSERT(it != store->end(), "Lower bound not found for '{}'", mapKey); @@ -196,7 +196,7 @@ TEST_F(GrpcSourceLoadInitialLedgerTests, GetLedgerDataNotFound) TEST_F(GrpcSourceLoadInitialLedgerTests, ObserverCalledCorrectly) { - auto const key = ripple::uint256{4}; + auto const key = xrpl::uint256{4}; auto const keyStr = uint256ToString(key); auto const object = createTicketLedgerObject("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", sequence_); auto const objectData = object.getSerializer().peekData(); diff --git a/tests/unit/etl/LedgerPublisherTests.cpp b/tests/unit/etl/LedgerPublisherTests.cpp index e4d422a9d..9062123bc 100644 --- a/tests/unit/etl/LedgerPublisherTests.cpp +++ b/tests/unit/etl/LedgerPublisherTests.cpp @@ -101,7 +101,7 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderWithinAgeLimit) auto dummyState = etl::SystemState{}; auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) .WillOnce(Return(std::vector{})); @@ -145,7 +145,7 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderInRange) auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); backend_->setRange(kSEQ - 1, kSEQ); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); TransactionAndMetadata t1; @@ -180,13 +180,13 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderCloseTimeGreaterThanNow) auto dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, 0); auto const nowPlus10 = system_clock::now() + seconds(10); auto const closeTime = duration_cast(nowPlus10.time_since_epoch()).count() - kRIPPLE_EPOCH_START; - dummyLedgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + dummyLedgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; backend_->setRange(kSEQ - 1, kSEQ); auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); TransactionAndMetadata t1; @@ -260,7 +260,7 @@ TEST_F(ETLLedgerPublisherTest, PublishMultipleTxInOrder) auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); backend_->setRange(kSEQ - 1, kSEQ); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); // t1 index > t2 index @@ -331,9 +331,9 @@ TEST_F(ETLLedgerPublisherTest, PublishMultipleLedgersInQuickSuccession) auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); backend_->setRange(kSEQ - 1, kSEQ + 1); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ + 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ + 1, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) diff --git a/tests/unit/etl/NFTHelpersTests.cpp b/tests/unit/etl/NFTHelpersTests.cpp index 404147044..c546121fc 100644 --- a/tests/unit/etl/NFTHelpersTests.cpp +++ b/tests/unit/etl/NFTHelpersTests.cpp @@ -60,12 +60,12 @@ protected: static void verifyNFTTransactionsData( NFTTransactionsData const& data, - ripple::STTx const& sttx, - ripple::TxMeta const& txMeta, + xrpl::STTx const& sttx, + xrpl::TxMeta const& txMeta, std::string_view nftId ) { - EXPECT_EQ(data.tokenID, ripple::uint256(nftId)); + EXPECT_EQ(data.tokenID, xrpl::uint256(nftId)); EXPECT_EQ(data.ledgerSequence, txMeta.getLgrSeq()); EXPECT_EQ(data.transactionIndex, txMeta.getIndex()); EXPECT_EQ(data.txHash, sttx.getTransactionID()); @@ -74,32 +74,32 @@ protected: static void verifyNFTsData( NFTsData const& data, - ripple::STTx const& sttx, - ripple::TxMeta const& txMeta, + xrpl::STTx const& sttx, + xrpl::TxMeta const& txMeta, std::string_view nftId, std::optional const& owner ) { - EXPECT_EQ(data.tokenID, ripple::uint256(nftId)); + EXPECT_EQ(data.tokenID, xrpl::uint256(nftId)); EXPECT_EQ(data.ledgerSequence, txMeta.getLgrSeq()); EXPECT_EQ(data.transactionIndex, txMeta.getIndex()); if (owner) EXPECT_EQ(data.owner, getAccountIdWithString(*owner)); - if (sttx.getTxnType() == ripple::ttNFTOKEN_MINT || sttx.getTxnType() == ripple::ttNFTOKEN_MODIFY) { + if (sttx.getTxnType() == xrpl::ttNFTOKEN_MINT || sttx.getTxnType() == xrpl::ttNFTOKEN_MODIFY) { EXPECT_TRUE(data.uri.has_value()); - EXPECT_EQ(*data.uri, sttx.getFieldVL(ripple::sfURI)); + EXPECT_EQ(*data.uri, sttx.getFieldVL(xrpl::sfURI)); } else { EXPECT_FALSE(data.uri.has_value()); } - if (sttx.getTxnType() == ripple::ttNFTOKEN_BURN) { + if (sttx.getTxnType() == xrpl::ttNFTOKEN_BURN) { EXPECT_TRUE(data.isBurned); } else { EXPECT_FALSE(data.isBurned); } - if (sttx.getTxnType() == ripple::ttNFTOKEN_MODIFY) { + if (sttx.getTxnType() == xrpl::ttNFTOKEN_MODIFY) { EXPECT_TRUE(data.onlyUriChanged); } else { EXPECT_FALSE(data.onlyUriChanged); @@ -109,16 +109,16 @@ protected: TEST_F(NFTHelpersTest, NFTDataFromFailedTx) { - auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{}); + auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, xrpl::Blob{}); // Inject a failed result - ripple::SerialIter sitMeta(ripple::makeSlice(tx.metadata)); - ripple::STObject objMeta(sitMeta, ripple::sfMetadata); - objMeta.setFieldU8(ripple::sfTransactionResult, ripple::tecINCOMPLETE); + xrpl::SerialIter sitMeta(xrpl::makeSlice(tx.metadata)); + xrpl::STObject objMeta(sitMeta, xrpl::sfMetadata); + objMeta.setFieldU8(xrpl::sfTransactionResult, xrpl::tecINCOMPLETE); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, objMeta.getSerializer().peekData()); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, objMeta.getSerializer().peekData()); auto const [nftTxs, nftDatas] = - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})); + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})); EXPECT_EQ(nftTxs.size(), 0); EXPECT_FALSE(nftDatas); @@ -132,16 +132,16 @@ TEST_F(NFTHelpersTest, NotNFTTx) 123, 1, 4321u, - createPriceDataSeries({createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)}), + createPriceDataSeries({createOraclePriceData(1e3, xrpl::toCurrency("EUR"), xrpl::toCurrency("XRP"), 2)}), kPAGE_INDEX, false, kTX ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); auto const [nftTxs, nftDatas] = - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})); + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})); EXPECT_EQ(nftTxs.size(), 0); EXPECT_FALSE(nftDatas); @@ -150,14 +150,14 @@ TEST_F(NFTHelpersTest, NotNFTTx) TEST_F(NFTHelpersTest, NFTModifyWithURI) { std::string const uri("1234567890A"); - ripple::Blob const uriBlob(uri.begin(), uri.end()); + xrpl::Blob const uriBlob(uri.begin(), uri.end()); auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, uriBlob); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})); + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})); EXPECT_EQ(nftTxs.size(), 1); verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID); @@ -166,9 +166,9 @@ TEST_F(NFTHelpersTest, NFTModifyWithURI) TEST_F(NFTHelpersTest, NFTModifyWithoutURI) { - auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{}); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, xrpl::Blob{}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -179,9 +179,9 @@ TEST_F(NFTHelpersTest, NFTModifyWithoutURI) TEST_F(NFTHelpersTest, NFTMintFromModifiedNode) { auto const tx = createMintNftTxWithMetadata(kACCOUNT, 1, 20, 1, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -194,10 +194,10 @@ TEST_F(NFTHelpersTest, NFTMintCantFindNewNFT) // No NFT added to the page auto const tx = createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, std::nullopt, std::nullopt, kPAGE_INDEX); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -205,10 +205,10 @@ TEST_F(NFTHelpersTest, NFTMintCantFindNewNFT) TEST_F(NFTHelpersTest, NFTMintFromCreatedNode) { std::string const uri("1234567890A"); - ripple::Blob const uriBlob(uri.begin(), uri.end()); + xrpl::Blob const uriBlob(uri.begin(), uri.end()); auto const tx = createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, kNFT_ID, uri, kPAGE_INDEX); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); @@ -220,8 +220,8 @@ TEST_F(NFTHelpersTest, NFTMintFromCreatedNode) TEST_F(NFTHelpersTest, NFTMintWithoutUriField) { auto const tx = createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); @@ -233,11 +233,11 @@ TEST_F(NFTHelpersTest, NFTMintWithoutUriField) TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) { auto const tx = createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -245,9 +245,9 @@ TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode) { auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[1].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[1].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -258,11 +258,11 @@ TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode) TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) { auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -270,10 +270,10 @@ TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromModifiedNode) { auto const tx = createNftBurnTxWithMetadataOfModifiedNode(kACCOUNT, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -284,9 +284,9 @@ TEST_F(NFTHelpersTest, NFTBurnFromModifiedNode) TEST_F(NFTHelpersTest, NFTCancelOffer) { auto const tx = createCancelNftOffersTxWithMetadata(kACCOUNT, 1, 2, std::vector{kNFT_ID, kNFT_ID2}); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 2); @@ -300,8 +300,8 @@ TEST_F(NFTHelpersTest, NFTCancelOfferContainsDuplicateNFTs) auto const tx = createCancelNftOffersTxWithMetadata( kACCOUNT, 1, 2, std::vector{kNFT_ID2, kNFT_ID, kNFT_ID2, kNFT_ID} ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 2); @@ -316,13 +316,13 @@ TEST_F(NFTHelpersTest, UniqueNFTDatas) auto const generateNFTsData = [](char const* nftID, std::uint32_t txIndex) { auto const tx = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 50, nftID, 123, kOFFER1); - ripple::SerialIter s{tx.metadata.data(), tx.metadata.size()}; - ripple::STObject meta{s, ripple::sfMetadata}; - meta.setFieldU32(ripple::sfTransactionIndex, txIndex); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, meta.getSerializer().peekData()); + xrpl::SerialIter s{tx.metadata.data(), tx.metadata.size()}; + xrpl::STObject meta{s, xrpl::sfMetadata}; + meta.setFieldU32(xrpl::sfTransactionIndex, txIndex); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, meta.getSerializer().peekData()); auto const account = getAccountIdWithString(kACCOUNT); - return NFTsData{ripple::uint256(nftID), account, ripple::Blob{}, txMeta}; + return NFTsData{xrpl::uint256(nftID), account, xrpl::Blob{}, txMeta}; }; nftDatas.push_back(generateNFTsData(kNFT_ID, 3)); @@ -340,15 +340,15 @@ TEST_F(NFTHelpersTest, UniqueNFTDatas) EXPECT_EQ(uniqueNFTDatas[1].ledgerSequence, 1); EXPECT_EQ(uniqueNFTDatas[0].transactionIndex, 5); EXPECT_EQ(uniqueNFTDatas[1].transactionIndex, 3); - EXPECT_EQ(uniqueNFTDatas[0].tokenID, ripple::uint256(kNFT_ID2)); - EXPECT_EQ(uniqueNFTDatas[1].tokenID, ripple::uint256(kNFT_ID)); + EXPECT_EQ(uniqueNFTDatas[0].tokenID, xrpl::uint256(kNFT_ID2)); + EXPECT_EQ(uniqueNFTDatas[1].tokenID, xrpl::uint256(kNFT_ID)); } TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) { auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -361,12 +361,12 @@ TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) TEST_F(NFTHelpersTest, NFTAcceptBuyerOfferCheckOfferIDFail) { auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); // inject a different offer id - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -374,8 +374,8 @@ TEST_F(NFTHelpersTest, NFTAcceptBuyerOfferCheckOfferIDFail) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromCreatedNode) { auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -387,8 +387,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromCreatedNode) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromModifiedNode) { auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, false); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -401,10 +401,10 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferCheckFail) { // The only changed nft page is owned by ACCOUNT, thus can't find the new owner auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -412,12 +412,12 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferCheckFail) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferNotInMeta) { auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); // inject a different offer id - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -425,11 +425,11 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferNotInMeta) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferZeroMetaNode) { auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -437,15 +437,15 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferZeroMetaNode) TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) { auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); // The first node is offer, the second is nft page. Change the offer id to something else txMeta.getNodes()[0] - .getField(ripple::sfFinalFields) - .downcast() - .setFieldH256(ripple::sfNFTokenID, ripple::uint256(kNFT_ID2)); + .getField(xrpl::sfFinalFields) + .downcast() + .setFieldH256(xrpl::sfNFTokenID, xrpl::uint256(kNFT_ID2)); EXPECT_THROW( - etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})), + etl::getNFTDataFromTx(txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()})), std::runtime_error ); } @@ -453,8 +453,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) TEST_F(NFTHelpersTest, NFTCreateOffer) { auto const tx = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, 1, kOFFER_ID); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 5, tx.metadata); - auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 5, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -466,8 +466,8 @@ TEST_F(NFTHelpersTest, NFTDataFromLedgerObject) { std::string const url1 = "abcd1"; std::string const url2 = "abcd2"; - ripple::Blob const uri1Blob(url1.begin(), url1.end()); - ripple::Blob const uri2Blob(url2.begin(), url2.end()); + xrpl::Blob const uri1Blob(url1.begin(), url1.end()); + xrpl::Blob const uri2Blob(url2.begin(), url2.end()); auto const account = getAccountIdWithString(kACCOUNT); auto const nftPage = createNftTokenPage({{kNFT_ID, url1}, {kNFT_ID2, url2}}, std::nullopt); @@ -484,14 +484,14 @@ TEST_F(NFTHelpersTest, NFTDataFromLedgerObject) auto const nftDatas = etl::getNFTDataFromObj(kSEQ, key, blob); EXPECT_EQ(nftDatas.size(), 2); - EXPECT_EQ(nftDatas[0].tokenID, ripple::uint256(kNFT_ID)); + EXPECT_EQ(nftDatas[0].tokenID, xrpl::uint256(kNFT_ID)); EXPECT_EQ(*(nftDatas[0].uri), uri1Blob); EXPECT_FALSE(nftDatas[0].onlyUriChanged); EXPECT_EQ(nftDatas[0].owner, account); EXPECT_EQ(nftDatas[0].ledgerSequence, kSEQ); EXPECT_FALSE(nftDatas[0].isBurned); - EXPECT_EQ(nftDatas[1].tokenID, ripple::uint256(kNFT_ID2)); + EXPECT_EQ(nftDatas[1].tokenID, xrpl::uint256(kNFT_ID2)); EXPECT_EQ(*(nftDatas[1].uri), uri2Blob); EXPECT_FALSE(nftDatas[1].onlyUriChanged); EXPECT_EQ(nftDatas[1].owner, account); diff --git a/tests/unit/etl/RegistryTests.cpp b/tests/unit/etl/RegistryTests.cpp index 41382b873..d0eb2edaa 100644 --- a/tests/unit/etl/RegistryTests.cpp +++ b/tests/unit/etl/RegistryTests.cpp @@ -61,7 +61,7 @@ struct Ext4SpecMissing { }; struct Ext4Fixed { - using spec = etl::model::Spec; + using spec = etl::model::Spec; static void onTransaction(uint32_t, etl::model::Transaction const&); @@ -78,7 +78,7 @@ struct Ext6SpecMissing { }; struct Ext6Fixed { - using spec = etl::model::Spec; + using spec = etl::model::Spec; static void onInitialTransaction(uint32_t, etl::model::Transaction const&); @@ -86,11 +86,11 @@ struct Ext6Fixed { struct ExtRealistic { using spec = etl::model::Spec< - ripple::TxType::ttNFTOKEN_BURN, - ripple::TxType::ttNFTOKEN_ACCEPT_OFFER, - ripple::TxType::ttNFTOKEN_CREATE_OFFER, - ripple::TxType::ttNFTOKEN_CANCEL_OFFER, - ripple::TxType::ttNFTOKEN_MINT>; + xrpl::TxType::ttNFTOKEN_BURN, + xrpl::TxType::ttNFTOKEN_ACCEPT_OFFER, + xrpl::TxType::ttNFTOKEN_CREATE_OFFER, + xrpl::TxType::ttNFTOKEN_CANCEL_OFFER, + xrpl::TxType::ttNFTOKEN_MINT>; static void onLedgerData(etl::model::LedgerData const&); @@ -117,12 +117,12 @@ static_assert(SomeExtension); static_assert(not SomeExtension); struct ValidSpec { - using spec = etl::model::Spec; + using spec = etl::model::Spec; }; // invalid spec does not compile: // struct DuplicatesSpec { -// using spec = etl::model::Spec; +// using spec = etl::model::Spec; // }; static_assert(ContainsSpec); @@ -147,15 +147,15 @@ struct MockExtOnObject { }; struct MockExtTransactionNftBurn { - using spec = etl::model::Spec; + using spec = etl::model::Spec; MOCK_METHOD(void, onTransaction, (uint32_t, etl::model::Transaction const&), (const)); }; struct MockExtTransactionNftOffer { using spec = etl::model::Spec< - ripple::TxType::ttNFTOKEN_CREATE_OFFER, - ripple::TxType::ttNFTOKEN_CANCEL_OFFER, - ripple::TxType::ttNFTOKEN_ACCEPT_OFFER>; + xrpl::TxType::ttNFTOKEN_CREATE_OFFER, + xrpl::TxType::ttNFTOKEN_CANCEL_OFFER, + xrpl::TxType::ttNFTOKEN_ACCEPT_OFFER>; MOCK_METHOD(void, onTransaction, (uint32_t, etl::model::Transaction const&), (const)); }; @@ -168,15 +168,15 @@ struct MockExtInitialObjects { }; struct MockExtNftBurn { - using spec = etl::model::Spec; + using spec = etl::model::Spec; MOCK_METHOD(void, onInitialTransaction, (uint32_t, etl::model::Transaction const&), (const)); }; struct MockExtNftOffer { using spec = etl::model::Spec< - ripple::TxType::ttNFTOKEN_CREATE_OFFER, - ripple::TxType::ttNFTOKEN_CANCEL_OFFER, - ripple::TxType::ttNFTOKEN_ACCEPT_OFFER>; + xrpl::TxType::ttNFTOKEN_CREATE_OFFER, + xrpl::TxType::ttNFTOKEN_CANCEL_OFFER, + xrpl::TxType::ttNFTOKEN_ACCEPT_OFFER>; MOCK_METHOD(void, onInitialTransaction, (uint32_t, etl::model::Transaction const&), (const)); }; @@ -212,7 +212,7 @@ struct MockExtOnObjectReadonly { }; struct MockExtTransactionNftBurnReadonly { - using spec = etl::model::Spec; + using spec = etl::model::Spec; MOCK_METHOD(void, onTransaction, (uint32_t, etl::model::Transaction const&), (const)); static bool @@ -243,7 +243,7 @@ struct MockExtInitialObjectsReadonly { }; struct MockExtNftBurnReadonly { - using spec = etl::model::Spec; + using spec = etl::model::Spec; MOCK_METHOD(void, onInitialTransaction, (uint32_t, etl::model::Transaction const&), (const)); static bool @@ -268,9 +268,9 @@ protected: TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForInitialTransaction) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER), }; auto extBurn = MockExtNftBurn{}; @@ -297,9 +297,9 @@ TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForInitialTransaction) TEST_F(RegistryTest, FilteringOfTxWorksCorrectlyForTransaction) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER), }; auto extBurn = MockExtTransactionNftBurn{}; @@ -371,9 +371,9 @@ TEST_F(RegistryTest, ObjectsDispatched) TEST_F(RegistryTest, OnLedgerDataForBatch) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER), }; auto ext = MockExtLedgerData{}; @@ -414,9 +414,9 @@ TEST_F(RegistryTest, InitialDataCorrectOrderOfHookCalls) auto extInitialTransaction = MockExtNftBurn{}; auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER), }; testing::InSequence const seqGuard; @@ -445,9 +445,9 @@ TEST_F(RegistryTest, LedgerDataCorrectOrderOfHookCalls) auto extOnObject = MockExtOnObject{}; auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER), }; auto objects = std::vector{ util::createObject(), @@ -481,8 +481,8 @@ TEST_F(RegistryTest, LedgerDataCorrectOrderOfHookCalls) TEST_F(RegistryTest, ReadonlyModeLedgerDataAllowed) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), }; auto ext = MockExtLedgerDataReadonly{}; @@ -508,8 +508,8 @@ TEST_F(RegistryTest, ReadonlyModeLedgerDataAllowed) TEST_F(RegistryTest, ReadonlyModeTransactionAllowed) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), }; auto extTx = MockExtTransactionNftBurnReadonly{}; @@ -563,8 +563,8 @@ TEST_F(RegistryTest, ReadonlyModeObjectAllowed) TEST_F(RegistryTest, ReadonlyModeInitialDataAllowed) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), }; auto extInitialData = MockExtInitialDataReadonly{}; @@ -590,8 +590,8 @@ TEST_F(RegistryTest, ReadonlyModeInitialDataAllowed) TEST_F(RegistryTest, ReadonlyModeInitialTransactionAllowed) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), }; auto extTx = MockExtNftBurnReadonly{}; @@ -771,7 +771,7 @@ TEST_F(RegistryTest, ReadonlyModeExecutePluralHooksIfAllowedPaths) state_.isWriting = false; auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), }; auto objects = std::vector{ util::createObject(), @@ -814,7 +814,7 @@ TEST_F(RegistryTest, ReadonlyModeExecutePluralHooksIfAllowedPaths) TEST_F(RegistryTest, ReadonlyModeExecuteByOneHooksIfAllowedPaths) { struct ExtWithBothHooksAndAllowReadonly { - using spec = etl::model::Spec; + using spec = etl::model::Spec; MOCK_METHOD(void, onObject, (uint32_t, etl::model::Object const&), (const)); MOCK_METHOD(void, onInitialObject, (uint32_t, etl::model::Object const&), (const)); @@ -832,7 +832,7 @@ TEST_F(RegistryTest, ReadonlyModeExecuteByOneHooksIfAllowedPaths) state_.isWriting = false; auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), }; auto objects = std::vector{ util::createObject(), diff --git a/tests/unit/etl/TaskManagerTests.cpp b/tests/unit/etl/TaskManagerTests.cpp index 78bb84d49..abdcc1089 100644 --- a/tests/unit/etl/TaskManagerTests.cpp +++ b/tests/unit/etl/TaskManagerTests.cpp @@ -63,7 +63,7 @@ struct MockExtractor : etl::ExtractorInterface { struct MockLoader : etl::LoaderInterface { using ExpectedType = std::expected; MOCK_METHOD(ExpectedType, load, (LedgerData const&), (override)); - MOCK_METHOD(std::optional, loadInitialLedger, (LedgerData const&), (override)); + MOCK_METHOD(std::optional, loadInitialLedger, (LedgerData const&), (override)); }; struct MockMonitor : etl::MonitorInterface { diff --git a/tests/unit/etl/ext/CoreTests.cpp b/tests/unit/etl/ext/CoreTests.cpp index cb0807a3a..d73d038d2 100644 --- a/tests/unit/etl/ext/CoreTests.cpp +++ b/tests/unit/etl/ext/CoreTests.cpp @@ -42,9 +42,9 @@ auto createTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER), }; auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); diff --git a/tests/unit/etl/ext/MPTTests.cpp b/tests/unit/etl/ext/MPTTests.cpp index af6b4d158..2299168f3 100644 --- a/tests/unit/etl/ext/MPTTests.cpp +++ b/tests/unit/etl/ext/MPTTests.cpp @@ -67,10 +67,10 @@ auto createTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE), // not AUTHORIZE so will not be written - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttAMM_CREATE), // not MPT - will be filtered - util::createTransaction(ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE), // not unique - will be filtered + util::createTransaction(xrpl::TxType::ttMPTOKEN_ISSUANCE_CREATE), // not AUTHORIZE so will not be written + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), + util::createTransaction(xrpl::TxType::ttAMM_CREATE), // not MPT - will be filtered + util::createTransaction(xrpl::TxType::ttMPTOKEN_ISSUANCE_CREATE), // not unique - will be filtered }; auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); @@ -89,9 +89,9 @@ auto createMultipleHoldersTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH2, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH3, kTXN_META, kTXN_HEX) + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH2, kTXN_META, kTXN_HEX), + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH3, kTXN_META, kTXN_HEX) }; auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); diff --git a/tests/unit/etl/ext/NFTTests.cpp b/tests/unit/etl/ext/NFTTests.cpp index c051f0877..85bc5eae9 100644 --- a/tests/unit/etl/ext/NFTTests.cpp +++ b/tests/unit/etl/ext/NFTTests.cpp @@ -228,10 +228,10 @@ auto createTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN, kHASH2, kTXN_META2, kTXN_HEX2), - util::createTransaction(ripple::TxType::ttAMM_CREATE), // not NFT - will be filtered - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), // not unique - will be filtered + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN, kHASH2, kTXN_META2, kTXN_HEX2), + util::createTransaction(xrpl::TxType::ttAMM_CREATE), // not NFT - will be filtered + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), // not unique - will be filtered }; auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); diff --git a/tests/unit/etl/ext/SuccessorTests.cpp b/tests/unit/etl/ext/SuccessorTests.cpp index 9f5b5b7dc..e609a630c 100644 --- a/tests/unit/etl/ext/SuccessorTests.cpp +++ b/tests/unit/etl/ext/SuccessorTests.cpp @@ -55,9 +55,9 @@ auto createTestData(std::vector objects) { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_CREATE_OFFER), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_CREATE_OFFER), }; auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); @@ -73,7 +73,7 @@ createTestData(std::vector objects) } [[maybe_unused]] auto -createInitialTestData(std::vector edgeKeys) +createInitialTestData(std::vector edgeKeys) { // initial data expects objects to be empty as well as non-empty edgeKeys ASSERT(not edgeKeys.empty(), "Initial data requires edgeKeys"); @@ -368,11 +368,11 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndNoSuccessor { using namespace etl::model; - auto const firstKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); - auto const secondKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + auto const firstKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + auto const secondKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto const data = createInitialTestData({firstKey, secondKey}); - auto successorChain = std::queue(); + auto successorChain = std::queue(); successorChain.push(firstKey); successorChain.push(secondKey); @@ -395,7 +395,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndNoSuccessor EXPECT_CALL(*backend_, writeSuccessor(uint256ToString(secondKey), kSEQ, uint256ToString(data::kLAST_KEY))); for (auto const& key : data.edgeKeys.value()) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*xrpl::uint256::fromVoidChecked(key), kSEQ)) .InSequence(inSeq) .WillOnce(testing::Return(std::nullopt)); } @@ -407,11 +407,11 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndSuccessorsF { using namespace etl::model; - auto const firstKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); - auto const secondKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + auto const firstKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + auto const secondKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto const data = createInitialTestData({firstKey, secondKey}); - auto successorChain = std::queue(); + auto successorChain = std::queue(); successorChain.push(firstKey); successorChain.push(secondKey); @@ -434,7 +434,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndSuccessorsF EXPECT_CALL(*backend_, writeSuccessor(uint256ToString(secondKey), kSEQ, uint256ToString(data::kLAST_KEY))); for (auto const& key : data.edgeKeys.value()) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*xrpl::uint256::fromVoidChecked(key), kSEQ)) .InSequence(inSeq) .WillOnce(testing::Return(data::LedgerObject{.key = firstKey, .blob = {}})); EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSEQ, uint256ToString(firstKey))); @@ -447,11 +447,11 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsAndBookDirAndSuccessorsForE { using namespace etl::model; - auto const firstKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); - auto const secondKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + auto const firstKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + auto const secondKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto const data = createInitialTestData({firstKey, secondKey}); - auto successorChain = std::queue(); + auto successorChain = std::queue(); successorChain.push(firstKey); successorChain.push(secondKey); @@ -484,7 +484,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsAndBookDirAndSuccessorsForE ); // Called once because firstKey returned repeatedly above for (auto const& key : data.edgeKeys.value()) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*xrpl::uint256::fromVoidChecked(key), kSEQ)) .InSequence(inSeq) .WillOnce(testing::Return(data::LedgerObject{.key = firstKey, .blob = {'1'}})); EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSEQ, uint256ToString(firstKey))).InSequence(inSeq); @@ -525,7 +525,7 @@ TEST_F(SuccessorExtTests, OnInitialObjectsWithNonEmptyLastKey) using namespace etl::model; auto const lastKey = - uint256ToString(ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960D")); + uint256ToString(xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960D")); auto const data = std::vector{ util::createObject( Object::ModType::Created, "B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E" @@ -629,8 +629,8 @@ TEST_F(SuccessorExtAssertTests, OnInitialDataIsFullWithEdgeKeysButHasObjects) { using namespace etl::model; - auto const firstKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); - auto const secondKey = ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + auto const firstKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + auto const secondKey = xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto data = createInitialTestData({firstKey, secondKey}); data.objects = {util::createObject()}; diff --git a/tests/unit/etlng/LedgerPublisherTests.cpp b/tests/unit/etlng/LedgerPublisherTests.cpp index 808401a44..4a13ad60d 100644 --- a/tests/unit/etlng/LedgerPublisherTests.cpp +++ b/tests/unit/etlng/LedgerPublisherTests.cpp @@ -107,7 +107,7 @@ TEST_F(ETLLedgerPublisherNgTest, PublishLedgerHeaderWithinAgeLimit) EXPECT_TRUE(publisher.getLastPublishedSequence()); EXPECT_EQ(publisher.getLastPublishedSequence().value(), kSEQ); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) .WillOnce(Return(std::vector{})); @@ -145,7 +145,7 @@ TEST_F(ETLLedgerPublisherNgTest, PublishLedgerHeaderInRange) publisher.publish(dummyLedgerHeader); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); TransactionAndMetadata t1; @@ -178,14 +178,14 @@ TEST_F(ETLLedgerPublisherNgTest, PublishLedgerHeaderCloseTimeGreaterThanNow) auto dummyLedgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ, 0); auto const nowPlus10 = system_clock::now() + seconds(10); auto const closeTime = duration_cast(nowPlus10.time_since_epoch()).count() - kRIPPLE_EPOCH_START; - dummyLedgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + dummyLedgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; backend_->setRange(kSEQ - 1, kSEQ); auto publisher = etlng::impl::LedgerPublisher(ctx_, backend_, mockSubscriptionManagerPtr, dummyState); publisher.publish(dummyLedgerHeader); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); TransactionAndMetadata t1; @@ -259,7 +259,7 @@ TEST_F(ETLLedgerPublisherNgTest, PublishMultipleTxInOrder) publisher.publish(dummyLedgerHeader); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); // t1 index > t2 index @@ -333,9 +333,9 @@ TEST_F(ETLLedgerPublisherNgTest, PublishMultipleLedgersInQuickSuccession) publisher.publish(dummyLedgerHeader1); publisher.publish(dummyLedgerHeader2); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ + 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ + 1, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSEQ, _)) diff --git a/tests/unit/feed/BookChangesFeedTests.cpp b/tests/unit/feed/BookChangesFeedTests.cpp index 8fbe96adf..1ad0491a7 100644 --- a/tests/unit/feed/BookChangesFeedTests.cpp +++ b/tests/unit/feed/BookChangesFeedTests.cpp @@ -53,10 +53,10 @@ TEST_F(FeedBookChangeTest, Pub) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 32); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + xrpl::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); diff --git a/tests/unit/feed/ForwardFeedTests.cpp b/tests/unit/feed/ForwardFeedTests.cpp index a1056cf96..85434ebae 100644 --- a/tests/unit/feed/ForwardFeedTests.cpp +++ b/tests/unit/feed/ForwardFeedTests.cpp @@ -29,7 +29,6 @@ #include using namespace feed::impl; -namespace json = boost::json; using namespace util::prometheus; namespace { @@ -53,7 +52,7 @@ TEST_F(FeedForwardTest, Pub) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 1); - auto const json = json::parse(kFEED).as_object(); + auto const json = boost::json::parse(kFEED).as_object(); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED))).Times(1); testFeedPtr->pub(json); @@ -69,7 +68,7 @@ TEST_F(FeedForwardTest, AutoDisconnect) testFeedPtr->sub(sessionPtr); EXPECT_EQ(testFeedPtr->count(), 1); - auto const json = json::parse(kFEED).as_object(); + auto const json = boost::json::parse(kFEED).as_object(); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED))); testFeedPtr->pub(json); diff --git a/tests/unit/feed/LedgerFeedTests.cpp b/tests/unit/feed/LedgerFeedTests.cpp index b6e509969..439151e8a 100644 --- a/tests/unit/feed/LedgerFeedTests.cpp +++ b/tests/unit/feed/LedgerFeedTests.cpp @@ -35,7 +35,6 @@ constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF2 } // namespace using namespace feed::impl; -namespace json = boost::json; using namespace testing; using FeedLedgerTest = FeedBaseTest; @@ -68,7 +67,7 @@ TEST_F(FeedLedgerTest, SubPub) EXPECT_CALL(*mockSessionPtr, onDisconnect); auto res = testFeedPtr->sub(yield, backend_, sessionPtr, networkID); // check the response - EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE)); + EXPECT_EQ(res, boost::json::parse(kLEDGER_RESPONSE)); }); ioContext.run(); EXPECT_EQ(testFeedPtr->count(), 1); @@ -90,7 +89,7 @@ TEST_F(FeedLedgerTest, SubPub) // test publish EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kLEDGER_PUB))).Times(1); auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; testFeedPtr->pub(ledgerHeader2, fee2, "10-31", 8, networkID); @@ -128,7 +127,7 @@ TEST_F(FeedLedgerTest, AutoDisconnect) util::spawn(ioContext, [this](boost::asio::yield_context yield) { auto res = testFeedPtr->sub(yield, backend_, sessionPtr, networkID); // check the response - EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE)); + EXPECT_EQ(res, boost::json::parse(kLEDGER_RESPONSE)); }); ioContext.run(); @@ -142,7 +141,7 @@ TEST_F(FeedLedgerTest, AutoDisconnect) EXPECT_EQ(testFeedPtr->count(), 0); auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; // no error testFeedPtr->pub(ledgerHeader2, fee2, "10-31", 8, networkID); diff --git a/tests/unit/feed/ProposedTransactionFeedTests.cpp b/tests/unit/feed/ProposedTransactionFeedTests.cpp index 92a934f75..dd6b8c1fe 100644 --- a/tests/unit/feed/ProposedTransactionFeedTests.cpp +++ b/tests/unit/feed/ProposedTransactionFeedTests.cpp @@ -58,7 +58,6 @@ constexpr auto kDUMMY_TRANSACTION = } // namespace using namespace feed::impl; -namespace json = boost::json; using namespace util::prometheus; using FeedProposedTransactionTest = FeedBaseTest; @@ -70,12 +69,12 @@ TEST_F(FeedProposedTransactionTest, ProposedTransaction) EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 0); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransaction) @@ -95,13 +94,13 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransaction) EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); // unsub testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); } TEST_F(FeedProposedTransactionTest, SubStreamAndAccount) @@ -116,20 +115,20 @@ TEST_F(FeedProposedTransactionTest, SubStreamAndAccount) EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))).Times(2); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); // unsub testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); // unsub transaction testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 0); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate) @@ -143,19 +142,19 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate) EXPECT_EQ(testFeedPtr->accountSubCount(), 2); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); // unsub account1 testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); // unsub account2 testFeedPtr->unsub(account2, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object()); + testFeedPtr->pub(boost::json::parse(kDUMMY_TRANSACTION).get_object()); } TEST_F(FeedProposedTransactionTest, Count) diff --git a/tests/unit/feed/SubscriptionManagerTests.cpp b/tests/unit/feed/SubscriptionManagerTests.cpp index 5ea968d05..a47535aca 100644 --- a/tests/unit/feed/SubscriptionManagerTests.cpp +++ b/tests/unit/feed/SubscriptionManagerTests.cpp @@ -58,7 +58,6 @@ constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF2 } // namespace -namespace json = boost::json; using namespace feed; using namespace feed::impl; using namespace data; @@ -101,8 +100,8 @@ TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtx) EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(testing::AtMost(2)); - subscriptionManagerPtr_->forwardManifest(json::parse(kJSON_MANIFEST).get_object()); - subscriptionManagerPtr_->forwardValidation(json::parse(kJSON_VALIDATION).get_object()); + subscriptionManagerPtr_->forwardManifest(boost::json::parse(kJSON_MANIFEST).get_object()); + subscriptionManagerPtr_->forwardValidation(boost::json::parse(kJSON_VALIDATION).get_object()); } TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtxSessionDieEarly) @@ -115,8 +114,8 @@ TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtxSessionDieEarly) EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(0); session_.reset(); - subscriptionManagerPtr_->forwardManifest(json::parse(R"JSON({"manifest": "test"})JSON").get_object()); - subscriptionManagerPtr_->forwardValidation(json::parse(R"JSON({"validation": "test"})JSON").get_object()); + subscriptionManagerPtr_->forwardManifest(boost::json::parse(R"JSON({"manifest": "test"})JSON").get_object()); + subscriptionManagerPtr_->forwardValidation(boost::json::parse(R"JSON({"validation": "test"})JSON").get_object()); } TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) @@ -165,10 +164,10 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) subscriptionManagerPtr_->subProposedAccount(account, session1); subscriptionManagerPtr_->subProposedAccount(account, session2); auto const issue1 = getIssue(kCURRENCY, kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; subscriptionManagerPtr_->subBook(book, session1); subscriptionManagerPtr_->subBook(book, session2); - EXPECT_EQ(subscriptionManagerPtr_->report(), json::parse(kREPORT_RETURN)); + EXPECT_EQ(subscriptionManagerPtr_->report(), boost::json::parse(kREPORT_RETURN)); // count down when unsub manually subscriptionManagerPtr_->unsubBookChanges(session1); @@ -184,7 +183,7 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) auto const account2 = getAccountIdWithString(kACCOUNT2); subscriptionManagerPtr_->unsubAccount(account2, session1); subscriptionManagerPtr_->unsubProposedAccount(account2, session1); - auto checkResult = [](json::object reportReturn, int result) { + auto checkResult = [](boost::json::object reportReturn, int result) { EXPECT_EQ(reportReturn["book_changes"], result); EXPECT_EQ(reportReturn["validations"], result); EXPECT_EQ(reportReturn["transactions_proposed"], result); @@ -208,11 +207,11 @@ TEST_F(SubscriptionManagerTest, ManifestTest) EXPECT_CALL(*sessionPtr_, onDisconnect); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_MANIFEST))); subscriptionManagerPtr_->subManifest(session_); - subscriptionManagerPtr_->forwardManifest(json::parse(kDUMMY_MANIFEST).get_object()); + subscriptionManagerPtr_->forwardManifest(boost::json::parse(kDUMMY_MANIFEST).get_object()); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_MANIFEST))).Times(0); subscriptionManagerPtr_->unsubManifest(session_); - subscriptionManagerPtr_->forwardManifest(json::parse(kDUMMY_MANIFEST).get_object()); + subscriptionManagerPtr_->forwardManifest(boost::json::parse(kDUMMY_MANIFEST).get_object()); } TEST_F(SubscriptionManagerTest, ValidationTest) @@ -221,11 +220,11 @@ TEST_F(SubscriptionManagerTest, ValidationTest) EXPECT_CALL(*sessionPtr_, onDisconnect); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY))); subscriptionManagerPtr_->subValidation(session_); - subscriptionManagerPtr_->forwardValidation(json::parse(kDUMMY).get_object()); + subscriptionManagerPtr_->forwardValidation(boost::json::parse(kDUMMY).get_object()); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY))).Times(0); subscriptionManagerPtr_->unsubValidation(session_); - subscriptionManagerPtr_->forwardValidation(json::parse(kDUMMY).get_object()); + subscriptionManagerPtr_->forwardValidation(boost::json::parse(kDUMMY).get_object()); } TEST_F(SubscriptionManagerTest, BookChangesTest) @@ -237,10 +236,10 @@ TEST_F(SubscriptionManagerTest, BookChangesTest) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 32); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + xrpl::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); static constexpr auto kBOOK_CHANGE_PUBLISH = @@ -300,14 +299,14 @@ TEST_F(SubscriptionManagerTest, LedgerTest) EXPECT_CALL(*sessionPtr_, onDisconnect); auto const res = subscriptionManagerPtr_->subLedger(yield, session_); // check the response - EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE)); + EXPECT_EQ(res, boost::json::parse(kLEDGER_RESPONSE)); }); ctx.run(); EXPECT_EQ(subscriptionManagerPtr_->report()["ledger"], 1); // test publish auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; static constexpr auto kLEDGER_PUB = R"JSON({ @@ -334,7 +333,7 @@ TEST_F(SubscriptionManagerTest, TransactionTest) { auto const issue1 = getIssue(kCURRENCY, kISSUER); auto const account = getAccountIdWithString(kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*sessionPtr_, onDisconnect).Times(3); subscriptionManagerPtr_->subBook(book, session_); subscriptionManagerPtr_->subTransactions(session_); @@ -487,7 +486,7 @@ TEST_F(SubscriptionManagerTest, ProposedTransactionTest) })JSON"; EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_TRANSACTION))).Times(2); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(2); - subscriptionManagerPtr_->forwardProposedTransaction(json::parse(kDUMMY_TRANSACTION).get_object()); + subscriptionManagerPtr_->forwardProposedTransaction(boost::json::parse(kDUMMY_TRANSACTION).get_object()); auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); diff --git a/tests/unit/feed/TransactionFeedTests.cpp b/tests/unit/feed/TransactionFeedTests.cpp index 673f66329..21cad6cc4 100644 --- a/tests/unit/feed/TransactionFeedTests.cpp +++ b/tests/unit/feed/TransactionFeedTests.cpp @@ -239,7 +239,7 @@ TEST_F(FeedTransactionTest, SubTransactionV1) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -261,7 +261,7 @@ TEST_F(FeedTransactionTest, SubTransactionForProposedTx) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -282,7 +282,7 @@ TEST_F(FeedTransactionTest, SubTransactionV2) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -308,7 +308,7 @@ TEST_F(FeedTransactionTest, SubAccountV1) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -334,7 +334,7 @@ TEST_F(FeedTransactionTest, SubForProposedAccount) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -357,7 +357,7 @@ TEST_F(FeedTransactionTest, SubAccountV2) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -384,7 +384,7 @@ TEST_F(FeedTransactionTest, SubBothTransactionAndAccount) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -404,7 +404,7 @@ TEST_F(FeedTransactionTest, SubBothTransactionAndAccount) TEST_F(FeedTransactionTest, SubBookV1) { auto const issue1 = getIssue(kCURRENCY, kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(book, sessionPtr); @@ -593,7 +593,7 @@ TEST_F(FeedTransactionTest, SubBookV1) TEST_F(FeedTransactionTest, SubBookV2) { auto const issue1 = getIssue(kCURRENCY, kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(book, sessionPtr); @@ -686,7 +686,7 @@ TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -723,7 +723,7 @@ TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -757,7 +757,7 @@ TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -816,7 +816,7 @@ TEST_F(FeedTransactionTest, SubRepeat) EXPECT_EQ(testFeedPtr->accountSubCount(), 0); auto const issue1 = getIssue(kCURRENCY, kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr, onDisconnect); testFeedPtr->sub(book, sessionPtr); @@ -841,32 +841,32 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); + xrpl::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STArray const metaArray{0}; - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 22); + xrpl::STArray const metaArray{0}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 22); trans1.metadata = metaObj.getSerializer().peekData(); - ripple::STObject line(ripple::sfIndexes); - line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE); - line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false)); - line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false)); - line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, 0); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, 0); auto const issue2 = getIssue(kCURRENCY, kISSUER); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(issue2, 100)); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(issue2, 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); auto const issueAccount = getAccountIdWithString(kISSUER); - auto const kk = ripple::keylet::account(issueAccount).key; + auto const kk = xrpl::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); + xrpl::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -976,31 +976,31 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); + xrpl::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STArray const metaArray{0}; - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 22); + xrpl::STArray const metaArray{0}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 22); trans1.metadata = metaObj.getSerializer().peekData(); - ripple::STObject line(ripple::sfIndexes); - line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE); - line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false)); - line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false)); - line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100)); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, xrpl::lsfHighFreeze); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(getIssue(kCURRENCY, kISSUER), 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); auto const issueAccount = getAccountIdWithString(kISSUER); - auto const kk = ripple::keylet::account(issueAccount).key; + auto const kk = xrpl::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); + xrpl::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -1016,32 +1016,31 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); + xrpl::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STArray const metaArray{0}; - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 22); + xrpl::STArray const metaArray{0}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 22); trans1.metadata = metaObj.getSerializer().peekData(); - ripple::STObject line(ripple::sfIndexes); - line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE); - line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false)); - line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false)); - line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, xrpl::lsfHighFreeze); auto const issueAccount = getAccountIdWithString(kISSUER); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100)); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(getIssue(kCURRENCY, kISSUER), 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const kk = ripple::keylet::account(issueAccount).key; + auto const kk = xrpl::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = - createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + xrpl::STObject const accountRoot = createAccountRootObject(kISSUER, xrpl::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -1063,7 +1062,7 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -1090,7 +1089,7 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidated) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -1112,7 +1111,7 @@ TEST_F(FeedTransactionTest, SubProposedDisconnect) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -1135,7 +1134,7 @@ TEST_F(FeedTransactionTest, SubProposedAccountDisconnect) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData(); @@ -1157,37 +1156,37 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = + xrpl::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STArray const metaArray{0}; - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 22); + xrpl::STArray const metaArray{0}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 22); trans1.metadata = metaObj.getSerializer().peekData(); - ripple::STObject line(ripple::sfIndexes); - line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE); - line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false)); - line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false)); - line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, 0); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, 0); auto const issue2 = getIssue(kLPTOKEN_CURRENCY, kAMM_ACCOUNT); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(issue2, 100)); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(issue2, 100)); EXPECT_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .Times(2) .WillRepeatedly(testing::Return(line.getSerializer().peekData())); - auto const ammID = ripple::uint256{54321}; + auto const ammID = xrpl::uint256{54321}; // create an amm account because in `accountHolds` checks for the ammID auto const ammAccount = getAccountIdWithString(kAMM_ACCOUNT); - auto const kk = ripple::keylet::account(ammAccount).key; - ripple::STObject const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 1, 10, 2, kTXN_ID, 3, 0, ammID); + auto const kk = xrpl::keylet::account(ammAccount).key; + xrpl::STObject const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 1, 10, 2, kTXN_ID, 3, 0, ammID); EXPECT_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .Times(2) .WillRepeatedly(testing::Return(ammAccountRoot.getSerializer().peekData())); @@ -1233,15 +1232,14 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)) .WillOnce(testing::Return(true)); - auto const ammObj = - createAmmObject(kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), kCURRENCY, kISSUER); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_)) + auto const ammObj = createAmmObject(kAMM_ACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), kCURRENCY, kISSUER); + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amm(ammID).key, testing::_, testing::_)) .WillOnce(testing::Return(ammObj.getSerializer().peekData())); // create the issuer account that enacted global freeze auto const issuerAccount = getAccountIdWithString(kISSUER); - ripple::STObject const issuerAccountRoot = createAccountRootObject(kISSUER, 4194304, 1, 10, 2, kTXN_ID, 3); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuerAccount).key, testing::_, testing::_)) + xrpl::STObject const issuerAccountRoot = createAccountRootObject(kISSUER, 4194304, 1, 10, 2, kTXN_ID, 3); + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(issuerAccount).key, testing::_, testing::_)) .WillOnce(testing::Return(issuerAccountRoot.getSerializer().peekData())); testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID); @@ -1363,7 +1361,7 @@ TEST_F(FeedTransactionTest, PublishesMPTokenAuthorizeTx) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); // The issuance ID that this transaction is authorizing - auto const mptIssuanceID = ripple::makeMptID(1, getAccountIdWithString(kACCOUNT1)); + auto const mptIssuanceID = xrpl::makeMptID(1, getAccountIdWithString(kACCOUNT1)); auto const trans = createMPTokenAuthorizeTxWithMetadata(kACCOUNT1, mptIssuanceID, 15, 5); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); @@ -1405,7 +1403,7 @@ TEST_F(TransactionFeedMockPrometheusTest, subUnsub) testFeedPtr_->unsub(account, sessionPtr_); auto const issue1 = getIssue(kCURRENCY, kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; EXPECT_CALL(*mockSessionPtr_, onDisconnect); testFeedPtr_->sub(book, sessionPtr_); testFeedPtr_->unsub(book, sessionPtr_); @@ -1435,7 +1433,7 @@ TEST_F(TransactionFeedMockPrometheusTest, AutoDisconnect) testFeedPtr_->sub(account, sessionPtr_); auto const issue1 = getIssue(kCURRENCY, kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; testFeedPtr_->sub(book, sessionPtr_); // Emulate onDisconnect signal is called diff --git a/tests/unit/rpc/APIVersionTests.cpp b/tests/unit/rpc/APIVersionTests.cpp index b02637b72..14ec31097 100644 --- a/tests/unit/rpc/APIVersionTests.cpp +++ b/tests/unit/rpc/APIVersionTests.cpp @@ -35,7 +35,6 @@ constexpr auto kMAX_API_VERSION = 10u; using namespace util::config; using namespace rpc::impl; -namespace json = boost::json; class RPCAPIVersionTest : public virtual ::testing::Test { protected: @@ -44,35 +43,35 @@ protected: TEST_F(RPCAPIVersionTest, ReturnsDefaultVersionIfNotSpecified) { - auto ver = parser_.parse(json::parse("{}").as_object()); + auto ver = parser_.parse(boost::json::parse("{}").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), kDEFAULT_API_VERSION); } TEST_F(RPCAPIVersionTest, ReturnsErrorIfVersionHigherThanMaxSupported) { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": 11})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": 11})JSON").as_object()); EXPECT_FALSE(ver); } TEST_F(RPCAPIVersionTest, ReturnsErrorIfVersionLowerThanMinSupported) { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": 1})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": 1})JSON").as_object()); EXPECT_FALSE(ver); } TEST_F(RPCAPIVersionTest, ReturnsErrorOnWrongType) { { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": null})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": null})JSON").as_object()); EXPECT_FALSE(ver); } { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": "5"})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": "5"})JSON").as_object()); EXPECT_FALSE(ver); } { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": "wrong"})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": "wrong"})JSON").as_object()); EXPECT_FALSE(ver); } } @@ -80,17 +79,17 @@ TEST_F(RPCAPIVersionTest, ReturnsErrorOnWrongType) TEST_F(RPCAPIVersionTest, ReturnsParsedVersionIfAllPreconditionsAreMet) { { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": 2})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": 2})JSON").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), 2u); } { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": 10})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": 10})JSON").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), 10u); } { - auto ver = parser_.parse(json::parse(R"JSON({"api_version": 5})JSON").as_object()); + auto ver = parser_.parse(boost::json::parse(R"JSON({"api_version": 5})JSON").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), 5u); } @@ -107,31 +106,31 @@ TEST_F(RPCAPIVersionTest, GetsValuesFromConfigCorrectly) ProductionAPIVersionParser const configuredParser{cfg.getObject("api_version")}; { - auto ver = configuredParser.parse(json::parse(R"JSON({"api_version": 2})JSON").as_object()); + auto ver = configuredParser.parse(boost::json::parse(R"JSON({"api_version": 2})JSON").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), 2u); } { - auto ver = configuredParser.parse(json::parse(R"JSON({"api_version": 10})JSON").as_object()); + auto ver = configuredParser.parse(boost::json::parse(R"JSON({"api_version": 10})JSON").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), 10u); } { - auto ver = configuredParser.parse(json::parse(R"JSON({"api_version": 5})JSON").as_object()); + auto ver = configuredParser.parse(boost::json::parse(R"JSON({"api_version": 5})JSON").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), 5u); } { - auto ver = configuredParser.parse(json::parse(R"JSON({})JSON").as_object()); + auto ver = configuredParser.parse(boost::json::parse(R"JSON({})JSON").as_object()); EXPECT_TRUE(ver); EXPECT_EQ(ver.value(), kDEFAULT_API_VERSION); } { - auto ver = configuredParser.parse(json::parse(R"JSON({"api_version": 11})JSON").as_object()); + auto ver = configuredParser.parse(boost::json::parse(R"JSON({"api_version": 11})JSON").as_object()); EXPECT_FALSE(ver); } { - auto ver = configuredParser.parse(json::parse(R"JSON({"api_version": 1})JSON").as_object()); + auto ver = configuredParser.parse(boost::json::parse(R"JSON({"api_version": 1})JSON").as_object()); EXPECT_FALSE(ver); } } diff --git a/tests/unit/rpc/AmendmentsTests.cpp b/tests/unit/rpc/AmendmentsTests.cpp index 16fa85ba9..635763443 100644 --- a/tests/unit/rpc/AmendmentsTests.cpp +++ b/tests/unit/rpc/AmendmentsTests.cpp @@ -28,7 +28,7 @@ TEST(RPCAmendmentsTest, GenerateAmendmentId) { // https://xrpl.org/known-amendments.html#disallowincoming refer to the published id EXPECT_EQ( - ripple::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF"), + xrpl::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF"), Amendments::GetAmendmentId("DisallowIncoming") ); } diff --git a/tests/unit/rpc/BaseTests.cpp b/tests/unit/rpc/BaseTests.cpp index 74a148493..f78089aa3 100644 --- a/tests/unit/rpc/BaseTests.cpp +++ b/tests/unit/rpc/BaseTests.cpp @@ -47,20 +47,18 @@ using namespace rpc::validation; using namespace rpc::meta; using namespace rpc::modifiers; -namespace json = boost::json; - class RPCBaseTest : public virtual ::testing::Test {}; TEST_F(RPCBaseTest, CheckTypeString) { - auto const jString = json::value("a string"); + auto const jString = boost::json::value("a string"); ASSERT_TRUE(checkType(jString)); ASSERT_FALSE(checkType(jString)); } TEST_F(RPCBaseTest, CheckTypeUint) { - auto const jUint = json::value(123u); + auto const jUint = boost::json::value(123u); ASSERT_TRUE(checkType(jUint)); ASSERT_TRUE(checkType(jUint)); ASSERT_FALSE(checkType(jUint)); @@ -68,12 +66,12 @@ TEST_F(RPCBaseTest, CheckTypeUint) TEST_F(RPCBaseTest, CheckTypeInt) { - auto jInt = json::value(123); + auto jInt = boost::json::value(123); ASSERT_TRUE(checkType(jInt)); ASSERT_TRUE(checkType(jInt)); ASSERT_FALSE(checkType(jInt)); - jInt = json::value(-123); + jInt = boost::json::value(-123); ASSERT_TRUE(checkType(jInt)); ASSERT_FALSE(checkType(jInt)); // Unsigned can't be negative ASSERT_FALSE(checkType(jInt)); @@ -81,14 +79,14 @@ TEST_F(RPCBaseTest, CheckTypeInt) TEST_F(RPCBaseTest, CheckTypeBool) { - auto const jBool = json::value(true); + auto const jBool = boost::json::value(true); ASSERT_TRUE(checkType(jBool)); ASSERT_FALSE(checkType(jBool)); } TEST_F(RPCBaseTest, CheckTypeDouble) { - auto const jDouble = json::value(0.123); + auto const jDouble = boost::json::value(0.123); ASSERT_TRUE(checkType(jDouble)); ASSERT_TRUE(checkType(jDouble)); ASSERT_FALSE(checkType(jDouble)); @@ -96,50 +94,50 @@ TEST_F(RPCBaseTest, CheckTypeDouble) TEST_F(RPCBaseTest, CheckTypeArray) { - auto const jArr = json::value({1, 2, 3}); - ASSERT_TRUE(checkType(jArr)); + auto const jArr = boost::json::value({1, 2, 3}); + ASSERT_TRUE(checkType(jArr)); ASSERT_FALSE(checkType(jArr)); } TEST_F(RPCBaseTest, CheckTypeAndClampValueUnchanged) { - auto jUint = json::value(123u); + auto jUint = boost::json::value(123u); ASSERT_TRUE(checkTypeAndClamp(jUint)); ASSERT_EQ(jUint.as_uint64(), 123u); ASSERT_TRUE(checkTypeAndClamp(jUint)); ASSERT_EQ(jUint.as_uint64(), 123u); - auto jInt = json::value(123); + auto jInt = boost::json::value(123); ASSERT_TRUE(checkTypeAndClamp(jInt)); ASSERT_EQ(jInt.as_int64(), 123); ASSERT_TRUE(checkTypeAndClamp(jInt)); ASSERT_EQ(jInt.as_int64(), 123); - jInt = json::value(-123); + jInt = boost::json::value(-123); ASSERT_TRUE(checkTypeAndClamp(jInt)); ASSERT_EQ(jInt.as_int64(), -123); } TEST_F(RPCBaseTest, CheckTypeAndClampInvalidValues) { - auto jInt = json::value(-123); + auto jInt = boost::json::value(-123); ASSERT_FALSE(checkTypeAndClamp(jInt)); // Unsigned can't be negative } TEST_F(RPCBaseTest, CheckTypeAndClampOverflow) { - auto jBigUint = json::value(std::numeric_limits::max()); + auto jBigUint = boost::json::value(std::numeric_limits::max()); ASSERT_TRUE(checkTypeAndClamp(jBigUint)); ASSERT_EQ(jBigUint.as_uint64(), std::numeric_limits::max()); - auto jBigInt = json::value(std::numeric_limits::max()); + auto jBigInt = boost::json::value(std::numeric_limits::max()); ASSERT_TRUE(checkTypeAndClamp(jBigInt)); ASSERT_EQ(jBigInt.as_int64(), std::numeric_limits::max()); } TEST_F(RPCBaseTest, CheckTypeAndClampUnderflow) { - auto jLowInt = json::value(std::numeric_limits::min()); + auto jLowInt = boost::json::value(std::numeric_limits::min()); ASSERT_TRUE(checkTypeAndClamp(jLowInt)); ASSERT_EQ(jLowInt.as_int64(), std::numeric_limits::min()); } @@ -152,10 +150,10 @@ TEST_F(RPCBaseTest, TypeValidator) {"str", Type{}}, {"double", Type{}}, {"bool", Type{}}, - {"arr", Type{}}, + {"arr", Type{}}, }; - auto passingInput = json::parse(R"JSON({ + auto passingInput = boost::json::parse(R"JSON({ "uint": 123, "int": 321, "str": "a string", @@ -166,27 +164,27 @@ TEST_F(RPCBaseTest, TypeValidator) ASSERT_TRUE(spec.process(passingInput)); { - auto failingInput = json::parse(R"JSON({ "uint": "a string" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "uint": "a string" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } { - auto failingInput = json::parse(R"JSON({ "int": "a string" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "int": "a string" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } { - auto failingInput = json::parse(R"JSON({ "str": 1234 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "str": 1234 })JSON"); ASSERT_FALSE(spec.process(failingInput)); } { - auto failingInput = json::parse(R"JSON({ "double": "a string" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "double": "a string" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } { - auto failingInput = json::parse(R"JSON({ "bool": "a string" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "bool": "a string" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } { - auto failingInput = json::parse(R"JSON({ "arr": "a string" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "arr": "a string" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } } @@ -198,13 +196,13 @@ TEST_F(RPCBaseTest, TypeValidatorMultipleTypes) {"test", Type{}}, }; - auto passingInput = json::parse(R"JSON({ "test": "1234" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "test": "1234" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto passingInput2 = json::parse(R"JSON({ "test": 1234 })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "test": 1234 })JSON"); ASSERT_TRUE(spec.process(passingInput2)); - auto failingInput = json::parse(R"JSON({ "test": true })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "test": true })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -214,13 +212,13 @@ TEST_F(RPCBaseTest, RequiredValidator) {"required", Required{}}, }; - auto passingInput = json::parse(R"JSON({ "required": "present" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "required": "present" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto passingInput2 = json::parse(R"JSON({ "required": true })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "required": true })JSON"); ASSERT_TRUE(spec.process(passingInput2)); - auto failingInput = json::parse(R"JSON({})JSON"); + auto failingInput = boost::json::parse(R"JSON({})JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -230,19 +228,19 @@ TEST_F(RPCBaseTest, BetweenValidator) {"amount", Between{10u, 20u}}, }; - auto passingInput = json::parse(R"JSON({ "amount": 15 })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "amount": 15 })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto passingInput2 = json::parse(R"JSON({ "amount": 10 })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "amount": 10 })JSON"); ASSERT_TRUE(spec.process(passingInput2)); - auto passingInput3 = json::parse(R"JSON({ "amount": 20 })JSON"); + auto passingInput3 = boost::json::parse(R"JSON({ "amount": 20 })JSON"); ASSERT_TRUE(spec.process(passingInput3)); - auto failingInput = json::parse(R"JSON({ "amount": 9 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "amount": 9 })JSON"); ASSERT_FALSE(spec.process(failingInput)); - auto failingInput2 = json::parse(R"JSON({ "amount": 21 })JSON"); + auto failingInput2 = boost::json::parse(R"JSON({ "amount": 21 })JSON"); ASSERT_FALSE(spec.process(failingInput2)); } @@ -252,13 +250,13 @@ TEST_F(RPCBaseTest, MinValidator) {"amount", Min{6}}, }; - auto passingInput = json::parse(R"JSON({ "amount": 7 })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "amount": 7 })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto passingInput2 = json::parse(R"JSON({ "amount": 6 })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "amount": 6 })JSON"); ASSERT_TRUE(spec.process(passingInput2)); - auto failingInput = json::parse(R"JSON({ "amount": 5 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "amount": 5 })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -270,7 +268,8 @@ TEST_F(RPCBaseTest, MinValidatorAfterType) {"amount3", Type{}, Min{std::numeric_limits::min()}}, }; - auto bigInput = json::parse(R"JSON({ "amount": 9999999999, "amount2": 9999999999, "amount3": -9999999999 })JSON"); + auto bigInput = + boost::json::parse(R"JSON({ "amount": 9999999999, "amount2": 9999999999, "amount3": -9999999999 })JSON"); ASSERT_TRUE(spec.process(bigInput)); // type check clamps to type's max/min value } @@ -280,13 +279,13 @@ TEST_F(RPCBaseTest, MaxValidator) {"amount", Max{6}}, }; - auto passingInput = json::parse(R"JSON({ "amount": 5 })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "amount": 5 })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto passingInput2 = json::parse(R"JSON({ "amount": 6 })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "amount": 6 })JSON"); ASSERT_TRUE(spec.process(passingInput2)); - auto failingInput = json::parse(R"JSON({ "amount": 7 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "amount": 7 })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -298,7 +297,8 @@ TEST_F(RPCBaseTest, MaxValidatorAfterType) {"amount3", Type{}, Max{std::numeric_limits::min()}}, }; - auto bigInput = json::parse(R"JSON({ "amount": 9999999999, "amount2": 9999999999, "amount3": -9999999999 })JSON"); + auto bigInput = + boost::json::parse(R"JSON({ "amount": 9999999999, "amount2": 9999999999, "amount3": -9999999999 })JSON"); ASSERT_TRUE(spec.process(bigInput)); // type check clamps to type's min/max value } @@ -308,13 +308,13 @@ TEST_F(RPCBaseTest, OneOfValidator) {"currency", OneOf{"XRP", "USD"}}, }; - auto passingInput = json::parse(R"JSON({ "currency": "XRP" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "currency": "XRP" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto passingInput2 = json::parse(R"JSON({ "currency": "USD" })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "currency": "USD" })JSON"); ASSERT_TRUE(spec.process(passingInput2)); - auto failingInput = json::parse(R"JSON({ "currency": "PRX" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "currency": "PRX" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -324,10 +324,10 @@ TEST_F(RPCBaseTest, EqualToValidator) {"exact", EqualTo{"CaseSensitive"}}, }; - auto passingInput = json::parse(R"JSON({ "exact": "CaseSensitive" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "exact": "CaseSensitive" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "exact": "Different" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "exact": "Different" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -336,7 +336,7 @@ TEST_F(RPCBaseTest, ArrayAtValidator) auto spec = RpcSpec{ {"arr", Required{}, - Type{}, + Type{}, ValidateArrayAt{ 0, { @@ -353,16 +353,16 @@ TEST_F(RPCBaseTest, ArrayAtValidator) }; // clang-format on - auto passingInput = json::parse(R"JSON({ "arr": [{"limit": 42}] })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "arr": [{"limit": 42}] })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "arr": [{"limit": "not int"}] })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "arr": [{"limit": "not int"}] })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "arr": [{"limit": 42}], "arr2": "not array type" })JSON"); + failingInput = boost::json::parse(R"JSON({ "arr": [{"limit": 42}], "arr2": "not array type" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "arr": [] })JSON"); + failingInput = boost::json::parse(R"JSON({ "arr": [] })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -371,41 +371,41 @@ TEST_F(RPCBaseTest, IfTypeValidator) auto spec = RpcSpec{ {"mix", Required{}, - Type{}, - IfType{ + Type{}, + IfType{ Section{{"limit", Required{}, Type{}, Between{0, 100}}}, Section{{"limit2", Required{}, Type{}, Between{0, 100}}} }, IfType{CustomValidators::uint256HexStringValidator}}, {"mix2", Section{{"limit", Required{}, Type{}, Between{0, 100}}}, - Type{}}, + Type{}}, }; // if json object pass - auto passingInput = json::parse(R"JSON({ "mix": {"limit": 42, "limit2": 22} })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "mix": {"limit": 42, "limit2": 22} })JSON"); ASSERT_TRUE(spec.process(passingInput)); // if string pass passingInput = - json::parse(R"JSON({ "mix": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC" })JSON"); + boost::json::parse(R"JSON({ "mix": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC" })JSON"); ASSERT_TRUE(spec.process(passingInput)); // if json object fail at first requirement - auto failingInput = json::parse(R"JSON({ "mix": {"limit": "not int"} })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "mix": {"limit": "not int"} })JSON"); ASSERT_FALSE(spec.process(failingInput)); // if json object fail at second requirement - failingInput = json::parse(R"JSON({ "mix": {"limit": 22, "limit2": "y"} })JSON"); + failingInput = boost::json::parse(R"JSON({ "mix": {"limit": 22, "limit2": "y"} })JSON"); ASSERT_FALSE(spec.process(failingInput)); // if string fail - failingInput = json::parse(R"JSON({ "mix": "not hash" })JSON"); + failingInput = boost::json::parse(R"JSON({ "mix": "not hash" })JSON"); ASSERT_FALSE(spec.process(failingInput)); // type check fail - failingInput = json::parse(R"JSON({ "mix": 1213 })JSON"); + failingInput = boost::json::parse(R"JSON({ "mix": 1213 })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "mix": {"limit": 42, "limit2": 22}, "mix2": 1213 })JSON"); + failingInput = boost::json::parse(R"JSON({ "mix": {"limit": 42, "limit2": 22}, "mix2": 1213 })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -414,28 +414,29 @@ TEST_F(RPCBaseTest, WithCustomError) auto const spec = RpcSpec{ {"transaction", WithCustomError{ - CustomValidators::uint256HexStringValidator, rpc::Status{ripple::rpcBAD_FEATURE, "MyCustomError"} + CustomValidators::uint256HexStringValidator, rpc::Status{xrpl::RpcBadFeature, "MyCustomError"} }}, - {"other", WithCustomError{Type{}, rpc::Status{ripple::rpcALREADY_MULTISIG, "MyCustomError2"}}} + {"other", WithCustomError{Type{}, rpc::Status{xrpl::RpcAlreadyMultisig, "MyCustomError2"}}} }; - auto passingInput = json::parse( + auto passingInput = boost::json::parse( R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC", "other": "1"})JSON" ); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = - json::parse(R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B"})JSON"); + auto failingInput = boost::json::parse( + R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B"})JSON" + ); auto err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "MyCustomError"); - ASSERT_EQ(err.error(), ripple::rpcBAD_FEATURE); + ASSERT_EQ(err.error(), xrpl::RpcBadFeature); - failingInput = json::parse(R"JSON({ "other": 1})JSON"); + failingInput = boost::json::parse(R"JSON({ "other": 1})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "MyCustomError2"); - ASSERT_EQ(err.error(), ripple::rpcALREADY_MULTISIG); + ASSERT_EQ(err.error(), xrpl::RpcAlreadyMultisig); } TEST_F(RPCBaseTest, TimeFormatValidator) @@ -444,50 +445,51 @@ TEST_F(RPCBaseTest, TimeFormatValidator) {"date", TimeFormatValidator{"%Y-%m-%dT%H:%M:%SZ"}}, }; - auto passingInput = json::parse(R"JSON({ "date": "2023-01-01T00:00:00Z" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "date": "2023-01-01T00:00:00Z" })JSON"); EXPECT_TRUE(spec.process(passingInput)); - passingInput = json::parse("123"); + passingInput = boost::json::parse("123"); EXPECT_TRUE(spec.process(passingInput)); // key not exists - passingInput = json::parse(R"JSON({ "date1": "2023-01-01T00:00:00Z" })JSON"); + passingInput = boost::json::parse(R"JSON({ "date1": "2023-01-01T00:00:00Z" })JSON"); EXPECT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "date": "2023-01-01-00:00:00" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "date": "2023-01-01-00:00:00" })JSON"); auto err = spec.process(failingInput); EXPECT_FALSE(err); - EXPECT_EQ(err.error(), ripple::rpcINVALID_PARAMS); + EXPECT_EQ(err.error(), xrpl::RpcInvalidParams); - failingInput = json::parse(R"JSON({ "date": "01-01-2024T00:00:00" })JSON"); + failingInput = boost::json::parse(R"JSON({ "date": "01-01-2024T00:00:00" })JSON"); EXPECT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "date": "2024-01-01T29:00:00" })JSON"); + failingInput = boost::json::parse(R"JSON({ "date": "2024-01-01T29:00:00" })JSON"); EXPECT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "date": "" })JSON"); + failingInput = boost::json::parse(R"JSON({ "date": "" })JSON"); EXPECT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "date": 1 })JSON"); + failingInput = boost::json::parse(R"JSON({ "date": 1 })JSON"); err = spec.process(failingInput); EXPECT_FALSE(err); - EXPECT_EQ(err.error(), ripple::rpcINVALID_PARAMS); + EXPECT_EQ(err.error(), xrpl::RpcInvalidParams); } TEST_F(RPCBaseTest, CustomValidator) { - auto customFormatCheck = CustomValidator{[](json::value const& value, std::string_view /* key */) -> MaybeError { - return value.as_string().size() == 34 ? MaybeError{} : Error{rpc::Status{"Uh oh"}}; - }}; + auto customFormatCheck = + CustomValidator{[](boost::json::value const& value, std::string_view /* key */) -> MaybeError { + return value.as_string().size() == 34 ? MaybeError{} : Error{rpc::Status{"Uh oh"}}; + }}; auto spec = RpcSpec{ {"taker", customFormatCheck}, }; - auto passingInput = json::parse(R"JSON({ "taker": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "taker": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "taker": "wrongformat" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "taker": "wrongformat" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -498,13 +500,13 @@ TEST_F(RPCBaseTest, NotSupported) {"getter", NotSupported{}}, }; - auto passingInput = json::parse(R"JSON({ "taker": 2 })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "taker": 2 })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "taker": 123 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "taker": 123 })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "taker": 2, "getter": 2 })JSON"); + failingInput = boost::json::parse(R"JSON({ "taker": 2, "getter": 2 })JSON"); ASSERT_FALSE(spec.process(failingInput)); } @@ -513,21 +515,21 @@ TEST_F(RPCBaseTest, LedgerIndexValidator) auto spec = RpcSpec{ {"ledgerIndex", CustomValidators::ledgerIndexValidator}, }; - auto passingInput = json::parse(R"JSON({ "ledgerIndex": "validated" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "ledgerIndex": "validated" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON({ "ledgerIndex": "256" })JSON"); + passingInput = boost::json::parse(R"JSON({ "ledgerIndex": "256" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON({ "ledgerIndex": 256 })JSON"); + passingInput = boost::json::parse(R"JSON({ "ledgerIndex": 256 })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "ledgerIndex": "wrongformat" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "ledgerIndex": "wrongformat" })JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "ledgerIndexMalformed"); - failingInput = json::parse(R"JSON({ "ledgerIndex": true })JSON"); + failingInput = boost::json::parse(R"JSON({ "ledgerIndex": true })JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "ledgerIndexMalformed"); @@ -538,24 +540,26 @@ TEST_F(RPCBaseTest, AccountValidator) auto spec = RpcSpec{ {"account", CustomValidators::accountValidator}, }; - auto failingInput = json::parse(R"JSON({ "account": 256 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "account": 256 })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })JSON"); + failingInput = boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = - json::parse(R"JSON({ "account": "02000000000000000000000000000000000000000000000000000000000000000" })JSON"); + failingInput = boost::json::parse( + R"JSON({ "account": "02000000000000000000000000000000000000000000000000000000000000000" })JSON" + ); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp?" })JSON"); + failingInput = boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp?" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - auto passingInput = json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = - json::parse(R"JSON({ "account": "020000000000000000000000000000000000000000000000000000000000000000" })JSON"); + passingInput = boost::json::parse( + R"JSON({ "account": "020000000000000000000000000000000000000000000000000000000000000000" })JSON" + ); ASSERT_TRUE(spec.process(passingInput)); } @@ -564,20 +568,21 @@ TEST_F(RPCBaseTest, AccountBase58Validator) auto spec = RpcSpec{ {"account", CustomValidators::accountBase58Validator}, }; - auto failingInput = json::parse(R"JSON({ "account": 256 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "account": 256 })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })JSON"); + failingInput = boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = - json::parse(R"JSON({ "account": "020000000000000000000000000000000000000000000000000000000000000000" })JSON"); + failingInput = boost::json::parse( + R"JSON({ "account": "020000000000000000000000000000000000000000000000000000000000000000" })JSON" + ); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp?" })JSON"); + failingInput = boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp?" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - auto passingInput = json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })JSON"); ASSERT_TRUE(spec.process(passingInput)); } @@ -586,31 +591,31 @@ TEST_F(RPCBaseTest, AccountMarkerValidator) auto spec = RpcSpec{ {"marker", CustomValidators::accountMarkerValidator}, }; - auto failingInput = json::parse(R"JSON({ "marker": 256 })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "marker": 256 })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "marker": "testtest" })JSON"); + failingInput = boost::json::parse(R"JSON({ "marker": "testtest" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "marker": "ABAB1234:1H" })JSON"); + failingInput = boost::json::parse(R"JSON({ "marker": "ABAB1234:1H" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - auto passingInput = json::parse(R"JSON({ "account": "ABAB1234:123" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "account": "ABAB1234:123" })JSON"); ASSERT_TRUE(spec.process(passingInput)); } TEST_F(RPCBaseTest, Uint160HexStringValidator) { auto const spec = RpcSpec{{"marker", CustomValidators::uint160HexStringValidator}}; - auto passingInput = json::parse(R"JSON({ "marker": "F609A18102218C75767209946A77523CBD97E225"})JSON"); + auto passingInput = boost::json::parse(R"JSON({ "marker": "F609A18102218C75767209946A77523CBD97E225"})JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "marker": 160})JSON"); + auto failingInput = boost::json::parse(R"JSON({ "marker": 160})JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "markerNotString"); - failingInput = json::parse(R"JSON({ "marker": "F609A18102218C75767209946A77523CBD97E2253515BC"})JSON"); + failingInput = boost::json::parse(R"JSON({ "marker": "F609A18102218C75767209946A77523CBD97E2253515BC"})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "markerMalformed"); @@ -620,16 +625,17 @@ TEST_F(RPCBaseTest, Uint192HexStringValidator) { auto const spec = RpcSpec{{"mpt_issuance_id", CustomValidators::uint192HexStringValidator}}; auto passingInput = - json::parse(R"JSON({ "mpt_issuance_id": "0000012F27A9DE73EAA1E8831FA253E19030A17E2D038198"})JSON"); + boost::json::parse(R"JSON({ "mpt_issuance_id": "0000012F27A9DE73EAA1E8831FA253E19030A17E2D038198"})JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "mpt_issuance_id": 192})JSON"); + auto failingInput = boost::json::parse(R"JSON({ "mpt_issuance_id": 192})JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "mpt_issuance_idNotString"); - failingInput = - json::parse(R"JSON({ "mpt_issuance_id": "0000012F27A9DE73EAA1E8831FA253E19030A17E2D038198983515BC"})JSON"); + failingInput = boost::json::parse( + R"JSON({ "mpt_issuance_id": "0000012F27A9DE73EAA1E8831FA253E19030A17E2D038198983515BC"})JSON" + ); err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "mpt_issuance_idMalformed"); @@ -638,17 +644,18 @@ TEST_F(RPCBaseTest, Uint192HexStringValidator) TEST_F(RPCBaseTest, Uint256HexStringValidator) { auto const spec = RpcSpec{{"transaction", CustomValidators::uint256HexStringValidator}}; - auto passingInput = - json::parse(R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"})JSON"); + auto passingInput = boost::json::parse( + R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"})JSON" + ); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "transaction": 256})JSON"); + auto failingInput = boost::json::parse(R"JSON({ "transaction": 256})JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "transactionNotString"); failingInput = - json::parse(R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC"})JSON"); + boost::json::parse(R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC"})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "transactionMalformed"); @@ -657,26 +664,26 @@ TEST_F(RPCBaseTest, Uint256HexStringValidator) TEST_F(RPCBaseTest, CurrencyValidator) { auto const spec = RpcSpec{{"currency", CustomValidators::currencyValidator}}; - auto passingInput = json::parse(R"JSON({ "currency": "GBP"})JSON"); + auto passingInput = boost::json::parse(R"JSON({ "currency": "GBP"})JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON({ "currency": "0158415500000000C1F76FF6ECB0BAC600000000"})JSON"); + passingInput = boost::json::parse(R"JSON({ "currency": "0158415500000000C1F76FF6ECB0BAC600000000"})JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON({ "currency": "0158415500000000c1f76ff6ecb0bac600000000"})JSON"); + passingInput = boost::json::parse(R"JSON({ "currency": "0158415500000000c1f76ff6ecb0bac600000000"})JSON"); ASSERT_TRUE(spec.process(passingInput)); for (auto const& currency : {"[]<", ">()", "{}|", "?!@", "#$%", "^&*"}) { - passingInput = json::parse(fmt::format(R"JSON({{ "currency": "{}" }})JSON", currency)); + passingInput = boost::json::parse(fmt::format(R"JSON({{ "currency": "{}" }})JSON", currency)); ASSERT_TRUE(spec.process(passingInput)); } - auto failingInput = json::parse(R"JSON({ "currency": 256})JSON"); + auto failingInput = boost::json::parse(R"JSON({ "currency": 256})JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "currencyNotString"); - failingInput = json::parse(R"JSON({ "currency": "12314"})JSON"); + failingInput = boost::json::parse(R"JSON({ "currency": "12314"})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "malformedCurrency"); @@ -685,15 +692,15 @@ TEST_F(RPCBaseTest, CurrencyValidator) TEST_F(RPCBaseTest, IssuerValidator) { auto const spec = RpcSpec{{"issuer", CustomValidators::issuerValidator}}; - auto passingInput = json::parse(R"JSON({ "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"})JSON"); + auto passingInput = boost::json::parse(R"JSON({ "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"})JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "issuer": 256})JSON"); + auto failingInput = boost::json::parse(R"JSON({ "issuer": 256})JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); ASSERT_EQ(err.error().message, "issuerNotString"); - failingInput = json::parse(fmt::format(R"JSON({{ "issuer": "{}"}})JSON", toBase58(ripple::noAccount()))); + failingInput = boost::json::parse(fmt::format(R"JSON({{ "issuer": "{}"}})JSON", toBase58(xrpl::noAccount()))); err = spec.process(failingInput); ASSERT_FALSE(err); } @@ -701,7 +708,7 @@ TEST_F(RPCBaseTest, IssuerValidator) TEST_F(RPCBaseTest, SubscribeStreamValidator) { auto const spec = RpcSpec{{"streams", CustomValidators::subscribeStreamValidator}}; - auto passingInput = json::parse( + auto passingInput = boost::json::parse( R"JSON({ "streams": [ "ledger", @@ -716,15 +723,15 @@ TEST_F(RPCBaseTest, SubscribeStreamValidator) ); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "streams": 256})JSON"); + auto failingInput = boost::json::parse(R"JSON({ "streams": 256})JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); - failingInput = json::parse(R"JSON({ "streams": ["test"]})JSON"); + failingInput = boost::json::parse(R"JSON({ "streams": ["test"]})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); - failingInput = json::parse(R"JSON({ "streams": [123]})JSON"); + failingInput = boost::json::parse(R"JSON({ "streams": [123]})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); } @@ -732,20 +739,20 @@ TEST_F(RPCBaseTest, SubscribeStreamValidator) TEST_F(RPCBaseTest, SubscribeAccountsValidator) { auto const spec = RpcSpec{{"accounts", CustomValidators::subscribeAccountsValidator}}; - auto passingInput = json::parse( + auto passingInput = boost::json::parse( R"JSON({ "accounts": ["rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"]})JSON" ); ASSERT_TRUE(spec.process(passingInput)); - auto failingInput = json::parse(R"JSON({ "accounts": 256})JSON"); + auto failingInput = boost::json::parse(R"JSON({ "accounts": 256})JSON"); auto err = spec.process(failingInput); ASSERT_FALSE(err); - failingInput = json::parse(R"JSON({ "accounts": ["test"]})JSON"); + failingInput = boost::json::parse(R"JSON({ "accounts": ["test"]})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); - failingInput = json::parse(R"JSON({ "accounts": [123]})JSON"); + failingInput = boost::json::parse(R"JSON({ "accounts": [123]})JSON"); err = spec.process(failingInput); ASSERT_FALSE(err); } @@ -756,14 +763,14 @@ TEST_F(RPCBaseTest, ClampingModifier) {"amount", Clamp{10u, 20u}}, }; - auto passingInput = json::parse(R"JSON({ "amount": 15 })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "amount": 15 })JSON"); ASSERT_TRUE(spec.process(passingInput)); - auto passingInput2 = json::parse(R"JSON({ "amount": 5 })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "amount": 5 })JSON"); ASSERT_TRUE(spec.process(passingInput2)); ASSERT_EQ(passingInput2.at("amount").as_uint64(), 10u); // clamped - auto passingInput3 = json::parse(R"JSON({ "amount": 25 })JSON"); + auto passingInput3 = boost::json::parse(R"JSON({ "amount": 25 })JSON"); ASSERT_TRUE(spec.process(passingInput3)); ASSERT_EQ(passingInput3.at("amount").as_uint64(), 20u); // clamped } @@ -774,18 +781,18 @@ TEST_F(RPCBaseTest, ToLowerModifier) {"str", ToLower{}}, }; - auto passingInput = json::parse(R"JSON({ "str": "TesT" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "str": "TesT" })JSON"); ASSERT_TRUE(spec.process(passingInput)); ASSERT_EQ(passingInput.at("str").as_string(), "test"); - auto passingInput2 = json::parse(R"JSON({ "str2": "TesT" })JSON"); + auto passingInput2 = boost::json::parse(R"JSON({ "str2": "TesT" })JSON"); ASSERT_TRUE(spec.process(passingInput2)); // no str no problem - auto passingInput3 = json::parse(R"JSON({ "str": "already lower case" })JSON"); + auto passingInput3 = boost::json::parse(R"JSON({ "str": "already lower case" })JSON"); ASSERT_TRUE(spec.process(passingInput3)); ASSERT_EQ(passingInput3.at("str").as_string(), "already lower case"); - auto passingInput4 = json::parse(R"JSON({ "str": "" })JSON"); + auto passingInput4 = boost::json::parse(R"JSON({ "str": "" })JSON"); ASSERT_TRUE(spec.process(passingInput4)); // empty str no problem ASSERT_EQ(passingInput4.at("str").as_string(), ""); } @@ -796,42 +803,42 @@ TEST_F(RPCBaseTest, ToNumberModifier) {"str", ToNumber{}}, }; - auto passingInput = json::parse(R"JSON({ "str": [] })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "str": [] })JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON({ "str2": "TesT" })JSON"); + passingInput = boost::json::parse(R"JSON({ "str2": "TesT" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON([])JSON"); + passingInput = boost::json::parse(R"JSON([])JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON({ "str": "123" })JSON"); + passingInput = boost::json::parse(R"JSON({ "str": "123" })JSON"); ASSERT_TRUE(spec.process(passingInput)); ASSERT_EQ(passingInput.at("str").as_int64(), 123); - auto failingInput = json::parse(R"JSON({ "str": "ok" })JSON"); + auto failingInput = boost::json::parse(R"JSON({ "str": "ok" })JSON"); ASSERT_FALSE(spec.process(failingInput)); - failingInput = json::parse(R"JSON({ "str": "123.123" })JSON"); + failingInput = boost::json::parse(R"JSON({ "str": "123.123" })JSON"); ASSERT_FALSE(spec.process(failingInput)); } TEST_F(RPCBaseTest, CustomModifier) { - testing::StrictMock> mockModifier; + testing::StrictMock> mockModifier; auto const customModifier = CustomModifier{mockModifier.AsStdFunction()}; auto const spec = RpcSpec{ {"str", customModifier}, }; EXPECT_CALL(mockModifier, Call).WillOnce(testing::Return(MaybeError{})); - auto passingInput = json::parse(R"JSON({ "str": "sss" })JSON"); + auto passingInput = boost::json::parse(R"JSON({ "str": "sss" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse(R"JSON({ "strNotExist": 123 })JSON"); + passingInput = boost::json::parse(R"JSON({ "strNotExist": 123 })JSON"); ASSERT_TRUE(spec.process(passingInput)); // not a json object - passingInput = json::parse(R"JSON([])JSON"); + passingInput = boost::json::parse(R"JSON([])JSON"); ASSERT_TRUE(spec.process(passingInput)); } diff --git a/tests/unit/rpc/ErrorTests.cpp b/tests/unit/rpc/ErrorTests.cpp index 3b265f0dc..162134e92 100644 --- a/tests/unit/rpc/ErrorTests.cpp +++ b/tests/unit/rpc/ErrorTests.cpp @@ -63,17 +63,17 @@ check(boost::json::object const& j, std::string_view error, ErrorCodeType errorC TEST(RPCErrorsTest, StatusAsBool) { // Only rpcSUCCESS status should return false - EXPECT_FALSE(Status{RippledError::rpcSUCCESS}); + EXPECT_FALSE(Status{RippledError::RpcSuccess}); // true should be returned for any error state, we just test a few CombinedError const errors[]{ - RippledError::rpcINVALID_PARAMS, - RippledError::rpcUNKNOWN_COMMAND, - RippledError::rpcTOO_BUSY, - RippledError::rpcNO_NETWORK, - RippledError::rpcWRONG_NETWORK, - RippledError::rpcACT_MALFORMED, - RippledError::rpcBAD_MARKET, + RippledError::RpcInvalidParams, + RippledError::RpcUnknownCommand, + RippledError::RpcTooBusy, + RippledError::RpcNoNetwork, + RippledError::RpcWrongNetwork, + RippledError::RpcActMalformed, + RippledError::RpcBadMarket, ClioError::RpcMalformedCurrency, }; @@ -83,20 +83,20 @@ TEST(RPCErrorsTest, StatusAsBool) TEST(RPCErrorsTest, StatusEquals) { - EXPECT_EQ(Status{RippledError::rpcUNKNOWN}, Status{RippledError::rpcUNKNOWN}); - EXPECT_NE(Status{RippledError::rpcUNKNOWN}, Status{RippledError::rpcINTERNAL}); + EXPECT_EQ(Status{RippledError::RpcUnknown}, Status{RippledError::RpcUnknown}); + EXPECT_NE(Status{RippledError::RpcUnknown}, Status{RippledError::RpcInternal}); } TEST(RPCErrorsTest, SuccessToJSON) { - auto const status = Status{RippledError::rpcSUCCESS}; - check(makeError(status), "unknown", RippledError::rpcSUCCESS, "An unknown error code."); + auto const status = Status{RippledError::RpcSuccess}; + check(makeError(status), "unknown", RippledError::RpcSuccess, "An unknown error code."); } TEST(RPCErrorsTest, RippledErrorToJSON) { - auto const status = Status{RippledError::rpcINVALID_PARAMS}; - check(makeError(status), "invalidParams", RippledError::rpcINVALID_PARAMS, "Invalid parameters."); + auto const status = Status{RippledError::RpcInvalidParams}; + check(makeError(status), "invalidParams", RippledError::RpcInvalidParams, "Invalid parameters."); } TEST(RPCErrorsTest, RippledErrorFromStringToJSON) @@ -107,14 +107,14 @@ TEST(RPCErrorsTest, RippledErrorFromStringToJSON) TEST(RPCErrorsTest, RippledErrorToJSONCustomMessage) { - auto const status = Status{RippledError::rpcINVALID_PARAMS, "custom"}; - check(makeError(status), "invalidParams", RippledError::rpcINVALID_PARAMS, "custom"); + auto const status = Status{RippledError::RpcInvalidParams, "custom"}; + check(makeError(status), "invalidParams", RippledError::RpcInvalidParams, "custom"); } TEST(RPCErrorsTest, RippledErrorToJSONCustomStrCodeAndMessage) { - auto const status = Status{RippledError::rpcINVALID_PARAMS, "customCode", "customMessage"}; - check(makeError(status), "customCode", RippledError::rpcINVALID_PARAMS, "customMessage"); + auto const status = Status{RippledError::RpcInvalidParams, "customCode", "customMessage"}; + check(makeError(status), "customCode", RippledError::RpcInvalidParams, "customMessage"); } TEST(RPCErrorsTest, ClioErrorToJSON) @@ -221,7 +221,7 @@ INSTANTIATE_TEST_SUITE_P( }, StatusStreamTestBundle{ .testName = "StatusWithRippledError", - .status = Status{RippledError::rpcSUCCESS}, + .status = Status{RippledError::RpcSuccess}, .expectedOutput = "Code: 0, Message: An unknown error code." }, StatusStreamTestBundle{ @@ -241,7 +241,7 @@ INSTANTIATE_TEST_SUITE_P( }, StatusStreamTestBundle{ .testName = "StatusWithRippledErrorAndMessage", - .status = Status{RippledError::rpcSUCCESS, "test message."}, + .status = Status{RippledError::RpcSuccess, "test message."}, .expectedOutput = "Code: 0, Message: test message." }, StatusStreamTestBundle{ diff --git a/tests/unit/rpc/ForwardingProxyTests.cpp b/tests/unit/rpc/ForwardingProxyTests.cpp index 9f55574ad..206f70569 100644 --- a/tests/unit/rpc/ForwardingProxyTests.cpp +++ b/tests/unit/rpc/ForwardingProxyTests.cpp @@ -45,7 +45,6 @@ using namespace rpc; using namespace testing; using namespace util::config; -namespace json = boost::json; namespace { constexpr auto kCLIENT_IP = "127.0.0.1"; @@ -277,7 +276,7 @@ TEST_P(ShouldForwardParameterTest, Test) auto const rawHandlerProviderPtr = handlerProvider_.get(); auto const apiVersion = testBundle.apiVersion; auto const method = testBundle.method; - auto const params = json::parse(testBundle.testJson); + auto const params = boost::json::parse(testBundle.testJson); ON_CALL(*rawHandlerProviderPtr, isClioOnly(_)).WillByDefault(Return(testBundle.mockedIsClioOnly)); EXPECT_CALL(*rawHandlerProviderPtr, isClioOnly(method)).Times(testBundle.called); @@ -306,13 +305,13 @@ TEST_F(RPCForwardingProxyTest, ForwardCallsBalancerWithCorrectParams) auto const rawBalancerPtr = loadBalancer_.get(); auto const apiVersion = 2u; auto const method = "submit"; - auto const params = json::parse(R"JSON({"test": true})JSON"); - auto const forwarded = json::parse(R"JSON({"test": true, "command": "submit"})JSON"); + auto const params = boost::json::parse(R"JSON({"test": true})JSON"); + auto const forwarded = boost::json::parse(R"JSON({"test": true, "command": "submit"})JSON"); EXPECT_CALL( *rawBalancerPtr, forwardToRippled(forwarded.as_object(), std::make_optional(kCLIENT_IP), true, _) ) - .WillOnce(Return(json::object{})); + .WillOnce(Return(boost::json::object{})); EXPECT_CALL(*rawHandlerProviderPtr, contains(method)).WillOnce(Return(true)); @@ -343,8 +342,8 @@ TEST_F(RPCForwardingProxyTest, ForwardingFailYieldsErrorStatus) auto const rawBalancerPtr = loadBalancer_.get(); auto const apiVersion = 2u; auto const method = "submit"; - auto const params = json::parse(R"JSON({"test": true})JSON"); - auto const forwarded = json::parse(R"JSON({"test": true, "command": "submit"})JSON"); + auto const params = boost::json::parse(R"JSON({"test": true})JSON"); + auto const forwarded = boost::json::parse(R"JSON({"test": true, "command": "submit"})JSON"); EXPECT_CALL( *rawBalancerPtr, forwardToRippled(forwarded.as_object(), std::make_optional(kCLIENT_IP), true, _) diff --git a/tests/unit/rpc/JsonBoolTests.cpp b/tests/unit/rpc/JsonBoolTests.cpp index ca7f96e6f..021a8fe37 100644 --- a/tests/unit/rpc/JsonBoolTests.cpp +++ b/tests/unit/rpc/JsonBoolTests.cpp @@ -27,7 +27,6 @@ #include using namespace rpc; -namespace json = boost::json; using namespace testing; struct JsonBoolTestsCaseBundle { @@ -71,7 +70,7 @@ INSTANTIATE_TEST_CASE_P( TEST_P(JsonBoolTests, Parse) { auto const testBundle = GetParam(); - auto const jv = json::parse(testBundle.json).as_object(); + auto const jv = boost::json::parse(testBundle.json).as_object(); ASSERT_TRUE(jv.contains("test_bool")); EXPECT_EQ(testBundle.expectedBool, value_to(jv.at("test_bool")).value); } diff --git a/tests/unit/rpc/RPCEngineTests.cpp b/tests/unit/rpc/RPCEngineTests.cpp index f4f580870..22fe8cee1 100644 --- a/tests/unit/rpc/RPCEngineTests.cpp +++ b/tests/unit/rpc/RPCEngineTests.cpp @@ -58,7 +58,6 @@ using namespace data; using namespace rpc; using namespace util; -namespace json = boost::json; using namespace testing; using namespace util::config; @@ -143,7 +142,7 @@ generateTestValuesForParametersTest() .isTooBusy = neverCalled, .isUnknownCmd = neverCalled, .handlerReturnError = false, - .status = rpc::Status{RippledError::rpcNO_PERMISSION}, + .status = rpc::Status{RippledError::RpcNoPermission}, .response = std::nullopt}, {.testName = "BackendTooBusy", .isAdmin = false, @@ -153,7 +152,7 @@ generateTestValuesForParametersTest() .isTooBusy = true, .isUnknownCmd = neverCalled, .handlerReturnError = false, - .status = rpc::Status{RippledError::rpcTOO_BUSY}, + .status = rpc::Status{RippledError::RpcTooBusy}, .response = std::nullopt}, {.testName = "HandlerUnknown", .isAdmin = false, @@ -163,7 +162,7 @@ generateTestValuesForParametersTest() .isTooBusy = false, .isUnknownCmd = true, .handlerReturnError = false, - .status = rpc::Status{RippledError::rpcUNKNOWN_COMMAND}, + .status = rpc::Status{RippledError::RpcUnknownCommand}, .response = std::nullopt}, {.testName = "HandlerReturnError", .isAdmin = false, @@ -211,9 +210,9 @@ TEST_P(RPCEngineFlowParameterTest, Test) if (testBundle.forwarded) { EXPECT_CALL(*mockLoadBalancerPtr_, forwardToRippled) - .WillOnce( - Return(std::expected(json::parse(kFORWARD_REPLY).as_object())) - ); + .WillOnce(Return( + std::expected(boost::json::parse(kFORWARD_REPLY).as_object()) + )); EXPECT_CALL(*handlerProvider, contains).WillOnce(Return(true)); EXPECT_CALL(*mockCountersPtr_, rpcForwarded(testBundle.method)); } @@ -293,7 +292,7 @@ TEST_F(RPCEngineTest, ThrowDatabaseError) auto const res = engine->buildResponse(ctx); ASSERT_FALSE(res.response.has_value()); - EXPECT_EQ(res.response.error(), Status{RippledError::rpcTOO_BUSY}); + EXPECT_EQ(res.response.error(), Status{RippledError::RpcTooBusy}); }); } @@ -324,7 +323,7 @@ TEST_F(RPCEngineTest, ThrowException) auto const res = engine->buildResponse(ctx); ASSERT_FALSE(res.response.has_value()); - EXPECT_EQ(res.response.error(), Status{RippledError::rpcINTERNAL}); + EXPECT_EQ(res.response.error(), Status{RippledError::RpcInternal}); }); } @@ -409,7 +408,7 @@ INSTANTIATE_TEST_CASE_P( TEST_P(RPCEngineCacheParameterTest, Test) { auto const& testParam = GetParam(); - auto const json = ConfigFileJson{json::parse(testParam.config).as_object()}; + auto const json = ConfigFileJson{boost::json::parse(testParam.config).as_object()}; auto cfgCache{generateDefaultRPCEngineConfig()}; auto const errors = cfgCache.parse(json); diff --git a/tests/unit/rpc/RPCHelpersTests.cpp b/tests/unit/rpc/RPCHelpersTests.cpp index 40189b9b6..5ac6ecb30 100644 --- a/tests/unit/rpc/RPCHelpersTests.cpp +++ b/tests/unit/rpc/RPCHelpersTests.cpp @@ -105,7 +105,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidIndexNotHex) }); EXPECT_FALSE(ret.has_value()); - EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS); + EXPECT_EQ(ret.error(), xrpl::RpcInvalidParams); EXPECT_EQ(ret.error().message, "Malformed cursor."); }); ctx_.run(); @@ -119,7 +119,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidPageNotInt) }); EXPECT_FALSE(ret.has_value()); - EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS); + EXPECT_EQ(ret.error(), xrpl::RpcInvalidParams); EXPECT_EQ(ret.error().message, "Malformed cursor."); }); ctx_.run(); @@ -129,18 +129,18 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidPageNotInt) TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarker) { auto account = getAccountIdWithString(kACCOUNT); - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); // return owner index - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); // return two payment channel objects std::vector bbs; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -162,14 +162,14 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarker) TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker) { auto account = getAccountIdWithString(kACCOUNT); - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); std::vector bbs; int objectsCount = 11; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); - std::vector indexes; + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -177,8 +177,8 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -199,18 +199,18 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker) TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) { auto account = getAccountIdWithString(kACCOUNT); - auto ownerDirKk = ripple::keylet::ownerDir(account).key; + auto ownerDirKk = xrpl::keylet::ownerDir(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; int objectsCount = 10; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); - std::vector indexes; + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -222,14 +222,14 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); // first page 's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); // second page's next page is 0 - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); @@ -250,7 +250,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) { auto account = getAccountIdWithString(kACCOUNT); - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), 99).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), 99).key; static constexpr auto kLIMIT = 8; static constexpr auto kPAGE_NUM = 99; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -258,8 +258,8 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) std::vector bbs; int objectsCount = 10; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); - std::vector indexes; + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -271,8 +271,8 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); // return ownerdir when search by marker ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -297,21 +297,21 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) TEST_F(RPCHelpersTest, TraverseOwnedNodesWithUnexistingIndexMarker) { auto account = getAccountIdWithString(kACCOUNT); - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), 99).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), 99).key; static constexpr auto kLIMIT = 8; static constexpr auto kPAGE_NUM = 99; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); int objectsCount = 10; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); - std::vector indexes; + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); // return ownerdir when search by marker ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -322,7 +322,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithUnexistingIndexMarker) *backend_, account, 9, kLIMIT, fmt::format("{},{}", kINDEX2, kPAGE_NUM), yield, [&](auto) { count++; } ); EXPECT_FALSE(ret.has_value()); - EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS); + EXPECT_EQ(ret.error(), xrpl::RpcInvalidParams); EXPECT_EQ(ret.error().message, "Invalid marker."); }); ctx_.run(); @@ -530,7 +530,7 @@ TEST_F(RPCHelpersTest, ParseIssue) EXPECT_TRUE(issue.account == getAccountIdWithString(kACCOUNT2)); issue = parseIssue(boost::json::parse(R"JSON({"currency": "XRP"})JSON").as_object()); - EXPECT_TRUE(ripple::isXRP(issue.currency)); + EXPECT_TRUE(xrpl::isXRP(issue.currency)); EXPECT_THROW(parseIssue(boost::json::parse(R"JSON({"currency": 2})JSON").as_object()), std::runtime_error); @@ -551,7 +551,7 @@ TEST_F(RPCHelpersTest, ParseIssue) TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist) { auto const account = getAccountIdWithString(kACCOUNT); - auto const issuerKey = ripple::keylet::account(account); + auto const issuerKey = xrpl::keylet::account(account); // returns empty blob ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) @@ -560,7 +560,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist) runSpawn([&](boost::asio::yield_context yield) { // return false: blob doesn't exist EXPECT_FALSE( - fetchAndCheckAnyFlagsExists(*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield) + fetchAndCheckAnyFlagsExists(*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {xrpl::lsfHighDeepFreeze}, yield) ); }); } @@ -568,10 +568,10 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist) TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_AccountWithCorrectFlag) { auto const account = getAccountIdWithString(kACCOUNT); - auto const issuerKey = ripple::keylet::account(account); + auto const issuerKey = xrpl::keylet::account(account); // create account with highDeepFreeze Flag - auto const accountObject = createAccountRootObject(kACCOUNT, ripple::lsfHighDeepFreeze, 1, 10, 2, kTXN_ID, 3); + auto const accountObject = createAccountRootObject(kACCOUNT, xrpl::lsfHighDeepFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -579,7 +579,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_AccountWithCorrectFlag) runSpawn([&](boost::asio::yield_context yield) { // returns true: accountObject has the highDeepFreeze flag EXPECT_TRUE( - fetchAndCheckAnyFlagsExists(*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield) + fetchAndCheckAnyFlagsExists(*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {xrpl::lsfHighDeepFreeze}, yield) ); }); } @@ -587,10 +587,10 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_AccountWithCorrectFlag) TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_TrustLineIsFrozenAndCheckFreezeFlag) { auto const account = getAccountIdWithString(kACCOUNT); - auto const issuerKey = ripple::keylet::account(account); + auto const issuerKey = xrpl::keylet::account(account); // create account with lowDeepFreeze Flag - auto const accountObject = createAccountRootObject(kACCOUNT, ripple::lsfLowDeepFreeze, 1, 10, 2, kTXN_ID, 3); + auto const accountObject = createAccountRootObject(kACCOUNT, xrpl::lsfLowDeepFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -598,7 +598,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_TrustLineIsFrozenAndCheckFreez runSpawn([&](boost::asio::yield_context yield) { // returns false: accountObject has the lowDeepFreeze flag EXPECT_FALSE( - fetchAndCheckAnyFlagsExists(*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield) + fetchAndCheckAnyFlagsExists(*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {xrpl::lsfHighDeepFreeze}, yield) ); }); } @@ -606,9 +606,9 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_TrustLineIsFrozenAndCheckFreez TEST_F(RPCHelpersTest, isGlobalFrozen_AccountIsGlobalFrozen) { auto const account = getAccountIdWithString(kACCOUNT); - auto const issuerKey = ripple::keylet::account(account); + auto const issuerKey = xrpl::keylet::account(account); - auto const accountObject = createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + auto const accountObject = createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -625,16 +625,16 @@ TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsDeepFrozen) auto const account2 = getAccountIdWithString(kACCOUNT2); // create a trustline between account and account2 and is deep frozen - auto const trustLineKey = ripple::keylet::line(account, account2, ripple::Currency{kCURRENCY}).key; + auto const trustLineKey = xrpl::keylet::line(account, account2, xrpl::Currency{kCURRENCY}).key; auto const trustlineDeepFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowDeepFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfLowDeepFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { - EXPECT_TRUE(isDeepFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield)); + EXPECT_TRUE(isDeepFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account2, yield)); }); } @@ -644,18 +644,16 @@ TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsNotDeepFrozen) auto const account2 = getAccountIdWithString(kACCOUNT2); // create a trustline between account and account2 that is frozen (NOT DeepFrozen) - auto const trustLineKey = ripple::keylet::line(account, account2, ripple::Currency{kCURRENCY}).key; + auto const trustLineKey = xrpl::keylet::line(account, account2, xrpl::Currency{kCURRENCY}).key; auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfLowFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(trustlineFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { - EXPECT_FALSE( - isDeepFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield) - ); + EXPECT_FALSE(isDeepFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account2, yield)); }); } @@ -664,9 +662,9 @@ TEST_F(RPCHelpersTest, isDeepFrozen_IssuerAndAccountIsSameWillNotBeDeepFrozen) auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - auto const trustLineKey = ripple::keylet::line(account, issuer, ripple::Currency{kCURRENCY}).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, xrpl::Currency{kCURRENCY}).key; auto const trustlineDeepFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowDeepFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfLowDeepFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -674,7 +672,7 @@ TEST_F(RPCHelpersTest, isDeepFrozen_IssuerAndAccountIsSameWillNotBeDeepFrozen) runSpawn([&](boost::asio::yield_context yield) { // both accounts are same so trustline is not deep frozen - EXPECT_FALSE(isDeepFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield)); + EXPECT_FALSE(isDeepFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account, yield)); }); } @@ -683,14 +681,14 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerAccountIsGlobalFrozen) auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - auto const accountObject = createAccountRootObject(kACCOUNT2, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); - auto const issuerKey = ripple::keylet::account(issuer).key; + auto const accountObject = createAccountRootObject(kACCOUNT2, xrpl::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + auto const issuerKey = xrpl::keylet::account(issuer).key; ON_CALL(*backend_, doFetchLedgerObject(issuerKey, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { - EXPECT_TRUE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, issuer, yield)); + EXPECT_TRUE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, issuer, yield)); }); } @@ -699,16 +697,16 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerAndAccountIsSameWillNotBeFrozen) auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - auto const trustLineKey = ripple::keylet::line(account, issuer, ripple::Currency{kCURRENCY}).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, xrpl::Currency{kCURRENCY}).key; auto const trustlineDeepFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfHighFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfHighFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { - EXPECT_FALSE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield)); + EXPECT_FALSE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account, yield)); }); } @@ -716,13 +714,13 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerTrustLineIsFrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; // issuer is higher than account, so the correct flag to set is High freeze auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfHighFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfHighFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -737,13 +735,13 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerWithLowFreezeIsNotFrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; // issuer is higher than account, but the flag set here is low freeze auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfLowFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -758,9 +756,9 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineNotfrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; auto const trustLine = createRippleStateLedgerObject(kCURRENCY, kACCOUNT2, 500, kACCOUNT, 1000, kACCOUNT2, 1000, kTXN_ID, 1, 0); @@ -772,7 +770,7 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineNotfrozen) *backend_, *mockAmendmentCenterPtr_, kLEDGER_SEQ_OBJECT, account, currency, issuer, false, yield ); // Check issuer has a balance of 500 - EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 500)); + EXPECT_EQ(result, xrpl::STAmount(getIssue(kCURRENCY, kACCOUNT2), 500)); }); } @@ -780,9 +778,9 @@ TEST_F(RPCHelpersTest, AccountHolds_NoTrustLine) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const key = ripple::keylet::line(account, issuer, currency).key; + auto const key = xrpl::keylet::line(account, issuer, currency).key; // return no trustline found EXPECT_CALL(*backend_, doFetchLedgerObject(key, kLEDGER_SEQ_OBJECT, _)).WillOnce(Return(std::nullopt)); @@ -792,7 +790,7 @@ TEST_F(RPCHelpersTest, AccountHolds_NoTrustLine) *backend_, *mockAmendmentCenterPtr_, kLEDGER_SEQ_OBJECT, account, currency, issuer, false, yield ); // balance is 0 as trustline is frozen - EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0)); + EXPECT_EQ(result, xrpl::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0)); }); } @@ -800,13 +798,13 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineButFrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; // balance of 500, but trustline is frozen - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; auto const trustLine = createRippleStateLedgerObject( - kCURRENCY, kACCOUNT2, 500, kACCOUNT, 1000, kACCOUNT2, 1000, kTXN_ID, 1, ripple::lsfHighFreeze + kCURRENCY, kACCOUNT2, 500, kACCOUNT, 1000, kACCOUNT2, 1000, kTXN_ID, 1, xrpl::lsfHighFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -816,7 +814,7 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineButFrozen) auto const result = accountHolds( *backend_, *mockAmendmentCenterPtr_, kLEDGER_SEQ_OBJECT, account, currency, issuer, true, yield ); - EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0)); + EXPECT_EQ(result, xrpl::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0)); }); } @@ -828,15 +826,15 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) auto const lptRippleState = createRippleStateLedgerObject( kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); - auto const lptRippleStateKk = ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + auto const lptRippleStateKk = xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) .Times(2) .WillRepeatedly(Return(lptRippleState.getSerializer().peekData())); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_)) @@ -851,7 +849,7 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::toCurrency(kLPTOKEN_CURRENCY), ammAccount, true, yield @@ -868,7 +866,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) auto const usdRippleState = createRippleStateLedgerObject("USD", kACCOUNT2, 100, kACCOUNT, 100, kACCOUNT2, 100, kTXN_ID, 3); - auto const usdRippleStateKk = ripple::keylet::line(account2, account, ripple::to_currency("USD")).key; + auto const usdRippleStateKk = xrpl::keylet::line(account2, account, xrpl::toCurrency("USD")).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(usdRippleStateKk, testing::_, testing::_)) @@ -878,7 +876,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)) .WillOnce(Return(true)); - auto const account2Kk = ripple::keylet::account(account2).key; + auto const account2Kk = xrpl::keylet::account(account2).key; auto const account2Root = createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(account2Kk, testing::_, testing::_)) @@ -887,7 +885,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) util::spawn(ctx_, [&, this](boost::asio::yield_context yield) { auto ret = accountHolds( - *backend_, *mockAmendmentCenterPtr_, 0, account, ripple::to_currency("USD"), account2, true, yield + *backend_, *mockAmendmentCenterPtr_, 0, account, xrpl::toCurrency("USD"), account2, true, yield ); EXPECT_EQ(ret.mantissa(), 1000000000000000); }); @@ -903,7 +901,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) auto const lptRippleState = createRippleStateLedgerObject( kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); - auto const lptRippleStateKk = ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + auto const lptRippleStateKk = xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -913,8 +911,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); // accountroot fetched twice, once in isFrozen, once in accountHolds @@ -922,13 +920,13 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject(kAMM_ACCOUNT, "USD", kISSUER, "XRP", ripple::toBase58(ripple::xrpAccount())); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_)) + auto const amm = createAmmObject(kAMM_ACCOUNT, "USD", kISSUER, "XRP", xrpl::toBase58(xrpl::xrpAccount())); + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amm(ammID).key, testing::_, testing::_)) .Times(1) .WillOnce(Return(amm.getSerializer().peekData())); - auto const issuerKk = ripple::keylet::account(issuer).key; - auto const issuerAccountRoot = createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0); + auto const issuerKk = xrpl::keylet::account(issuer).key; + auto const issuerAccountRoot = createAccountRootObject(kISSUER, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); @@ -938,7 +936,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::toCurrency(kLPTOKEN_CURRENCY), ammAccount, true, yield @@ -957,7 +955,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) auto const lptRippleState = createRippleStateLedgerObject( kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); - auto const lptRippleStateKk = ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + auto const lptRippleStateKk = xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)).Times(2); @@ -967,8 +965,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)) .WillOnce(testing::Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); // accountroot fetched twice, once in isFrozen, once in accountHolds @@ -976,12 +974,12 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject(kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_)) + auto const amm = createAmmObject(kAMM_ACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "USD", kISSUER); + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amm(ammID).key, testing::_, testing::_)) .WillOnce(Return(amm.getSerializer().peekData())); - auto const issuerKk = ripple::keylet::account(issuer).key; - auto const issuerAccountRoot = createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0); + auto const issuerKk = xrpl::keylet::account(issuer).key; + auto const issuerAccountRoot = createAccountRootObject(kISSUER, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); @@ -991,7 +989,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::toCurrency(kLPTOKEN_CURRENCY), ammAccount, true, yield @@ -1010,7 +1008,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) auto const lptRippleState = createRippleStateLedgerObject( kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); - auto const lptRippleStateKk = ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + auto const lptRippleStateKk = xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -1020,8 +1018,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); // accountroot fetched twice, once in isFrozen, once in accountHolds @@ -1029,18 +1027,18 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject(kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_)) + auto const amm = createAmmObject(kAMM_ACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "USD", kISSUER); + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::amm(ammID).key, testing::_, testing::_)) .WillOnce(Return(amm.getSerializer().peekData())); - auto const issuerKk = ripple::keylet::account(issuer).key; + auto const issuerKk = xrpl::keylet::account(issuer).key; auto const issuerAccountRoot = createAccountRootObject(kISSUER, 0, 2, 200, 2, kINDEX1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); auto const usdRippleState = createRippleStateLedgerObject("USD", kISSUER, 100, kACCOUNT, 100, kISSUER, 100, kTXN_ID, 3); - auto const usdRippleStateKk = ripple::keylet::line(issuer, account, ripple::to_currency("USD")).key; + auto const usdRippleStateKk = xrpl::keylet::line(issuer, account, xrpl::toCurrency("USD")).key; EXPECT_CALL(*backend_, doFetchLedgerObject(usdRippleStateKk, testing::_, testing::_)) .WillOnce(Return(usdRippleState.getSerializer().peekData())); @@ -1051,7 +1049,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::toCurrency(kLPTOKEN_CURRENCY), ammAccount, true, yield diff --git a/tests/unit/rpc/handlers/AMMInfoTests.cpp b/tests/unit/rpc/handlers/AMMInfoTests.cpp index 6dafe2fd8..d59b30bfe 100644 --- a/tests/unit/rpc/handlers/AMMInfoTests.cpp +++ b/tests/unit/rpc/handlers/AMMInfoTests.cpp @@ -46,7 +46,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -156,7 +155,7 @@ TEST_P(AMMInfoParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -179,7 +178,7 @@ TEST_F(RPCAMMInfoHandlerTest, AccountNotFound) ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}", @@ -207,7 +206,7 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotExist) ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -232,7 +231,7 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotInDBIsMalformed) ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -260,7 +259,7 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotFoundMissingAmmField) ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(accountRoot.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -284,12 +283,12 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAmmBlobNotFound) { auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); auto const accountKey = getAccountKey(kAMM_ACCOUNT); - auto const ammId = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammId); + auto const ammId = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammId); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto ammObj = createAmmObject(kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2); - accountRoot.setFieldH256(ripple::sfAMMID, ripple::uint256{kAMM_ID}); + auto ammObj = createAmmObject(kAMM_ACCOUNT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2); + accountRoot.setFieldH256(xrpl::sfAMMID, xrpl::uint256{kAMM_ID}); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) @@ -297,7 +296,7 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAmmBlobNotFound) ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -322,13 +321,12 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAccBlobNotFound) auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); auto const accountKey = getAccountKey(kAMM_ACCOUNT); auto const account2Key = getAccountKey(kAMM_ACCOUNT2); - auto const ammId = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammId); + auto const ammId = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammId); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const ammObj = - createAmmObject(kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2); - accountRoot.setFieldH256(ripple::sfAMMID, ammId); + auto const ammObj = createAmmObject(kAMM_ACCOUNT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2); + accountRoot.setFieldH256(xrpl::sfAMMID, ammId); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) @@ -338,7 +336,7 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAccBlobNotFound) ON_CALL(*backend_, doFetchLedgerObject(account2Key, testing::_, testing::_)) .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -363,16 +361,16 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY + kAMM_ACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -385,7 +383,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -397,7 +395,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto expectedResult = json::parse( + auto expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -439,19 +437,19 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = ripple::keylet::line(account2, account1, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account2, account1, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const account2Root = createAccountRootObject(kAMM_ACCOUNT2, 0, 2, 300, 2, kINDEX1, 2); auto const ammObj = createAmmObject( - kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT, kLP_ISSUE_CURRENCY + kAMM_ACCOUNT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT, kLP_ISSUE_CURRENCY ); auto const lptCurrency = createLptCurrency("XRP", "JPY"); - auto const accountHoldsKeylet = ripple::keylet::line(account2, account2, lptCurrency); + auto const accountHoldsKeylet = xrpl::keylet::line(account2, account2, lptCurrency); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustline = createRippleStateLedgerObject( kLP_ISSUE_CURRENCY, kAMM_ACCOUNT, 12, kAMM_ACCOUNT2, 1000, kAMM_ACCOUNT, 2000, kINDEX1, 2 @@ -469,7 +467,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) ON_CALL(*backend_, doFetchLedgerObject(accountHoldsKeylet.key, kSEQ, _)) .WillByDefault(Return(trustline.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}", @@ -483,7 +481,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto const expectedResult = json::parse( + auto const expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -525,16 +523,16 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), kLP_ISSUE_CURRENCY + kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -547,7 +545,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -559,7 +557,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto const expectedResult = json::parse( + auto const expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -601,14 +599,14 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject(kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -621,7 +619,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) ON_CALL(*backend_, doFetchLedgerObject(feesKey, kSEQ, _)).WillByDefault(Return(feesObj)); ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -633,7 +631,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto const expectedResult = json::parse( + auto const expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -682,23 +680,23 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue1LineKey = ripple::keylet::line(account1, account1, ripple::to_currency("USD")).key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue1LineKey = xrpl::keylet::line(account1, account1, xrpl::toCurrency("USD")).key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject(kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); // note: frozen flag will not be used for trustline1 because issuer == account auto const trustline1BalanceFrozen = createRippleStateLedgerObject( - "USD", kAMM_ACCOUNT, 8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX1, 2, ripple::lsfGlobalFreeze + "USD", kAMM_ACCOUNT, 8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( - "JPY", kAMM_ACCOUNT, 12, kAMM_ACCOUNT2, 1000, kAMM_ACCOUNT, 2000, kINDEX1, 2, ripple::lsfGlobalFreeze + "JPY", kAMM_ACCOUNT, 12, kAMM_ACCOUNT2, 1000, kAMM_ACCOUNT, 2000, kINDEX1, 2, xrpl::lsfGlobalFreeze ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -714,7 +712,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) .WillByDefault(Return(trustline2BalanceFrozen.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -726,7 +724,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto const expectedResult = json::parse( + auto const expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -775,24 +773,24 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue1LineKey = ripple::keylet::line(account1, account1, ripple::to_currency("USD")).key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue1LineKey = xrpl::keylet::line(account1, account1, xrpl::toCurrency("USD")).key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; // asset1 will be frozen because flag set here - auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2); + auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject(kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); // note: frozen flag will not be used for trustline1 because issuer == account auto const trustline1BalanceFrozen = createRippleStateLedgerObject( - "USD", kAMM_ACCOUNT, 8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX1, 2, ripple::lsfGlobalFreeze + "USD", kAMM_ACCOUNT, 8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( - "JPY", kAMM_ACCOUNT, 12, kAMM_ACCOUNT2, 1000, kAMM_ACCOUNT, 2000, kINDEX1, 2, ripple::lsfGlobalFreeze + "JPY", kAMM_ACCOUNT, 12, kAMM_ACCOUNT2, 1000, kAMM_ACCOUNT, 2000, kINDEX1, 2, xrpl::lsfGlobalFreeze ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -808,7 +806,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) .WillByDefault(Return(trustline2BalanceFrozen.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -820,7 +818,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto const expectedResult = json::parse( + auto const expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -869,16 +867,16 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY + kAMM_ACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject("JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0); @@ -894,7 +892,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) .WillByDefault(Return(trustlineBalance.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -906,7 +904,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto expectedResult = json::parse( + auto expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -948,18 +946,18 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY + kAMM_ACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); ammAddVoteSlot(ammObj, account1, 2, 4); ammAddVoteSlot(ammObj, account2, 4, 2); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject("JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0); @@ -975,7 +973,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) .WillByDefault(Return(trustlineBalance.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -987,7 +985,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto expectedResult = json::parse( + auto expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -1043,20 +1041,20 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::toCurrency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY + kAMM_ACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); ammSetAuctionSlot( - ammObj, account2, ripple::amountFromString(ripple::xrpIssue(), "100"), 2, 25 * 3600, {account1, account2} + ammObj, account2, xrpl::amountFromString(xrpl::xrpIssue(), "100"), 2, 25 * 3600, {account1, account2} ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject("JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0); @@ -1072,7 +1070,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) ON_CALL(*backend_, doFetchLedgerObject(issue2LineKey, kSEQ, _)) .WillByDefault(Return(trustlineBalance.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "amm_account": "{}" @@ -1084,7 +1082,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto expectedResult = json::parse( + auto expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -1144,17 +1142,17 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const issue1 = ripple::Issue(ripple::to_currency("JPY"), account1); - auto const issue2 = ripple::Issue(ripple::to_currency("USD"), account2); - auto const ammKeylet = ripple::keylet::amm(issue1, issue2); + auto const issue1 = xrpl::Issue(xrpl::toCurrency("JPY"), account1); + auto const issue2 = xrpl::Issue(xrpl::toCurrency("USD"), account2); + auto const ammKeylet = xrpl::keylet::amm(issue1, issue2); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject(kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT, "USD", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLP_ISSUE_CURRENCY}, account1}; + auto const auctionIssue = xrpl::Issue{xrpl::Currency{kLP_ISSUE_CURRENCY}, account1}; ammSetAuctionSlot( - ammObj, account2, ripple::amountFromString(auctionIssue, "100"), 2, 25 * 3600, {account1, account2} + ammObj, account2, xrpl::amountFromString(auctionIssue, "100"), 2, 25 * 3600, {account1, account2} ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKeylet.key); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKeylet.key); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(getAccountKey(account1), testing::_, testing::_)) @@ -1164,7 +1162,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "asset": {{ @@ -1184,7 +1182,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto expectedResult = json::parse( + auto expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ @@ -1257,18 +1255,18 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const issue1 = ripple::Issue(ripple::to_currency("USD"), account1); - auto const issue2 = ripple::Issue(ripple::to_currency("JPY"), account2); - auto const ammKeylet = ripple::keylet::amm(issue1, issue2); + auto const issue1 = xrpl::Issue(xrpl::toCurrency("USD"), account1); + auto const issue2 = xrpl::Issue(xrpl::toCurrency("JPY"), account2); + auto const ammKeylet = xrpl::keylet::amm(issue1, issue2); // Note: order in the AMM object is different from the input auto ammObj = createAmmObject(kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT, "USD", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLP_ISSUE_CURRENCY}, account1}; + auto const auctionIssue = xrpl::Issue{xrpl::Currency{kLP_ISSUE_CURRENCY}, account1}; ammSetAuctionSlot( - ammObj, account2, ripple::amountFromString(auctionIssue, "100"), 2, 25 * 3600, {account1, account2} + ammObj, account2, xrpl::amountFromString(auctionIssue, "100"), 2, 25 * 3600, {account1, account2} ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKeylet.key); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKeylet.key); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(getAccountKey(account1), testing::_, testing::_)) @@ -1278,7 +1276,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) ON_CALL(*backend_, doFetchLedgerObject(ammKeylet.key, testing::_, testing::_)) .WillByDefault(Return(ammObj.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "asset": {{ @@ -1298,7 +1296,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) auto const handler = AnyHandler{AMMInfoHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); - auto expectedResult = json::parse( + auto expectedResult = boost::json::parse( fmt::format( R"JSON({{ "amm": {{ diff --git a/tests/unit/rpc/handlers/AccountChannelsTests.cpp b/tests/unit/rpc/handlers/AccountChannelsTests.cpp index ed9a5aee2..ec3a24746 100644 --- a/tests/unit/rpc/handlers/AccountChannelsTests.cpp +++ b/tests/unit/rpc/handlers/AccountChannelsTests.cpp @@ -42,7 +42,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -68,7 +67,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitNotInt) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -89,7 +88,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitNegative) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -110,7 +109,7 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitZero) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -131,7 +130,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonHexLedgerHash) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -154,7 +153,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonStringLedgerHash) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -177,7 +176,7 @@ TEST_F(RPCAccountChannelsHandlerTest, InvalidLedgerIndexString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -200,7 +199,7 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerNotString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -225,7 +224,7 @@ TEST_F(RPCAccountChannelsHandlerTest, InvalidMarker) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -243,7 +242,7 @@ TEST_F(RPCAccountChannelsHandlerTest, InvalidMarker) }); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -265,7 +264,7 @@ TEST_F(RPCAccountChannelsHandlerTest, AccountInvalidFormat) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })JSON"); auto const output = handler.process(input, Context{yield}); @@ -281,7 +280,7 @@ TEST_F(RPCAccountChannelsHandlerTest, AccountNotString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "account": 12 })JSON"); auto const output = handler.process(input, Context{yield}); @@ -297,11 +296,11 @@ TEST_F(RPCAccountChannelsHandlerTest, AccountNotString) TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -326,9 +325,9 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -350,9 +349,9 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerStringIndex) TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -377,9 +376,9 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -405,7 +404,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIndex2) // no need to check from db,call fetchLedgerBySequence 0 time // differ from previous logic EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -428,12 +427,12 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCAccountChannelsHandlerTest, NonExistAccount) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -491,15 +490,15 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index containing 2 indexes - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -507,13 +506,13 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) // return two payment channel objects std::vector bbs; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -525,7 +524,7 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) auto handler = AnyHandler{AccountChannelsHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCORRECT_OUTPUT), *output.result); }); } @@ -537,26 +536,25 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 50; while ((repetitions--) != 0) { indexes.emplace_back(kINDEX1); - ripple::STObject const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); bbs.push_back(channel.getSerializer().peekData()); } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); // it should not appear in return marker,marker is the current page - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -566,7 +564,7 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) runSpawn([this](auto yield) { auto handler = AnyHandler{AccountChannelsHandler{this->backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -584,7 +582,7 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -599,7 +597,7 @@ TEST_F(RPCAccountChannelsHandlerTest, UseLimit) runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountChannelsHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -621,22 +619,21 @@ TEST_F(RPCAccountChannelsHandlerTest, UseDestination) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; // 10 pay channel to Account2 auto repetitions = 10; while ((repetitions--) != 0) { indexes.emplace_back(kINDEX1); - ripple::STObject const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); bbs.push_back(channel.getSerializer().peekData()); } @@ -644,12 +641,11 @@ TEST_F(RPCAccountChannelsHandlerTest, UseDestination) repetitions = 20; while ((repetitions--) != 0) { indexes.emplace_back(kINDEX1); - ripple::STObject const channel = - createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT3, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT3, 100, 10, 32, kTXN_ID, 28); bbs.push_back(channel.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -657,7 +653,7 @@ TEST_F(RPCAccountChannelsHandlerTest, UseDestination) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -684,19 +680,19 @@ TEST_F(RPCAccountChannelsHandlerTest, EmptyChannel) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -758,15 +754,15 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -774,16 +770,16 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) // return two payment channel objects std::vector bbs; - ripple::STObject channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); - channel1.setFieldU32(ripple::sfExpiration, 100); - channel1.setFieldU32(ripple::sfCancelAfter, 200); - channel1.setFieldU32(ripple::sfSourceTag, 300); - channel1.setFieldU32(ripple::sfDestinationTag, 400); + xrpl::STObject channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + channel1.setFieldU32(xrpl::sfExpiration, 100); + channel1.setFieldU32(xrpl::sfCancelAfter, 200); + channel1.setFieldU32(xrpl::sfSourceTag, 300); + channel1.setFieldU32(xrpl::sfDestinationTag, 400); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -795,7 +791,7 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) auto handler = AnyHandler{AccountChannelsHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCORRECT_OUTPUT), *output.result); }); } @@ -803,11 +799,11 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto ownerDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto ownerDirKk = xrpl::keylet::ownerDir(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -817,10 +813,10 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); std::vector bbs; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); // owner dir contains 10 indexes int objectsCount = 10; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -833,21 +829,21 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); // first page 's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); // second page's next page is 0 - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -873,10 +869,10 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; + auto accountKk = xrpl::keylet::account(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -886,9 +882,9 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); std::vector bbs; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); int objectsCount = kLIMIT; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -896,15 +892,15 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -935,15 +931,15 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index containing 2 indexes - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -951,13 +947,13 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) // return two payment channel objects std::vector bbs; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -983,15 +979,15 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index containing 2 indexes - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -999,13 +995,13 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) // return two payment channel objects std::vector bbs; - ripple::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", diff --git a/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp b/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp index e2dafa047..53c1cbafd 100644 --- a/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp +++ b/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp @@ -43,8 +43,6 @@ using namespace rpc; using namespace data; using namespace testing; -namespace json = boost::json; - namespace { constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; @@ -73,7 +71,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, AccountNotExist) ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -95,9 +93,9 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaIntSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -121,9 +119,9 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaStringSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(12, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(12, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -147,10 +145,10 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -191,13 +189,12 @@ TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 - ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -218,7 +215,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -230,7 +227,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, DefaultParameter) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUTPUT)); }); } @@ -239,13 +236,13 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderHash) // return valid ledgerHeader auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -255,7 +252,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderHash) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -280,11 +277,11 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderSeq) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence(ledgerSeq, _)).WillByDefault(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, ledgerSeq, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, ledgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -294,7 +291,7 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderSeq) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", diff --git a/tests/unit/rpc/handlers/AccountInfoTests.cpp b/tests/unit/rpc/handlers/AccountInfoTests.cpp index 9bf629319..ccabdd9f4 100644 --- a/tests/unit/rpc/handlers/AccountInfoTests.cpp +++ b/tests/unit/rpc/handlers/AccountInfoTests.cpp @@ -45,7 +45,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -151,7 +150,7 @@ TEST_P(AccountInfoParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2}); ASSERT_FALSE(output); @@ -171,7 +170,7 @@ TEST_F(AccountInfoParameterTest, ApiV1SignerListIsNotBool) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(kREQ_JSON); + auto const req = boost::json::parse(kREQ_JSON); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1}); ASSERT_FALSE(output); @@ -184,9 +183,9 @@ TEST_F(AccountInfoParameterTest, ApiV1SignerListIsNotBool) TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaIntSequence) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerBySequence(30, _)).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence(30, _)).WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -210,7 +209,7 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaStringSequence) // return empty ledgerHeader EXPECT_CALL(*backend_, fetchLedgerBySequence(30, _)).WillOnce(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -232,10 +231,10 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -263,7 +262,7 @@ TEST_F(RPCAccountInfoHandlerTest, AccountNotExist) ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -290,7 +289,7 @@ TEST_F(RPCAccountInfoHandlerTest, AccountInvalid) ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -314,11 +313,11 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsInvalid) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); - auto signersKey = ripple::keylet::signers(account).key; + auto signersKey = xrpl::keylet::signers(account).key; ON_CALL(*backend_, doFetchLedgerObject(signersKey, 30, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::DisallowIncoming, _)).WillOnce(Return(false)); @@ -326,7 +325,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsInvalid) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -413,11 +412,11 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV2) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); - auto signersKey = ripple::keylet::signers(account).key; + auto signersKey = xrpl::keylet::signers(account).key; ON_CALL(*backend_, doFetchLedgerObject(signersKey, 30, _)) .WillByDefault(Return(createSignerLists({{kACCOUNT1, 1}, {kACCOUNT2, 1}}).getSerializer().peekData())); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::DisallowIncoming, _)).WillOnce(Return(false)); @@ -425,7 +424,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV2) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -438,7 +437,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV2) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(expectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(expectedOutput)); }); } @@ -510,11 +509,11 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV1) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); - auto signersKey = ripple::keylet::signers(account).key; + auto signersKey = xrpl::keylet::signers(account).key; ON_CALL(*backend_, doFetchLedgerObject(signersKey, 30, _)) .WillByDefault(Return(createSignerLists({{kACCOUNT1, 1}, {kACCOUNT2, 1}}).getSerializer().peekData())); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::DisallowIncoming, _)).WillOnce(Return(false)); @@ -522,7 +521,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV1) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -535,7 +534,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV1) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 1}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(expectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(expectedOutput)); }); } @@ -579,12 +578,12 @@ TEST_F(RPCAccountInfoHandlerTest, Flags) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject( kACCOUNT, - ripple::lsfDefaultRipple | ripple::lsfGlobalFreeze | ripple::lsfRequireDestTag | ripple::lsfRequireAuth | - ripple::lsfDepositAuth | ripple::lsfDisableMaster | ripple::lsfDisallowXRP | ripple::lsfNoFreeze | - ripple::lsfPasswordSpent, + xrpl::lsfDefaultRipple | xrpl::lsfGlobalFreeze | xrpl::lsfRequireDestTag | xrpl::lsfRequireAuth | + xrpl::lsfDepositAuth | xrpl::lsfDisableMaster | xrpl::lsfDisallowXRP | xrpl::lsfNoFreeze | + xrpl::lsfPasswordSpent, 2, 200, 2, @@ -598,7 +597,7 @@ TEST_F(RPCAccountInfoHandlerTest, Flags) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -610,7 +609,7 @@ TEST_F(RPCAccountInfoHandlerTest, Flags) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(expectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(expectedOutput)); }); } @@ -620,7 +619,7 @@ TEST_F(RPCAccountInfoHandlerTest, IdentAndSignerListsFalse) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); @@ -629,7 +628,7 @@ TEST_F(RPCAccountInfoHandlerTest, IdentAndSignerListsFalse) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "ident": "{}" @@ -651,7 +650,7 @@ TEST_F(RPCAccountInfoHandlerTest, EmptySignerLists) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(accountRoot.getSerializer().peekData())); @@ -659,13 +658,13 @@ TEST_F(RPCAccountInfoHandlerTest, EmptySignerLists) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::Clawback, _)).WillOnce(Return(false)); EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(false)); - auto signersKey = ripple::keylet::signers(account).key; + auto signersKey = xrpl::keylet::signers(account).key; ON_CALL(*backend_, doFetchLedgerObject(signersKey, 30, _)).WillByDefault(Return(std::optional{})); // Once for signer object, once for keylet EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -734,13 +733,13 @@ TEST_F(RPCAccountInfoHandlerTest, DisallowIncoming) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject( kACCOUNT, - ripple::lsfDefaultRipple | ripple::lsfGlobalFreeze | ripple::lsfRequireDestTag | ripple::lsfRequireAuth | - ripple::lsfDepositAuth | ripple::lsfDisableMaster | ripple::lsfDisallowXRP | ripple::lsfNoFreeze | - ripple::lsfPasswordSpent | ripple::lsfDisallowIncomingNFTokenOffer | ripple::lsfDisallowIncomingCheck | - ripple::lsfDisallowIncomingPayChan | ripple::lsfDisallowIncomingTrustline, + xrpl::lsfDefaultRipple | xrpl::lsfGlobalFreeze | xrpl::lsfRequireDestTag | xrpl::lsfRequireAuth | + xrpl::lsfDepositAuth | xrpl::lsfDisableMaster | xrpl::lsfDisallowXRP | xrpl::lsfNoFreeze | + xrpl::lsfPasswordSpent | xrpl::lsfDisallowIncomingNFTokenOffer | xrpl::lsfDisallowIncomingCheck | + xrpl::lsfDisallowIncomingPayChan | xrpl::lsfDisallowIncomingTrustline, 2, 200, 2, @@ -754,7 +753,7 @@ TEST_F(RPCAccountInfoHandlerTest, DisallowIncoming) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(false)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -766,7 +765,7 @@ TEST_F(RPCAccountInfoHandlerTest, DisallowIncoming) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(expectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(expectedOutput)); }); } @@ -813,12 +812,12 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; auto const accountRoot = createAccountRootObject( kACCOUNT, - ripple::lsfDefaultRipple | ripple::lsfGlobalFreeze | ripple::lsfRequireDestTag | ripple::lsfRequireAuth | - ripple::lsfDepositAuth | ripple::lsfDisableMaster | ripple::lsfDisallowXRP | ripple::lsfNoFreeze | - ripple::lsfPasswordSpent | ripple::lsfAllowTrustLineClawback | ripple::lsfAllowTrustLineLocking, + xrpl::lsfDefaultRipple | xrpl::lsfGlobalFreeze | xrpl::lsfRequireDestTag | xrpl::lsfRequireAuth | + xrpl::lsfDepositAuth | xrpl::lsfDisableMaster | xrpl::lsfDisallowXRP | xrpl::lsfNoFreeze | + xrpl::lsfPasswordSpent | xrpl::lsfAllowTrustLineClawback | xrpl::lsfAllowTrustLineLocking, 2, 200, 2, @@ -832,7 +831,7 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(_, Amendments::TokenEscrow, _)).WillOnce(Return(true)); EXPECT_CALL(*backend_, doFetchLedgerObject); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -844,7 +843,7 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(expectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(expectedOutput)); }); } diff --git a/tests/unit/rpc/handlers/AccountLinesTests.cpp b/tests/unit/rpc/handlers/AccountLinesTests.cpp index 14d256331..72d9411ac 100644 --- a/tests/unit/rpc/handlers/AccountLinesTests.cpp +++ b/tests/unit/rpc/handlers/AccountLinesTests.cpp @@ -45,7 +45,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -76,7 +75,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonHexLedgerHash) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -99,7 +98,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonStringLedgerHash) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -122,7 +121,7 @@ TEST_F(RPCAccountLinesHandlerTest, InvalidLedgerIndexString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -145,7 +144,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerNotString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -170,7 +169,7 @@ TEST_F(RPCAccountLinesHandlerTest, InvalidMarker) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -188,7 +187,7 @@ TEST_F(RPCAccountLinesHandlerTest, InvalidMarker) }); runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -210,7 +209,7 @@ TEST_F(RPCAccountLinesHandlerTest, AccountInvalidFormat) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })JSON" @@ -228,7 +227,7 @@ TEST_F(RPCAccountLinesHandlerTest, AccountNotString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "account": 12 })JSON" @@ -246,7 +245,7 @@ TEST_F(RPCAccountLinesHandlerTest, PeerInvalidFormat) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "peer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" @@ -264,7 +263,7 @@ TEST_F(RPCAccountLinesHandlerTest, PeerNotString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "peer": 12 @@ -283,7 +282,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitNotInt) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "limit": "t" @@ -301,7 +300,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitNegative) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "limit": -1 @@ -319,7 +318,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitZero) { runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "limit": 0 @@ -337,11 +336,11 @@ TEST_F(RPCAccountLinesHandlerTest, LimitZero) TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -366,9 +365,9 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -390,9 +389,9 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerStringIndex) TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -417,9 +416,9 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -445,7 +444,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIndex2) // no need to check from db, call fetchLedgerBySequence 0 time // differ from previous logic EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -468,12 +467,12 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCAccountLinesHandlerTest, NonExistAccount) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -501,15 +500,15 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index containing 2 indexes - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -525,7 +524,7 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -565,7 +564,7 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest) auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } @@ -577,14 +576,14 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 50; @@ -594,9 +593,9 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123); bbs.push_back(line.getSerializer().peekData()); } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); // it should not appear in return marker,marker is the current page - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -606,7 +605,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) runSpawn([this](auto yield) { auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -624,7 +623,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -639,7 +638,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountLinesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -661,14 +660,14 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; // 10 lines to Account2 @@ -689,7 +688,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination) bbs.push_back(line.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -697,7 +696,7 @@ TEST_F(RPCAccountLinesHandlerTest, UseDestination) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -724,19 +723,19 @@ TEST_F(RPCAccountLinesHandlerTest, EmptyChannel) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -795,16 +794,16 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -813,22 +812,22 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) // return few trust lines std::vector bbs; auto line1 = createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0); - line1.setFlag(ripple::lsfHighAuth); - line1.setFlag(ripple::lsfHighNoRipple); - line1.setFlag(ripple::lsfHighFreeze); - line1.setFlag(ripple::lsfHighDeepFreeze); + line1.setFlag(xrpl::lsfHighAuth); + line1.setFlag(xrpl::lsfHighNoRipple); + line1.setFlag(xrpl::lsfHighFreeze); + line1.setFlag(xrpl::lsfHighDeepFreeze); bbs.push_back(line1.getSerializer().peekData()); auto line2 = createRippleStateLedgerObject("USD", kACCOUNT2, 20, kACCOUNT, 200, kACCOUNT2, 400, kTXN_ID, 0); - line2.setFlag(ripple::lsfLowAuth); - line2.setFlag(ripple::lsfLowNoRipple); - line2.setFlag(ripple::lsfLowFreeze); - line2.setFlag(ripple::lsfLowDeepFreeze); + line2.setFlag(xrpl::lsfLowAuth); + line2.setFlag(xrpl::lsfLowNoRipple); + line2.setFlag(xrpl::lsfLowFreeze); + line2.setFlag(xrpl::lsfLowDeepFreeze); bbs.push_back(line2.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -840,7 +839,7 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCORRECT_OUTPUT), *output.result); }); } @@ -883,16 +882,16 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -900,17 +899,17 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) // return few trust lines std::vector bbs; auto line1 = createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0); - line1.setFlag(ripple::lsfHighAuth); - line1.setFlag(ripple::lsfHighFreeze); + line1.setFlag(xrpl::lsfHighAuth); + line1.setFlag(xrpl::lsfHighFreeze); bbs.push_back(line1.getSerializer().peekData()); auto line2 = createRippleStateLedgerObject("USD", kACCOUNT2, 20, kACCOUNT, 200, kACCOUNT2, 400, kTXN_ID, 0); - line2.setFlag(ripple::lsfLowAuth); - line2.setFlag(ripple::lsfLowFreeze); + line2.setFlag(xrpl::lsfLowAuth); + line2.setFlag(xrpl::lsfLowFreeze); bbs.push_back(line2.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -922,7 +921,7 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCORRECT_OUTPUT), *output.result); }); } @@ -930,11 +929,11 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto ownerDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto ownerDirKk = xrpl::keylet::ownerDir(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -948,7 +947,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) // owner dir contains 10 indexes int objectsCount = 10; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -961,21 +960,21 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); // first page's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); // second page's next page is 0 - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1001,10 +1000,10 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) TEST_F(RPCAccountLinesHandlerTest, MarkerInput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; + auto accountKk = xrpl::keylet::account(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -1016,7 +1015,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput) std::vector bbs; auto const line = createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0); int objectsCount = kLIMIT; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -1024,15 +1023,15 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1063,15 +1062,15 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index containing 2 indexes - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -1087,7 +1086,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1131,7 +1130,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin) auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } @@ -1142,15 +1141,15 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch account object return something auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto owneDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto owneDirKk = xrpl::keylet::ownerDir(account).key; auto fake = Blob{'f', 'a', 'k', 'e'}; // return a non empty account ON_CALL(*backend_, doFetchLedgerObject(accountKk, testing::_, testing::_)).WillByDefault(Return(fake)); // return owner index containing 2 indexes - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -1166,7 +1165,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1210,7 +1209,7 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax) auto handler = AnyHandler{AccountLinesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } diff --git a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp index 5e1a045e9..bea865029 100644 --- a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp @@ -48,7 +48,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -207,7 +206,7 @@ TEST_P(AccountMPTokenIssuancesParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -221,10 +220,10 @@ TEST_P(AccountMPTokenIssuancesParameterTest, InvalidParams) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -249,9 +248,9 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -274,9 +273,9 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerStringIndex TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -299,8 +298,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByHash) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); - auto const input = json::parse( + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -324,7 +323,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByHash) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByIndex) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -347,11 +346,11 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByIndex) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistAccount) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); // fetch account object return empty EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -379,13 +378,13 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) // return non-empty account auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); // return two mptoken issuance objects - ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -395,7 +394,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) kACCOUNT, 1, std::nullopt, - ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow, + xrpl::lsfMPTCanTrade | xrpl::lsfMPTRequireAuth | xrpl::lsfMPTCanTransfer | xrpl::lsfMPTCanEscrow, kISSUANCE1_OUTSTANDING_AMOUNT, std::nullopt, kISSUANCE1_ASSET_SCALE, @@ -408,7 +407,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) kACCOUNT, 2, kISSUANCE2_METADATA, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -441,12 +440,12 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) kISSUANCE_OUT1, kISSUANCE_OUT2 ); - auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT)); + auto const input = boost::json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT)); auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(expected), *output.result); + EXPECT_EQ(boost::json::parse(expected), *output.result); }); } @@ -457,11 +456,11 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const indexes = std::vector(50, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(50, xrpl::uint256{kISSUANCE_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); @@ -471,8 +470,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -480,7 +479,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(3); runSpawn([this, kLIMIT](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -503,7 +502,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -520,7 +519,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) runSpawn([this](auto yield) { auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -544,13 +543,13 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; - auto const ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; + auto const ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const indexes = std::vector(10, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(10, xrpl::uint256{kISSUANCE_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLIMIT); @@ -562,19 +561,19 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerOutput) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); // mock the first directory page - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ownerDir1.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); // mock the second directory page - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX2); - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX2); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -605,12 +604,12 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const indexes = std::vector(kLIMIT, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(kLIMIT, xrpl::uint256{kISSUANCE_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLIMIT); @@ -620,15 +619,15 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -657,12 +656,12 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -671,7 +670,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) kACCOUNT, 1, std::nullopt, - ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow, + xrpl::lsfMPTCanTrade | xrpl::lsfMPTRequireAuth | xrpl::lsfMPTCanTransfer | xrpl::lsfMPTCanEscrow, kISSUANCE1_OUTSTANDING_AMOUNT, std::nullopt, kISSUANCE1_ASSET_SCALE, @@ -684,7 +683,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) kACCOUNT, 2, kISSUANCE2_METADATA, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -699,7 +698,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -732,7 +731,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } @@ -742,12 +741,12 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -756,7 +755,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) kACCOUNT, 1, std::nullopt, - ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow, + xrpl::lsfMPTCanTrade | xrpl::lsfMPTRequireAuth | xrpl::lsfMPTCanTransfer | xrpl::lsfMPTCanEscrow, kISSUANCE1_OUTSTANDING_AMOUNT, std::nullopt, kISSUANCE1_ASSET_SCALE, @@ -769,7 +768,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) kACCOUNT, 2, kISSUANCE2_METADATA, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -784,7 +783,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -817,7 +816,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } @@ -827,15 +826,15 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, EmptyResult) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kISSUANCE_INDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kISSUANCE_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -852,22 +851,22 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, EmptyResult) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) { - uint32_t const mutableFlags1 = ripple::lsmfMPTCanMutateCanLock | ripple::lsmfMPTCanMutateRequireAuth | - ripple::lsmfMPTCanMutateCanEscrow | ripple::lsmfMPTCanMutateCanTrade; + uint32_t const mutableFlags1 = xrpl::lsmfMPTCanMutateCanLock | xrpl::lsmfMPTCanMutateRequireAuth | + xrpl::lsmfMPTCanMutateCanEscrow | xrpl::lsmfMPTCanMutateCanTrade; - uint32_t const mutableFlags2 = ripple::lsmfMPTCanMutateCanTransfer | ripple::lsmfMPTCanMutateCanClawback | - ripple::lsmfMPTCanMutateMetadata | ripple::lsmfMPTCanMutateTransferFee; + uint32_t const mutableFlags2 = xrpl::lsmfMPTCanMutateCanTransfer | xrpl::lsmfMPTCanMutateCanClawback | + xrpl::lsmfMPTCanMutateMetadata | xrpl::lsmfMPTCanMutateTransferFee; auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -876,7 +875,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) kACCOUNT, 3, std::nullopt, - ripple::lsfMPTCanTransfer, + xrpl::lsfMPTCanTransfer, kISSUANCE1_OUTSTANDING_AMOUNT, kISSUANCE1_TRANSFER_FEE, std::nullopt, @@ -892,7 +891,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) kACCOUNT, 5, kISSUANCE2_METADATA, - ripple::lsfMPTCanTransfer, + xrpl::lsfMPTCanTransfer, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -908,7 +907,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -968,7 +967,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } @@ -985,13 +984,13 @@ static auto generateSingleFlagTests() { return std::vector{ - {.testName = "Locked", .flag = ripple::lsfMPTLocked, .expectedJsonKey = "mpt_locked"}, - {.testName = "CanLock", .flag = ripple::lsfMPTCanLock, .expectedJsonKey = "mpt_can_lock"}, - {.testName = "RequireAuth", .flag = ripple::lsfMPTRequireAuth, .expectedJsonKey = "mpt_require_auth"}, - {.testName = "CanEscrow", .flag = ripple::lsfMPTCanEscrow, .expectedJsonKey = "mpt_can_escrow"}, - {.testName = "CanTrade", .flag = ripple::lsfMPTCanTrade, .expectedJsonKey = "mpt_can_trade"}, - {.testName = "CanTransfer", .flag = ripple::lsfMPTCanTransfer, .expectedJsonKey = "mpt_can_transfer"}, - {.testName = "CanClawback", .flag = ripple::lsfMPTCanClawback, .expectedJsonKey = "mpt_can_clawback"}, + {.testName = "Locked", .flag = xrpl::lsfMPTLocked, .expectedJsonKey = "mpt_locked"}, + {.testName = "CanLock", .flag = xrpl::lsfMPTCanLock, .expectedJsonKey = "mpt_can_lock"}, + {.testName = "RequireAuth", .flag = xrpl::lsfMPTRequireAuth, .expectedJsonKey = "mpt_require_auth"}, + {.testName = "CanEscrow", .flag = xrpl::lsfMPTCanEscrow, .expectedJsonKey = "mpt_can_escrow"}, + {.testName = "CanTrade", .flag = xrpl::lsfMPTCanTrade, .expectedJsonKey = "mpt_can_trade"}, + {.testName = "CanTransfer", .flag = xrpl::lsfMPTCanTransfer, .expectedJsonKey = "mpt_can_transfer"}, + {.testName = "CanClawback", .flag = xrpl::lsfMPTCanClawback, .expectedJsonKey = "mpt_can_clawback"}, }; } @@ -1010,11 +1009,11 @@ TEST_P(AccountMPTokenIssuancesImmutableFlagsTest, SingleFlag) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ @@ -1024,7 +1023,7 @@ TEST_P(AccountMPTokenIssuancesImmutableFlagsTest, SingleFlag) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this, &testParams](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -1060,28 +1059,28 @@ generateSingleMutableFlagTests() { return std::vector{ {.testName = "CanMutateCanLock", - .mutableFlag = ripple::lsmfMPTCanMutateCanLock, + .mutableFlag = xrpl::lsmfMPTCanMutateCanLock, .expectedJsonKey = "mpt_can_mutate_can_lock"}, {.testName = "CanMutateRequireAuth", - .mutableFlag = ripple::lsmfMPTCanMutateRequireAuth, + .mutableFlag = xrpl::lsmfMPTCanMutateRequireAuth, .expectedJsonKey = "mpt_can_mutate_require_auth"}, {.testName = "CanMutateCanEscrow", - .mutableFlag = ripple::lsmfMPTCanMutateCanEscrow, + .mutableFlag = xrpl::lsmfMPTCanMutateCanEscrow, .expectedJsonKey = "mpt_can_mutate_can_escrow"}, {.testName = "CanMutateCanTrade", - .mutableFlag = ripple::lsmfMPTCanMutateCanTrade, + .mutableFlag = xrpl::lsmfMPTCanMutateCanTrade, .expectedJsonKey = "mpt_can_mutate_can_trade"}, {.testName = "CanMutateCanTransfer", - .mutableFlag = ripple::lsmfMPTCanMutateCanTransfer, + .mutableFlag = xrpl::lsmfMPTCanMutateCanTransfer, .expectedJsonKey = "mpt_can_mutate_can_transfer"}, {.testName = "CanMutateCanClawback", - .mutableFlag = ripple::lsmfMPTCanMutateCanClawback, + .mutableFlag = xrpl::lsmfMPTCanMutateCanClawback, .expectedJsonKey = "mpt_can_mutate_can_clawback"}, {.testName = "CanMutateMetadata", - .mutableFlag = ripple::lsmfMPTCanMutateMetadata, + .mutableFlag = xrpl::lsmfMPTCanMutateMetadata, .expectedJsonKey = "mpt_can_mutate_metadata"}, {.testName = "CanMutateTransferFee", - .mutableFlag = ripple::lsmfMPTCanMutateTransferFee, + .mutableFlag = xrpl::lsmfMPTCanMutateTransferFee, .expectedJsonKey = "mpt_can_mutate_transfer_fee"}, }; } @@ -1101,11 +1100,11 @@ TEST_P(AccountMPTokenIssuancesMutableFlagsTest, SingleMutableFlag) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{createMptIssuanceObject( @@ -1127,7 +1126,7 @@ TEST_P(AccountMPTokenIssuancesMutableFlagsTest, SingleMutableFlag) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this, &testParams](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" diff --git a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp index 8a254391a..437917c8d 100644 --- a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp @@ -46,7 +46,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -180,7 +179,7 @@ TEST_P(AccountMPTokensParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountMPTokensHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -192,10 +191,10 @@ TEST_P(AccountMPTokensParameterTest, InvalidParams) TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash to return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -219,9 +218,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence to return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -243,9 +242,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerStringIndex) TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence to return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -267,9 +266,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByHash) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -294,7 +293,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByIndex) { // No need to check from db, call fetchLedgerBySequence 0 times EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -316,11 +315,11 @@ TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByIndex) TEST_F(RPCAccountMPTokensHandlerTest, NonExistAccount) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); // fetch account object return empty EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -347,23 +346,23 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kTOKEN_INDEX1}, xrpl::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMpTokenObject( - kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, ripple::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT + kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, xrpl::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT ) .getSerializer() .peekData(), createMpTokenObject( - kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, ripple::lsfMPTAuthorized, std::nullopt + kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() .peekData() @@ -390,11 +389,11 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) kTOKEN_OUT1, kTOKEN_OUT2 ); - auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT)); + auto const input = boost::json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT)); auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(expected), *output.result); + EXPECT_EQ(boost::json::parse(expected), *output.result); }); } @@ -405,24 +404,24 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const indexes = std::vector(50, ripple::uint256{kTOKEN_INDEX1}); + auto const indexes = std::vector(50, xrpl::uint256{kTOKEN_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); for (int i = 0; i < 50; ++i) { - v.push_back(createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + v.push_back(createMpTokenObject(kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) .getSerializer() .peekData()); } return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -430,7 +429,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(3); runSpawn([this, kLIMIT](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -452,7 +451,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) }); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -470,7 +469,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) }); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -496,16 +495,16 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; - auto const ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; + auto const ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const bbs = [&]() { std::vector v; v.reserve(kLIMIT); for (int i = 0; i < kLIMIT; ++i) { - v.push_back(createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + v.push_back(createMpTokenObject(kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) .getSerializer() .peekData()); } @@ -513,24 +512,24 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput) }(); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - std::vector indexes1; + std::vector indexes1; indexes1.reserve(10); for (int i = 0; i < 10; ++i) { indexes1.emplace_back(kTOKEN_INDEX1); } - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX1); + ownerDir1.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX2); - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX2); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -560,24 +559,24 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto const ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; - auto const indexes = std::vector(kLIMIT, ripple::uint256{kTOKEN_INDEX1}); + auto const indexes = std::vector(kLIMIT, xrpl::uint256{kTOKEN_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLIMIT); for (int i = 0; i < kLIMIT; ++i) { - v.push_back(createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + v.push_back(createMpTokenObject(kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) .getSerializer() .peekData()); } return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -585,7 +584,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -613,23 +612,23 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kTOKEN_INDEX1}, xrpl::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMpTokenObject( - kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, ripple::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT + kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, xrpl::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT ) .getSerializer() .peekData(), createMpTokenObject( - kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, ripple::lsfMPTAuthorized, std::nullopt + kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() .peekData() @@ -638,7 +637,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -671,7 +670,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } @@ -681,23 +680,23 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kTOKEN_INDEX1}, xrpl::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); auto const bbs = std::vector{ createMpTokenObject( - kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, ripple::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT + kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, xrpl::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT ) .getSerializer() .peekData(), createMpTokenObject( - kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, ripple::lsfMPTAuthorized, std::nullopt + kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() .peekData() @@ -706,7 +705,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -739,7 +738,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) auto const handler = AnyHandler{AccountMPTokensHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(correctOutput), *output.result); + EXPECT_EQ(boost::json::parse(correctOutput), *output.result); }); } @@ -749,15 +748,15 @@ TEST_F(RPCAccountMPTokensHandlerTest, EmptyResult) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kTOKEN_INDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kTOKEN_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); runSpawn([this](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" diff --git a/tests/unit/rpc/handlers/AccountNFTsTests.cpp b/tests/unit/rpc/handlers/AccountNFTsTests.cpp index 9a9796802..99a4e9cb2 100644 --- a/tests/unit/rpc/handlers/AccountNFTsTests.cpp +++ b/tests/unit/rpc/handlers/AccountNFTsTests.cpp @@ -59,7 +59,6 @@ constexpr auto kMIN_SEQ = 10; using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCAccountNFTsHandlerTest : HandlerBaseTest { @@ -165,7 +164,7 @@ TEST_P(AccountNFTParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountNFTsHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -178,10 +177,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -207,9 +206,9 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaStringIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -235,9 +234,9 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaIntIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -266,7 +265,7 @@ TEST_F(RPCAccountNFTsHandlerTest, AccountNotFound) ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -320,10 +319,10 @@ TEST_F(RPCAccountNFTsHandlerTest, NormalPath) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpageMax(accountID).key; auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); @@ -331,7 +330,7 @@ TEST_F(RPCAccountNFTsHandlerTest, NormalPath) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -343,7 +342,7 @@ TEST_F(RPCAccountNFTsHandlerTest, NormalPath) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } @@ -357,17 +356,17 @@ TEST_F(RPCAccountNFTsHandlerTest, Limit) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpageMax(accountID).key; auto const pageObject = createNftTokenPage(std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, firstPage); ON_CALL(*backend_, doFetchLedgerObject(firstPage, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1 + kLIMIT); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -382,7 +381,7 @@ TEST_F(RPCAccountNFTsHandlerTest, Limit) auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("account_nfts").as_array().size(), 20); - EXPECT_EQ(output.result->as_object().at("marker").as_string(), ripple::strHex(firstPage)); + EXPECT_EQ(output.result->as_object().at("marker").as_string(), xrpl::strHex(firstPage)); }); } @@ -394,17 +393,17 @@ TEST_F(RPCAccountNFTsHandlerTest, Marker) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAGE}, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAGE}, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -430,10 +429,10 @@ TEST_F(RPCAccountNFTsHandlerTest, InvalidMarker) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -461,10 +460,10 @@ TEST_F(RPCAccountNFTsHandlerTest, AccountWithNoNFT) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -488,17 +487,17 @@ TEST_F(RPCAccountNFTsHandlerTest, invalidPage) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAGE}, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAGE}, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -555,10 +554,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitLessThanMin) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpageMax(accountID).key; auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); @@ -566,7 +565,7 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitLessThanMin) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -580,7 +579,7 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitLessThanMin) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } @@ -621,10 +620,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitMoreThanMax) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpageMax(accountID).key; auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); @@ -632,7 +631,7 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitMoreThanMax) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -646,6 +645,6 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitMoreThanMax) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } diff --git a/tests/unit/rpc/handlers/AccountObjectsTests.cpp b/tests/unit/rpc/handlers/AccountObjectsTests.cpp index 8b723b5d4..0d801ef4c 100644 --- a/tests/unit/rpc/handlers/AccountObjectsTests.cpp +++ b/tests/unit/rpc/handlers/AccountObjectsTests.cpp @@ -49,7 +49,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -209,7 +208,7 @@ TEST_P(AccountObjectsParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountObjectsHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -221,9 +220,9 @@ TEST_P(AccountObjectsParameterTest, InvalidParams) TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaIntSequence) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -247,7 +246,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaStringSequence) // return empty ledgerHeader EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillOnce(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -269,10 +268,10 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -299,7 +298,7 @@ TEST_F(RPCAccountObjectsHandlerTest, AccountNotExist) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -355,16 +354,16 @@ TEST_F(RPCAccountObjectsHandlerTest, DefaultParameterNoNFTFound) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -373,7 +372,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DefaultParameterNoNFTFound) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -386,7 +385,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DefaultParameterNoNFTFound) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -396,19 +395,19 @@ TEST_F(RPCAccountObjectsHandlerTest, Limit) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); static constexpr auto kLIMIT = 10; auto count = kLIMIT * 2; // put 20 items in owner dir, but only return 10 - auto const ownerDir = createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kINDEX1}), kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject(std::vector(count, xrpl::uint256{kINDEX1}), kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -419,7 +418,7 @@ TEST_F(RPCAccountObjectsHandlerTest, Limit) } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -444,15 +443,15 @@ TEST_F(RPCAccountObjectsHandlerTest, Marker) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); static constexpr auto kLIMIT = 20; static constexpr auto kPAGE = 2; auto count = kLIMIT; - auto const ownerDir = createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kINDEX1}), kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - auto const hintIndex = ripple::keylet::page(ownerDirKk, kPAGE).key; + auto const ownerDir = createOwnerDirLedgerObject(std::vector(count, xrpl::uint256{kINDEX1}), kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const hintIndex = xrpl::keylet::page(ownerDirKk, kPAGE).key; EXPECT_CALL(*backend_, doFetchLedgerObject(hintIndex, 30, _)) .Times(2) .WillRepeatedly(Return(ownerDir.getSerializer().peekData())); @@ -465,7 +464,7 @@ TEST_F(RPCAccountObjectsHandlerTest, Marker) } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -492,23 +491,23 @@ TEST_F(RPCAccountObjectsHandlerTest, MultipleDirNoNFT) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); static constexpr auto kCOUNT = 10; static constexpr auto kNEXTPAGE = 1; auto cc = kCOUNT; - auto ownerDir = createOwnerDirLedgerObject(std::vector(cc, ripple::uint256{kINDEX1}), kINDEX1); + auto ownerDir = createOwnerDirLedgerObject(std::vector(cc, xrpl::uint256{kINDEX1}), kINDEX1); // set next page - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXTPAGE); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; - auto const page1 = ripple::keylet::page(ownerDirKk, kNEXTPAGE).key; + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXTPAGE); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; + auto const page1 = xrpl::keylet::page(ownerDirKk, kNEXTPAGE).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(page1, 30, _)).WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -521,7 +520,7 @@ TEST_F(RPCAccountObjectsHandlerTest, MultipleDirNoNFT) } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -547,16 +546,16 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilter) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -566,10 +565,10 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilter) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(line1.getSerializer().peekData()); @@ -577,7 +576,7 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilter) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -601,16 +600,16 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterAmmType) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -618,12 +617,12 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterAmmType) auto const line1 = createRippleStateLedgerObject("USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0); bbs.push_back(line1.getSerializer().peekData()); - auto const ammObject = createAmmObject(kACCOUNT, "XRP", toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2); + auto const ammObject = createAmmObject(kACCOUNT, "XRP", toBase58(xrpl::xrpAccount()), "JPY", kACCOUNT2); bbs.push_back(ammObject.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -649,16 +648,16 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -667,10 +666,10 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(line1.getSerializer().peekData()); @@ -678,7 +677,7 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -703,16 +702,16 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const line = createRippleStateLedgerObject("USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0); @@ -721,10 +720,10 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -735,7 +734,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -759,16 +758,16 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithTypeFilter) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const line = createRippleStateLedgerObject("USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, 0); @@ -780,7 +779,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithTypeFilter) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -805,36 +804,36 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterEmptyResult) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const offer1 = createOfferLedgerObject( kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); auto const offer2 = createOfferLedgerObject( kACCOUNT, 20, 30, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -844,7 +843,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterEmptyResult) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -868,35 +867,35 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithIncompatibleT EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const offer1 = createOfferLedgerObject( kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); auto const offer2 = createOfferLedgerObject( kACCOUNT, 20, 30, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -906,7 +905,7 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilterWithIncompatibleT EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -994,17 +993,17 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMixOtherObjects) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft page 1 - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; - auto const nftPage2KK = ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kINDEX1}).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; + auto const nftPage2KK = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{kINDEX1}).key; auto const nftpage1 = createNftTokenPage(std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, nftPage2KK); EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(nftpage1.getSerializer().peekData())); @@ -1022,7 +1021,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMixOtherObjects) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -1035,7 +1034,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMixOtherObjects) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1045,16 +1044,15 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitReturnMarker) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto current = ripple::keylet::nftpage_max(account).key; + auto current = xrpl::keylet::nftpageMax(account).key; std::string first{kINDEX1}; std::ranges::sort(first); for (auto i = 0; i < 10; i++) { std::ranges::next_permutation(first); - auto previous = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()}).key; + auto previous = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{first.c_str()}).key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1063,7 +1061,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitReturnMarker) current = previous; } - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1081,7 +1079,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitReturnMarker) EXPECT_EQ(output.result.value().as_object().at("account_objects").as_array().size(), 10); EXPECT_EQ( output.result.value().as_object().at("marker").as_string(), - fmt::format("{},{}", ripple::strHex(current), std::numeric_limits::max()) + fmt::format("{},{}", xrpl::strHex(current), std::numeric_limits::max()) ); }); } @@ -1092,16 +1090,15 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitNoMarker) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto current = ripple::keylet::nftpage_max(account).key; + auto current = xrpl::keylet::nftpageMax(account).key; std::string first{kINDEX1}; std::ranges::sort(first); for (auto i = 0; i < 10; i++) { std::ranges::next_permutation(first); - auto previous = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()}).key; + auto previous = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{first.c_str()}).key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1114,7 +1111,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitNoMarker) ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)).WillOnce(Return(nftpage11.getSerializer().peekData())); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1133,7 +1130,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitNoMarker) //"0000000000000000000000000000000000000000000000000000000000000000,4294967295" EXPECT_EQ( output.result.value().as_object().at("marker").as_string(), - fmt::format("{},{}", ripple::strHex(ripple::uint256(beast::zero)), std::numeric_limits::max()) + fmt::format("{},{}", xrpl::strHex(xrpl::uint256(beast::kZero)), std::numeric_limits::max()) ); }); } @@ -1144,17 +1141,16 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); std::string first{kINDEX1}; - auto current = ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()}).key; + auto current = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{first.c_str()}).key; auto const marker = current; std::ranges::sort(first); for (auto i = 0; i < 10; i++) { std::ranges::next_permutation(first); - auto previous = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()}).key; + auto previous = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{first.c_str()}).key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1167,10 +1163,9 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)).WillOnce(Return(nftpage11.getSerializer().peekData())); - auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1 - ); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1180,10 +1175,10 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -1194,14 +1189,14 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", kACCOUNT, - ripple::strHex(marker), + xrpl::strHex(marker), std::numeric_limits::max() ) ); @@ -1222,13 +1217,12 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1 - ); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1238,10 +1232,10 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -1252,14 +1246,14 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", kACCOUNT, - ripple::strHex(ripple::uint256{beast::zero}), + xrpl::strHex(xrpl::uint256{beast::kZero}), std::numeric_limits::max() ) ); @@ -1279,10 +1273,10 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotInRange) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1310,21 +1304,21 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotExist) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); // return null for this marker - auto const accountNftMax = ripple::keylet::nftpage_max(account).key; + auto const accountNftMax = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountNftMax, kMAX_SEQ, _)).WillOnce(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", "marker": "{},{}" }})JSON", kACCOUNT, - ripple::strHex(accountNftMax), + xrpl::strHex(accountNftMax), std::numeric_limits::max() ) ); @@ -1345,17 +1339,16 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); std::string first{kINDEX1}; - auto current = ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()}).key; + auto current = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{first.c_str()}).key; auto const marker = current; std::ranges::sort(first); for (auto i = 0; i < 10; i++) { std::ranges::next_permutation(first); - auto previous = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()}).key; + auto previous = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{first.c_str()}).key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1368,8 +1361,8 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) ); EXPECT_CALL(*backend_, doFetchLedgerObject(current, 30, _)).WillOnce(Return(nftpage11.getSerializer().peekData())); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1379,10 +1372,10 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -1393,7 +1386,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1401,7 +1394,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) "limit": 12 }})JSON", kACCOUNT, - ripple::strHex(marker), + xrpl::strHex(marker), std::numeric_limits::max() ) ); @@ -1463,17 +1456,17 @@ TEST_F(RPCAccountObjectsHandlerTest, FilterNFT) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft page 1 - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; - auto const nftPage2KK = ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kINDEX1}).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; + auto const nftPage2KK = xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{kINDEX1}).key; auto const nftpage1 = createNftTokenPage(std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, nftPage2KK); EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(nftpage1.getSerializer().peekData())); @@ -1491,7 +1484,7 @@ TEST_F(RPCAccountObjectsHandlerTest, FilterNFT) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1505,7 +1498,7 @@ TEST_F(RPCAccountObjectsHandlerTest, FilterNFT) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1515,14 +1508,14 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); static constexpr auto kLIMIT = 10; auto count = kLIMIT * 2; // put 20 items in owner dir, but only return 10 - auto const ownerDir = createOwnerDirLedgerObject(std::vector(count, ripple::uint256{kINDEX1}), kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject(std::vector(count, xrpl::uint256{kINDEX1}), kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1534,7 +1527,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) } EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1543,7 +1536,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) }})JSON", kACCOUNT, kLIMIT, - ripple::strHex(ripple::uint256{beast::zero}), + xrpl::strHex(xrpl::uint256{beast::kZero}), std::numeric_limits::max() ) ); @@ -1598,16 +1591,16 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -1616,7 +1609,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1631,7 +1624,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitLessThanMin) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1676,16 +1669,16 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -1694,7 +1687,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1709,7 +1702,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LimitMoreThanMax) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1719,16 +1712,16 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTIssuanceType) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerinfo)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -1738,7 +1731,7 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTIssuanceType) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1759,7 +1752,7 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTIssuanceType) // make sure mptID is synethetically parsed if object is mptIssuance EXPECT_EQ( accountObjects.front().at("mpt_issuance_id").as_string(), - ripple::to_string(ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))) + xrpl::to_string(xrpl::makeMptID(2, getAccountIdWithString(kACCOUNT))) ); }); } @@ -1770,26 +1763,26 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTokenType) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerinfo)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpageMax(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; // put 1 mpt issuance - auto const mptokenObject = createMpTokenObject(kACCOUNT, ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))); + auto const mptokenObject = createMpTokenObject(kACCOUNT, xrpl::makeMptID(2, getAccountIdWithString(kACCOUNT))); bbs.push_back(mptokenObject.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", diff --git a/tests/unit/rpc/handlers/AccountOffersTests.cpp b/tests/unit/rpc/handlers/AccountOffersTests.cpp index 885ccb083..dc5babe0f 100644 --- a/tests/unit/rpc/handlers/AccountOffersTests.cpp +++ b/tests/unit/rpc/handlers/AccountOffersTests.cpp @@ -54,7 +54,6 @@ constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1 using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCAccountOffersHandlerTest : HandlerBaseTest { @@ -160,7 +159,7 @@ TEST_P(AccountOfferParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountOffersHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -173,10 +172,10 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -202,9 +201,9 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaStringIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -230,9 +229,9 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaIntIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -261,7 +260,7 @@ TEST_F(RPCAccountOffersHandlerTest, AccountNotFound) ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -312,11 +311,11 @@ TEST_F(RPCAccountOffersHandlerTest, DefaultParams) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -326,19 +325,19 @@ TEST_F(RPCAccountOffersHandlerTest, DefaultParams) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); - offer.setFieldU32(ripple::sfExpiration, 123); + offer.setFieldU32(xrpl::sfExpiration, 123); bbs.push_back(offer.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -350,7 +349,7 @@ TEST_F(RPCAccountOffersHandlerTest, DefaultParams) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(expectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(expectedOutput)); }); } @@ -362,11 +361,11 @@ TEST_F(RPCAccountOffersHandlerTest, Limit) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject(std::vector{20, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -377,10 +376,10 @@ TEST_F(RPCAccountOffersHandlerTest, Limit) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(offer.getSerializer().peekData()); @@ -388,7 +387,7 @@ TEST_F(RPCAccountOffersHandlerTest, Limit) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -414,13 +413,13 @@ TEST_F(RPCAccountOffersHandlerTest, Marker) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const startPage = 2; - auto const ownerDir = createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - auto const hintIndex = ripple::keylet::page(ownerDirKk, startPage).key; + auto const ownerDir = createOwnerDirLedgerObject(std::vector{20, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const hintIndex = xrpl::keylet::page(ownerDirKk, startPage).key; ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -432,10 +431,10 @@ TEST_F(RPCAccountOffersHandlerTest, Marker) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(offer.getSerializer().peekData()); @@ -443,7 +442,7 @@ TEST_F(RPCAccountOffersHandlerTest, Marker) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -471,17 +470,17 @@ TEST_F(RPCAccountOffersHandlerTest, MarkerNotExists) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const startPage = 2; - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - auto const hintIndex = ripple::keylet::page(ownerDirKk, startPage).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const hintIndex = xrpl::keylet::page(ownerDirKk, startPage).key; ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLEDGER_SEQ, _)).WillByDefault(Return(std::nullopt)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -510,13 +509,12 @@ TEST_F(RPCAccountOffersHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 - ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = + createOwnerDirLedgerObject(std::vector{AccountOffersHandler::kLIMIT_MIN + 1, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -526,13 +524,13 @@ TEST_F(RPCAccountOffersHandlerTest, LimitLessThanMin) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); - offer.setFieldU32(ripple::sfExpiration, 123); + offer.setFieldU32(xrpl::sfExpiration, 123); bbs.reserve(AccountOffersHandler::kLIMIT_MIN + 1); for (auto i = 0; i < AccountOffersHandler::kLIMIT_MIN + 1; i++) @@ -541,7 +539,7 @@ TEST_F(RPCAccountOffersHandlerTest, LimitLessThanMin) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -567,14 +565,13 @@ TEST_F(RPCAccountOffersHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 - ); + auto const ownerDir = + createOwnerDirLedgerObject(std::vector{AccountOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -584,13 +581,13 @@ TEST_F(RPCAccountOffersHandlerTest, LimitMoreThanMax) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); - offer.setFieldU32(ripple::sfExpiration, 123); + offer.setFieldU32(xrpl::sfExpiration, 123); bbs.reserve(AccountOffersHandler::kLIMIT_MAX + 1); for (auto i = 0; i < AccountOffersHandler::kLIMIT_MAX + 1; i++) bbs.push_back(offer.getSerializer().peekData()); @@ -598,7 +595,7 @@ TEST_F(RPCAccountOffersHandlerTest, LimitMoreThanMax) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", diff --git a/tests/unit/rpc/handlers/AccountTxTests.cpp b/tests/unit/rpc/handlers/AccountTxTests.cpp index 20c6d9838..492d68717 100644 --- a/tests/unit/rpc/handlers/AccountTxTests.cpp +++ b/tests/unit/rpc/handlers/AccountTxTests.cpp @@ -42,7 +42,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -414,7 +413,7 @@ TEST_P(AccountTxParameterTest, CheckParams) { auto const& testBundle = GetParam(); - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); if (testBundle.expectedError.has_value()) { ASSERT_TRUE(testBundle.expectedErrorMessage.has_value()); @@ -444,19 +443,19 @@ genTransactions(uint32_t seq1, uint32_t seq2) { auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = seq1; - ripple::STObject const metaObj = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + xrpl::STObject const metaObj = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); trans1.metadata = metaObj.getSerializer().peekData(); trans1.date = 1; transactions.push_back(trans1); auto trans2 = TransactionAndMetadata(); - ripple::STObject const obj2 = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj2 = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); trans2.transaction = obj.getSerializer().peekData(); trans2.ledgerSequence = seq2; - ripple::STObject const metaObj2 = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + xrpl::STObject const metaObj2 = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); trans2.metadata = metaObj2.getSerializer().peekData(); trans2.date = 2; transactions.push_back(trans2); @@ -511,7 +510,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -529,7 +528,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_FALSE(output.result->as_object().contains("limit")); }); @@ -555,7 +554,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -573,7 +572,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_FALSE(output.result->as_object().contains("limit")); }); @@ -599,7 +598,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -617,7 +616,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_FALSE(output.result->as_object().contains("limit")); }); @@ -643,7 +642,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -661,7 +660,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_FALSE(output.result->as_object().contains("limit")); }); @@ -685,7 +684,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -703,7 +702,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue) EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( output.result->at("transactions").as_array()[0].as_object().at("meta").as_string(), @@ -741,7 +740,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -759,7 +758,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( output.result->at("transactions").as_array()[0].as_object().at("meta_blob").as_string(), @@ -795,7 +794,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -816,7 +815,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker) EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); EXPECT_EQ(output.result->at("limit").as_uint64(), 2); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); }); } @@ -831,7 +830,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitIsCapped) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -865,7 +864,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAllowedUpToCap) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -913,7 +912,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -940,7 +939,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerIntIndex) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -964,7 +963,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerStringIndex) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1001,13 +1000,13 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); EXPECT_CALL(*backend_, fetchLedgerByHash); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1052,7 +1051,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1092,7 +1091,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1136,7 +1135,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1156,7 +1155,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 2); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); EXPECT_FALSE(output.result->as_object().contains("limit")); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); }); } @@ -1352,7 +1351,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1368,7 +1367,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1) ); auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 1u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(out)); + EXPECT_EQ(*output.result, boost::json::parse(out)); }); } @@ -1574,7 +1573,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1590,7 +1589,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2) ); auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(out)); + EXPECT_EQ(*output.result, boost::json::parse(out)); }); } @@ -1667,7 +1666,7 @@ TEST_F(RPCAccountTxHandlerTest, MPTTxs_API_v2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -1681,7 +1680,7 @@ TEST_F(RPCAccountTxHandlerTest, MPTTxs_API_v2) ); auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(out)); + EXPECT_EQ(*output.result, boost::json::parse(out)); }); } @@ -2193,12 +2192,12 @@ TEST_P(AccountTxTransactionTypeTest, SpecificTransactionType) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion}); EXPECT_TRUE(output); auto const transactions = output.result->at("transactions").as_array(); - auto const jsonObject = json::parse(testBundle.result); + auto const jsonObject = boost::json::parse(testBundle.result); EXPECT_EQ(jsonObject, transactions); }); } diff --git a/tests/unit/rpc/handlers/AllHandlerTests.cpp b/tests/unit/rpc/handlers/AllHandlerTests.cpp index 531c259a9..77d15ab1b 100644 --- a/tests/unit/rpc/handlers/AllHandlerTests.cpp +++ b/tests/unit/rpc/handlers/AllHandlerTests.cpp @@ -205,9 +205,9 @@ BookOffersHandler::Input createInput() { BookOffersHandler::Input input{}; - input.paysCurrency = ripple::xrpCurrency(); - input.getsCurrency = ripple::Currency(kCURRENCY); - input.paysID = ripple::xrpAccount(); + input.paysCurrency = xrpl::xrpCurrency(); + input.getsCurrency = xrpl::Currency(kCURRENCY); + input.paysID = xrpl::xrpAccount(); input.getsID = getAccountIdWithString(kACCOUNT); return input; @@ -256,7 +256,7 @@ createInput() SubscribeHandler::Input input{}; input.books = std::vector{ - SubscribeHandler::OrderBook{.book = ripple::Book{}, .taker = kACCOUNT, .snapshot = true, .both = true} + SubscribeHandler::OrderBook{.book = xrpl::Book{}, .taker = kACCOUNT, .snapshot = true, .both = true} }; return input; } diff --git a/tests/unit/rpc/handlers/BookChangesTests.cpp b/tests/unit/rpc/handlers/BookChangesTests.cpp index a72c18b96..7854b4ef6 100644 --- a/tests/unit/rpc/handlers/BookChangesTests.cpp +++ b/tests/unit/rpc/handlers/BookChangesTests.cpp @@ -40,7 +40,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -111,7 +110,7 @@ TEST_P(BookChangesParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{BookChangesHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -124,9 +123,9 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaIntSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse(R"JSON({"ledger_index": 30})JSON"); + static auto const kINPUT = boost::json::parse(R"JSON({"ledger_index": 30})JSON"); auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); @@ -143,7 +142,7 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaStringSequence) // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse(R"JSON({"ledger_index": "30"})JSON"); + static auto const kINPUT = boost::json::parse(R"JSON({"ledger_index": "30"})JSON"); auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{yield}); @@ -157,10 +156,10 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}" @@ -206,10 +205,10 @@ TEST_F(RPCBookChangesHandlerTest, NormalPath) auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + xrpl::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); @@ -217,9 +216,9 @@ TEST_F(RPCBookChangesHandlerTest, NormalPath) auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(json::parse("{}"), Context{yield}); + auto const output = handler.process(boost::json::parse("{}"), Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -252,10 +251,10 @@ TEST_F(RPCBookChangesHandlerTest, NormalPathWithDomain) auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1, kDOMAIN); + xrpl::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1, kDOMAIN); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); @@ -263,8 +262,8 @@ TEST_F(RPCBookChangesHandlerTest, NormalPathWithDomain) auto const handler = AnyHandler{BookChangesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = handler.process(json::parse("{}"), Context{yield}); + auto const output = handler.process(boost::json::parse("{}"), Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } diff --git a/tests/unit/rpc/handlers/BookOffersTests.cpp b/tests/unit/rpc/handlers/BookOffersTests.cpp index e162fc57e..005fe5c96 100644 --- a/tests/unit/rpc/handlers/BookOffersTests.cpp +++ b/tests/unit/rpc/handlers/BookOffersTests.cpp @@ -79,7 +79,6 @@ struct ParameterTestBundle { using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCBookOffersHandlerTest : HandlerBaseTest { @@ -99,7 +98,7 @@ TEST_P(RPCBookOffersParameterTest, CheckError) auto bundle = GetParam(); auto const handler = AnyHandler{BookOffersHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](boost::asio::yield_context yield) { - auto const output = handler.process(json::parse(bundle.testJson), Context{.yield = yield}); + auto const output = handler.process(boost::json::parse(bundle.testJson), Context{.yield = yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), bundle.expectedError); @@ -511,10 +510,10 @@ INSTANTIATE_TEST_SUITE_P( struct BookOffersNormalTestBundle { std::string testName; std::string inputJson; - std::map> mockedSuccessors; - std::map mockedLedgerObjects; + std::map> mockedSuccessors; + std::map mockedLedgerObjects; uint32_t ledgerObjectCalls; - std::vector mockedOffers; + std::vector mockedOffers; std::string expectedJson; uint32_t amendmentIsEnabledCalls = 0; }; @@ -561,9 +560,9 @@ TEST_P(RPCBookOffersNormalPathTest, CheckOutput) auto const handler = AnyHandler{BookOffersHandler{backend_, mockAmendmentCenterPtr_}}; runSpawn([&](boost::asio::yield_context yield) { - auto const output = handler.process(json::parse(bundle.inputJson), Context{.yield = yield}); + auto const output = handler.process(boost::json::parse(bundle.inputJson), Context{.yield = yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result.value(), json::parse(bundle.expectedJson)); + EXPECT_EQ(output.result.value(), boost::json::parse(bundle.expectedJson)); }); } @@ -574,17 +573,17 @@ generateNormalPathBookOffersTestBundles() auto const account2 = getAccountIdWithString(kACCOUNT2); auto const frozenTrustLine = createRippleStateLedgerObject( - "USD", kACCOUNT, -8, kACCOUNT2, 1000, kACCOUNT, 2000, kINDEX1, 2, ripple::lsfLowFreeze + "USD", kACCOUNT, -8, kACCOUNT2, 1000, kACCOUNT, 2000, kINDEX1, 2, xrpl::lsfLowFreeze ); auto const gets10USDPays20XRPOffer = createOfferLedgerObject( kACCOUNT2, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); @@ -592,10 +591,10 @@ generateNormalPathBookOffersTestBundles() kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); @@ -603,9 +602,9 @@ generateNormalPathBookOffersTestBundles() kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -614,25 +613,22 @@ generateNormalPathBookOffersTestBundles() kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR, kDOMAIN ); auto const getsXRPPaysUSDBook = getBookBase( - rpc::parseBook(ripple::to_currency("USD"), account, ripple::xrpCurrency(), ripple::xrpAccount(), std::nullopt) - .value() + rpc::parseBook(xrpl::toCurrency("USD"), account, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt).value() ); auto const getsXRPPaysUSDBookWithDomain = getBookBase( - rpc::parseBook(ripple::to_currency("USD"), account, ripple::xrpCurrency(), ripple::xrpAccount(), kDOMAIN) - .value() + rpc::parseBook(xrpl::toCurrency("USD"), account, xrpl::xrpCurrency(), xrpl::xrpAccount(), kDOMAIN).value() ); auto const getsUSDPaysXRPBook = getBookBase( - rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), account, std::nullopt) - .value() + rpc::parseBook(xrpl::xrpCurrency(), xrpl::xrpAccount(), xrpl::toCurrency("USD"), account, std::nullopt).value() ); auto const getsXRPPaysUSDInputJson = fmt::format( @@ -690,28 +686,28 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()}, // owner account object - {ripple::keylet::account(account2).key, + {xrpl::keylet::account(account2).key, createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()}, // fee settings: base ->3 inc->2, account2 has 2 objects ,total // reserve ->7 // owner_funds should be 193 - {ripple::keylet::fees().key, feeLedgerObject} + {xrpl::keylet::fees().key, feeLedgerObject} }, .ledgerObjectCalls = 5, - .mockedOffers = std::vector{gets10XRPPays20USDOffer}, + .mockedOffers = std::vector{gets10XRPPays20USDOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -750,28 +746,28 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()}, // owner account object, hold - {ripple::keylet::account(account2).key, + {xrpl::keylet::account(account2).key, createAccountRootObject(kACCOUNT2, 0, 2, 5 + 7, 2, kINDEX1, 2).getSerializer().peekData()}, // fee settings: base ->3 inc->2, account2 has 2 objects // ,total // reserve ->7 - {ripple::keylet::fees().key, feeLedgerObject} + {xrpl::keylet::fees().key, feeLedgerObject} }, .ledgerObjectCalls = 5, - .mockedOffers = std::vector{gets10XRPPays20USDOffer}, + .mockedOffers = std::vector{gets10XRPPays20USDOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -816,23 +812,23 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2) + {xrpl::keylet::account(account).key, + createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2) .getSerializer() .peekData()} }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10XRPPays20USDOffer}, + .mockedOffers = std::vector{gets10XRPPays20USDOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -877,23 +873,23 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJsonWithDomain, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBookWithDomain, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBookWithDomain, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, - createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2) + {xrpl::keylet::account(account).key, + createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2) .getSerializer() .peekData()} }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10XRPPays20USDOfferWithDomain}, + .mockedOffers = std::vector{gets10XRPPays20USDOfferWithDomain}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -939,25 +935,23 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // gets issuer account object - {ripple::keylet::account(account).key, - createAccountRootObject( - kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2 - ) + {xrpl::keylet::account(account).key, + createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()} }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1003,26 +997,26 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // gets issuer account object, rate is 1/2 - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 8 USD - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::toCurrency("USD")).key, trustline8Balance.getSerializer().peekData()}, }, .ledgerObjectCalls = 6, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1069,29 +1063,29 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // gets issuer account object - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 30 USD - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::toCurrency("USD")).key, trustline30Balance.getSerializer().peekData()}, }, .ledgerObjectCalls = 6, .mockedOffers = - std::vector{ + std::vector{ // After offer1, balance is 30 - 2*10 = 10 gets10USDPays20XRPOffer, // offer2 not fully funded, balance is 10, rate is 2, so only @@ -1166,23 +1160,23 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // gets issuer account object, rate is 1/2 - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10USDPays20XRPOwnerOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOwnerOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1222,26 +1216,26 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // gets issuer account object, rate is 1/2 - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 8 USD - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::toCurrency("USD")).key, frozenTrustLine.getSerializer().peekData()}, }, .ledgerObjectCalls = 6, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1287,25 +1281,23 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // gets issuer account object, is deep frozen so unfunded - {ripple::keylet::account(account).key, - createAccountRootObject( - kACCOUNT, ripple::lsfLowDeepFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2 - ) + {xrpl::keylet::account(account).key, + createAccountRootObject(kACCOUNT, xrpl::lsfLowDeepFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, }, .ledgerObjectCalls = 4, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1351,28 +1343,26 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // gets issuer account object, is deep frozen so unfunded - {ripple::keylet::account(account).key, - createAccountRootObject( - kACCOUNT, ripple::lsfLowDeepFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2 - ) + {xrpl::keylet::account(account).key, + createAccountRootObject(kACCOUNT, xrpl::lsfLowDeepFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::toCurrency("USD")).key, frozenTrustLine.getSerializer().peekData()}, }, .ledgerObjectCalls = 6, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1428,9 +1418,9 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaIntSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": 30, @@ -1459,9 +1449,9 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaSequence) { EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence(30, _)).WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": "30", @@ -1490,10 +1480,10 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1533,24 +1523,23 @@ TEST_F(RPCBookOffersHandlerTest, Limit) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); auto const getsXRPPaysUSDBook = getBookBase( - rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount(), std::nullopt) - .value() + rpc::parseBook(xrpl::toCurrency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt).value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); + auto const indexes = std::vector(10, xrpl::uint256{kINDEX2}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _)) .WillByDefault(Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _)) .WillByDefault(Return(createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, seq, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuer).key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(issuer).key, seq, _)) .WillByDefault(Return( createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2).getSerializer().peekData() )); @@ -1559,9 +1548,9 @@ TEST_F(RPCBookOffersHandlerTest, Limit) kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -1570,7 +1559,7 @@ TEST_F(RPCBookOffersHandlerTest, Limit) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "taker_gets": {{ @@ -1607,24 +1596,23 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); auto const getsXRPPaysUSDBook = getBookBase( - rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount(), std::nullopt) - .value() + rpc::parseBook(xrpl::toCurrency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt).value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); - auto const indexes = std::vector(BookOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX2}); + auto const indexes = std::vector(BookOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX2}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _)) .WillByDefault(Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _)) .WillByDefault(Return(createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, seq, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuer).key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(issuer).key, seq, _)) .WillByDefault(Return( createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2).getSerializer().peekData() )); @@ -1633,9 +1621,9 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -1644,7 +1632,7 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "taker_gets": {{ diff --git a/tests/unit/rpc/handlers/CredentialHelpersTests.cpp b/tests/unit/rpc/handlers/CredentialHelpersTests.cpp index 9d6a2555b..e29a5a236 100644 --- a/tests/unit/rpc/handlers/CredentialHelpersTests.cpp +++ b/tests/unit/rpc/handlers/CredentialHelpersTests.cpp @@ -60,7 +60,7 @@ constexpr std::string_view kCREDENTIAL_TYPE = "credType"; TEST(CreateAuthCredentialsTest, UniqueCredentials) { - ripple::STArray credentials; + xrpl::STArray credentials; auto const cred1 = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); auto const cred2 = createCredentialObject(kACCOUNT2, kACCOUNT, kCREDENTIAL_TYPE); @@ -72,13 +72,13 @@ TEST(CreateAuthCredentialsTest, UniqueCredentials) // Validate that the result contains the correct set of credentials ASSERT_EQ(result.size(), 2); - auto const cred1Type = cred1.getFieldVL(ripple::sfCredentialType); - auto const cred2Type = cred2.getFieldVL(ripple::sfCredentialType); + auto const cred1Type = cred1.getFieldVL(xrpl::sfCredentialType); + auto const cred2Type = cred2.getFieldVL(xrpl::sfCredentialType); auto const expectedCred1 = - std::make_pair(cred1.getAccountID(ripple::sfIssuer), ripple::Slice{cred1Type.data(), cred1Type.size()}); + std::make_pair(cred1.getAccountID(xrpl::sfIssuer), xrpl::Slice{cred1Type.data(), cred1Type.size()}); auto const expectedCred2 = - std::make_pair(cred2.getAccountID(ripple::sfIssuer), ripple::Slice{cred2Type.data(), cred2Type.size()}); + std::make_pair(cred2.getAccountID(xrpl::sfIssuer), xrpl::Slice{cred2Type.data(), cred2Type.size()}); EXPECT_TRUE(result.count(expectedCred1)); EXPECT_TRUE(result.count(expectedCred2)); @@ -89,24 +89,24 @@ TEST(ParseAuthorizeCredentialsTest, ValidCredentialsArray) boost::json::array credentials; boost::json::object credential1; credential1[JS(issuer)] = kACCOUNT; - credential1[JS(credential_type)] = ripple::strHex(kCREDENTIAL_TYPE); + credential1[JS(credential_type)] = xrpl::strHex(kCREDENTIAL_TYPE); credentials.push_back(credential1); - ripple::STArray const parsedCredentials = credentials::parseAuthorizeCredentials(credentials); + xrpl::STArray const parsedCredentials = credentials::parseAuthorizeCredentials(credentials); ASSERT_EQ(parsedCredentials.size(), 1); - ripple::STObject const& cred = parsedCredentials[0]; - ASSERT_TRUE(cred.isFieldPresent(ripple::sfIssuer)); - ASSERT_TRUE(cred.isFieldPresent(ripple::sfCredentialType)); + xrpl::STObject const& cred = parsedCredentials[0]; + ASSERT_TRUE(cred.isFieldPresent(xrpl::sfIssuer)); + ASSERT_TRUE(cred.isFieldPresent(xrpl::sfCredentialType)); auto const expectedIssuer = - *ripple::parseBase58(static_cast(credential1[JS(issuer)].as_string())); + *xrpl::parseBase58(static_cast(credential1[JS(issuer)].as_string())); auto const expectedCredentialType = - ripple::strUnHex(static_cast(credential1[JS(credential_type)].as_string())).value(); + xrpl::strUnHex(static_cast(credential1[JS(credential_type)].as_string())).value(); - EXPECT_EQ(cred.getAccountID(ripple::sfIssuer), expectedIssuer); - EXPECT_EQ(cred.getFieldVL(ripple::sfCredentialType), expectedCredentialType); + EXPECT_EQ(cred.getAccountID(xrpl::sfIssuer), expectedIssuer); + EXPECT_EQ(cred.getFieldVL(xrpl::sfCredentialType), expectedCredentialType); } class CredentialHelperTest : public util::prometheus::WithPrometheus, @@ -124,7 +124,7 @@ TEST_F(CredentialHelperTest, GetInvalidCredentialArray) ); ASSERT_FALSE(ret.has_value()); auto const status = ret.error(); - EXPECT_EQ(status, RippledError::rpcBAD_CREDENTIALS); + EXPECT_EQ(status, RippledError::RpcBadCredentials); EXPECT_EQ(status.message, "credentials don't exist."); }); ctx_.run(); @@ -142,12 +142,10 @@ TEST_F(CredentialHelperTest, GetValidCredentialArray) boost::json::array credentialsArray = {kCREDENTIAL_ID}; - ripple::STArray expectedAuthCreds; - ripple::STObject credential(ripple::sfCredential); - credential.setAccountID(ripple::sfIssuer, getAccountIdWithString(kACCOUNT2)); - credential.setFieldVL( - ripple::sfCredentialType, ripple::Blob{std::begin(kCREDENTIAL_TYPE), std::end(kCREDENTIAL_TYPE)} - ); + xrpl::STArray expectedAuthCreds; + xrpl::STObject credential(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, getAccountIdWithString(kACCOUNT2)); + credential.setFieldVL(xrpl::sfCredentialType, xrpl::Blob{std::begin(kCREDENTIAL_TYPE), std::end(kCREDENTIAL_TYPE)}); expectedAuthCreds.push_back(std::move(credential)); util::spawn(ctx_, [&](boost::asio::yield_context yield) { diff --git a/tests/unit/rpc/handlers/DefaultProcessorTests.cpp b/tests/unit/rpc/handlers/DefaultProcessorTests.cpp index 73b2095bf..3d9cbd503 100644 --- a/tests/unit/rpc/handlers/DefaultProcessorTests.cpp +++ b/tests/unit/rpc/handlers/DefaultProcessorTests.cpp @@ -35,8 +35,6 @@ using namespace rpc; using namespace rpc::validation; using namespace tests::common; -namespace json = boost::json; - class RPCDefaultProcessorTest : public HandlerBaseTest {}; TEST_F(RPCDefaultProcessorTest, ValidInput) @@ -45,7 +43,7 @@ TEST_F(RPCDefaultProcessorTest, ValidInput) HandlerMock const handler; rpc::impl::DefaultProcessor const processor; - auto const input = json::parse(R"JSON({ "something": "works" })JSON"); + auto const input = boost::json::parse(R"JSON({ "something": "works" })JSON"); auto const spec = RpcSpec{{"something", Required{}}}; auto const data = InOutFake{"works"}; EXPECT_CALL(handler, spec(_)).WillOnce(ReturnRef(spec)); @@ -64,7 +62,7 @@ TEST_F(RPCDefaultProcessorTest, NoInputValidCall) rpc::impl::DefaultProcessor const processor; auto const data = InOutFake{"works"}; - auto const input = json::parse(R"JSON({})JSON"); + auto const input = boost::json::parse(R"JSON({})JSON"); EXPECT_CALL(handler, process(_)).WillOnce(Return(data)); auto const ret = processor(handler, input, Context{yield}); @@ -79,7 +77,7 @@ TEST_F(RPCDefaultProcessorTest, InvalidInput) HandlerMock const handler; rpc::impl::DefaultProcessor const processor; - auto const input = json::parse(R"JSON({ "other": "nope" })JSON"); + auto const input = boost::json::parse(R"JSON({ "other": "nope" })JSON"); auto const spec = RpcSpec{{"something", Required{}}}; EXPECT_CALL(handler, spec(_)).WillOnce(ReturnRef(spec)); diff --git a/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp b/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp index 9e47bc582..c34e5708c 100644 --- a/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp +++ b/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp @@ -62,7 +62,6 @@ constexpr auto kRANGE_MAX = 30; using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCDepositAuthorizedTest : HandlerBaseTest { @@ -222,7 +221,7 @@ TEST_P(DepositAuthorizedParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{DepositAuthorizedHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -240,7 +239,7 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaIntSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{DepositAuthorizedHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -269,7 +268,7 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaStringSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{DepositAuthorizedHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -294,11 +293,11 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaStringSequence) TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{DepositAuthorizedHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -324,13 +323,13 @@ TEST_F(RPCDepositAuthorizedTest, SourceAccountDoesNotExist) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -359,17 +358,17 @@ TEST_F(RPCDepositAuthorizedTest, DestinationAccountDoesNotExist) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(accountRoot.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -408,14 +407,14 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const accountRoot = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(accountRoot.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -433,7 +432,7 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -451,19 +450,19 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX2, 2); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -481,7 +480,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -499,20 +498,20 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::nullopt)); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -530,7 +529,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -548,20 +547,20 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -579,7 +578,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -600,28 +599,28 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) .WillByDefault(Return(credential.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(4); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -632,7 +631,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -641,7 +640,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -649,29 +648,29 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE, false); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) .WillByDefault(Return(credential.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -682,7 +681,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -702,34 +701,34 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 100); // set parent close time to 500 seconds - ledgerHeader.parentCloseTime = ripple::NetClock::time_point{std::chrono::seconds{500}}; + ledgerHeader.parentCloseTime = xrpl::NetClock::time_point{std::chrono::seconds{500}}; - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); // credential expire time is 23 seconds, so credential will fail auto const expiredCredential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE, true, 23); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) .WillByDefault(Return(expiredCredential.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -740,7 +739,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -759,29 +758,29 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) .WillByDefault(Return(credential.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -792,8 +791,8 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex), - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex), + xrpl::strHex(credentialIndex) ) ); @@ -812,20 +811,20 @@ TEST_F(RPCDepositAuthorizedTest, NoElementsInCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -854,31 +853,31 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) .WillByDefault(Return(credential.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - std::vector credentials(9, ripple::strHex(credentialIndex)); + std::vector credentials(9, xrpl::strHex(credentialIndex)); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -912,30 +911,30 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const account2Root = createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + auto const account2Root = createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); // reverse the subject and issuer account. Now subject is Account2 auto const credential = createCredentialObject(kACCOUNT2, kACCOUNT, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT2), getAccountIdWithString(kACCOUNT), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; ON_CALL(*backend_, doFetchLedgerObject(_, _, _)).WillByDefault(Return(std::optional{{1, 2, 3}})); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, _, _)) .WillByDefault(Return(account1Root.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, _, _)) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) .WillByDefault(Return(credential.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -946,7 +945,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); diff --git a/tests/unit/rpc/handlers/FeatureTests.cpp b/tests/unit/rpc/handlers/FeatureTests.cpp index 67e625eca..8856c63c6 100644 --- a/tests/unit/rpc/handlers/FeatureTests.cpp +++ b/tests/unit/rpc/handlers/FeatureTests.cpp @@ -221,7 +221,7 @@ TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([&, this](auto yield) { diff --git a/tests/unit/rpc/handlers/GatewayBalancesTests.cpp b/tests/unit/rpc/handlers/GatewayBalancesTests.cpp index 319f3126f..de954d3cb 100644 --- a/tests/unit/rpc/handlers/GatewayBalancesTests.cpp +++ b/tests/unit/rpc/handlers/GatewayBalancesTests.cpp @@ -47,7 +47,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -84,8 +83,9 @@ TEST_P(ParameterTest, CheckError) auto bundle = GetParam(); auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { - auto const output = - handler.process(json::parse(bundle.testJson), Context{.yield = yield, .apiVersion = bundle.apiVersion}); + auto const output = handler.process( + boost::json::parse(bundle.testJson), Context{.yield = yield, .apiVersion = bundle.apiVersion} + ); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), bundle.expectedError); @@ -270,12 +270,12 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaStringIndex) { auto const seq = 123; - EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(std::optional{})); auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process( - json::parse( + boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -298,12 +298,12 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaIntIndex) { auto const seq = 123; - EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(std::optional{})); auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process( - json::parse( + boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -324,13 +324,13 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaIntIndex) TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process( - json::parse( + boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -356,13 +356,13 @@ TEST_F(RPCGatewayBalancesHandlerTest, AccountNotFound) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)).WillOnce(Return(std::optional{})); auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process( - json::parse( + boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -381,8 +381,8 @@ TEST_F(RPCGatewayBalancesHandlerTest, AccountNotFound) struct NormalTestBundle { std::string testName; - ripple::STObject mockedDir; - std::vector mockedObjects; + xrpl::STObject mockedDir; + std::vector mockedObjects; std::string expectedJson; std::string hotwallet; }; @@ -399,12 +399,12 @@ TEST_P(NormalPathTest, CheckOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); // return valid owner dir - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, seq, _)) .WillOnce(Return(bundle.mockedDir.getSerializer().peekData())); @@ -417,7 +417,7 @@ TEST_P(NormalPathTest, CheckOutput) auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process( - json::parse( + boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -430,7 +430,7 @@ TEST_P(NormalPathTest, CheckOutput) Context{yield} ); ASSERT_TRUE(output); - EXPECT_EQ(output.result.value(), json::parse(bundle.expectedJson)); + EXPECT_EQ(output.result.value(), boost::json::parse(bundle.expectedJson)); }); } @@ -438,21 +438,21 @@ static auto generateNormalPathTestBundles() { auto frozenState = createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123); - frozenState.setFieldU32(ripple::sfFlags, ripple::lsfLowFreeze); + frozenState.setFieldU32(xrpl::sfFlags, xrpl::lsfLowFreeze); auto overflowState = createRippleStateLedgerObject("JPY", kISSUER, 50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123); int64_t const min64 = -9922966390934554; - overflowState.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue("JPY", kISSUER), min64, 80)); + overflowState.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(getIssue("JPY", kISSUER), min64, 80)); return std::vector{ NormalTestBundle{ .testName = "AllBranches", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}}, + {xrpl::uint256{kINDEX2}, + xrpl::uint256{kINDEX2}, + xrpl::uint256{kINDEX2}, + xrpl::uint256{kINDEX2}, + xrpl::uint256{kINDEX2}, + xrpl::uint256{kINDEX2}}, kINDEX1 ), .mockedObjects = @@ -520,7 +520,7 @@ generateNormalPathTestBundles() }, NormalTestBundle{ .testName = "NoHotwallet", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1), .mockedObjects = std::vector{createRippleStateLedgerObject( "JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 )}, @@ -539,7 +539,7 @@ generateNormalPathTestBundles() }, NormalTestBundle{ .testName = "ObligationOverflow", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}}, kINDEX1), .mockedObjects = std::vector{overflowState, overflowState}, .expectedJson = fmt::format( R"JSON({{ @@ -557,10 +557,7 @@ generateNormalPathTestBundles() NormalTestBundle{ .testName = "HighID", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}, - ripple::uint256{kINDEX2}}, + {xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}}, kINDEX1 ), .mockedObjects = @@ -610,7 +607,7 @@ generateNormalPathTestBundles() NormalTestBundle{ .testName = "HotWalletArray", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 + {xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}}, kINDEX1 ), .mockedObjects = std::vector{ @@ -661,8 +658,8 @@ INSTANTIATE_TEST_SUITE_P( struct EscrowTestBundle { std::string testName; - ripple::STObject mockedDir; - std::vector mockedObjects; + xrpl::STObject mockedDir; + std::vector mockedObjects; std::string expectedJson; }; @@ -676,10 +673,10 @@ TEST_P(EscrowTest, CheckEscrowOutput) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)).WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, seq, _)) .WillOnce(Return(bundle.mockedDir.getSerializer().peekData())); @@ -692,7 +689,7 @@ TEST_P(EscrowTest, CheckEscrowOutput) auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process( - json::parse( + boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -703,7 +700,7 @@ TEST_P(EscrowTest, CheckEscrowOutput) Context{yield} ); ASSERT_TRUE(output); - EXPECT_EQ(output.result.value(), json::parse(bundle.expectedJson)); + EXPECT_EQ(output.result.value(), boost::json::parse(bundle.expectedJson)); }); } @@ -712,20 +709,20 @@ generateEscrowTestBundles() { // Escrow with 100 XRP auto escrow1 = createEscrowLedgerObject(kACCOUNT, kACCOUNT2); - escrow1.setFieldAmount(ripple::sfAmount, ripple::STAmount(100, false)); + escrow1.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(100, false)); // Escrow with 200 XRP auto escrow2 = createEscrowLedgerObject(kACCOUNT, kACCOUNT3); - escrow2.setFieldAmount(ripple::sfAmount, ripple::STAmount(200, false)); + escrow2.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(200, false)); // Escrow with a non-XRP currency auto escrow3 = createEscrowLedgerObject(kACCOUNT, kACCOUNT2); - escrow3.setFieldAmount(ripple::sfAmount, ripple::STAmount(getIssue("USD", kISSUER), 50)); + escrow3.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(getIssue("USD", kISSUER), 50)); return std::vector{ EscrowTestBundle{ .testName = "SingleEscrowXRP", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1), .mockedObjects = std::vector{escrow1}, .expectedJson = fmt::format( R"JSON({{ @@ -740,7 +737,7 @@ generateEscrowTestBundles() }, EscrowTestBundle{ .testName = "MultipleEscrowXRP", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}}, kINDEX1), .mockedObjects = std::vector{escrow1, escrow2}, .expectedJson = fmt::format( R"JSON({{ @@ -755,7 +752,7 @@ generateEscrowTestBundles() }, EscrowTestBundle{ .testName = "EscrowNonXRP", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1), .mockedObjects = std::vector{escrow3}, .expectedJson = fmt::format( R"JSON({{ @@ -771,7 +768,7 @@ generateEscrowTestBundles() EscrowTestBundle{ .testName = "EscrowMixedCurrencies", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 + {xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}, xrpl::uint256{kINDEX2}}, kINDEX1 ), .mockedObjects = std::vector{escrow1, escrow2, escrow3}, .expectedJson = fmt::format( diff --git a/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp b/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp index b974f82ea..7b3d50602 100644 --- a/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp +++ b/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp @@ -43,7 +43,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -72,16 +71,14 @@ mockLedgerObject( "70726F7669646572", 64u, time, - ripple::Blob(8, 'a'), - ripple::Blob(8, 'a'), + xrpl::Blob(8, 'a'), + xrpl::Blob(8, 'a'), kRANGE_MAX - 4, - ripple::uint256{tx}, - createPriceDataSeries( - {createOraclePriceData(price, ripple::to_currency("USD"), ripple::to_currency("XRP"), scale)} - ) + xrpl::uint256{tx}, + createPriceDataSeries({createOraclePriceData(price, xrpl::toCurrency("USD"), xrpl::toCurrency("XRP"), scale)}) ); - auto const oracleIndex = ripple::keylet::oracle(getAccountIdWithString(account), docId).key; + auto const oracleIndex = xrpl::keylet::oracle(getAccountIdWithString(account), docId).key; EXPECT_CALL(backend, doFetchLedgerObject(oracleIndex, kRANGE_MAX, _)) .WillOnce(Return(oracleObject.getSerializer().peekData())); } @@ -404,7 +401,7 @@ TEST_P(GetAggregatePriceParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -415,7 +412,7 @@ TEST_P(GetAggregatePriceParameterTest, InvalidParams) TEST_F(RPCGetAggregatePriceHandlerTest, OverOraclesMax) { - auto req = json::parse( + auto req = boost::json::parse( R"JSON({ "base_asset": "USD", "quote_asset": "XRP", @@ -426,7 +423,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OverOraclesMax) for (auto i = 0; i < maxOracles + 1; ++i) { req.at("oracles").as_array().push_back( - json::object{{"account", "rGh1VZCRBJY6rJiaFpD4LZtyHiuCkC8aeD"}, {"oracle_document_id", 2}} + boost::json::object{{"account", "rGh1VZCRBJY6rJiaFpD4LZtyHiuCkC8aeD"}, {"oracle_document_id", 2}} ); } auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; @@ -443,7 +440,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, LedgerNotFound) { EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillOnce(Return(std::nullopt)); constexpr auto kDOCUMENT_ID = 1; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -478,7 +475,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -495,7 +492,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -529,7 +526,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -546,7 +543,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -580,7 +577,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "JPY", @@ -597,7 +594,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -632,23 +629,21 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) constexpr auto kDOCUMENT_ID = 1; mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX1), _)) .WillRepeatedly(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries( - {createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)} - ), + createPriceDataSeries({createOraclePriceData(1e3, xrpl::toCurrency("EUR"), xrpl::toCurrency("XRP"), 2)}), kINDEX, true, kTX2 ))); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "JPY", @@ -665,7 +660,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -706,7 +701,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -735,13 +730,13 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ "mean": "110", "size": 3, - "standard_deviation": "164.6207763315433" + "standard_deviation": "164.6207763315432795" }}, "median": "20", "time": 4321, @@ -776,7 +771,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -811,13 +806,13 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ "mean": "92.5", "size": 4, - "standard_deviation": "138.8944443333378" + "standard_deviation": "138.8944443333377776" }}, "median": "30", "time": 4321, @@ -852,7 +847,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -889,18 +884,18 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ "mean": "92.5", "size": 4, - "standard_deviation": "138.8944443333378" + "standard_deviation": "138.8944443333377776" }}, "trimmed_set": {{ "mean": "30", "size": 2, - "standard_deviation": "14.14213562373095" + "standard_deviation": "14.14213562373095049" }}, "median": "30", "time": 4321, @@ -925,11 +920,11 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoOracleEntryFound) .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); constexpr auto kDOCUMENT_ID = 1; - auto const oracleIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; + auto const oracleIndex = xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(oracleIndex, kRANGE_MAX, _)).WillOnce(Return(std::nullopt)); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -964,7 +959,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoMatchAssetPair) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "JPY", @@ -1009,7 +1004,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -1046,7 +1041,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -1091,7 +1086,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -1128,13 +1123,13 @@ TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ "mean": "15", "size": 2, - "standard_deviation": "7.071067811865475" + "standard_deviation": "7.071067811865475245" }}, "median": "15", "time": {}, @@ -1173,7 +1168,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -1210,13 +1205,13 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ "mean": "92.5", "size": 4, - "standard_deviation": "138.8944443333378" + "standard_deviation": "138.8944443333377776" }}, "median": "30", "time": 1711461384, @@ -1254,7 +1249,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID3, kTX1, 3e3, 1, kTIMESTAMP4); // 300 auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -1291,13 +1286,13 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ "mean": "92.5", "size": 4, - "standard_deviation": "138.8944443333378" + "standard_deviation": "138.8944443333377776" }}, "median": "30", "time": 1711461384, @@ -1323,26 +1318,24 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); constexpr auto kDOCUMENT_ID = 1; - auto const oracleIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; + auto const oracleIndex = xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 // return a tx which contains NewFields - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX1), _)) .WillOnce(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries( - {createOraclePriceData(1e3, ripple::to_currency("JPY"), ripple::to_currency("XRP"), 2)} - ), - ripple::to_string(oracleIndex), + createPriceDataSeries({createOraclePriceData(1e3, xrpl::toCurrency("JPY"), xrpl::toCurrency("XRP"), 2)}), + xrpl::to_string(oracleIndex), false, kTX1 ))); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "JPY", @@ -1359,7 +1352,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -1389,41 +1382,37 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NotFoundInTxHistory) .WillOnce(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); constexpr auto kDOCUMENT_ID = 1; - auto const oracleIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; + auto const oracleIndex = xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX1), _)) .WillOnce(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries( - {createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)} - ), - ripple::to_string(oracleIndex), + createPriceDataSeries({createOraclePriceData(1e3, xrpl::toCurrency("EUR"), xrpl::toCurrency("XRP"), 2)}), + xrpl::to_string(oracleIndex), false, kTX2 ))); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX2), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX2), _)) .WillRepeatedly(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries( - {createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)} - ), - ripple::to_string(oracleIndex), + createPriceDataSeries({createOraclePriceData(1e3, xrpl::toCurrency("EUR"), xrpl::toCurrency("XRP"), 2)}), + xrpl::to_string(oracleIndex), false, kTX2 ))); auto const handler = AnyHandler{GetAggregatePriceHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "JPY", diff --git a/tests/unit/rpc/handlers/LedgerDataTests.cpp b/tests/unit/rpc/handlers/LedgerDataTests.cpp index 0da5bb1b3..8a8320bc0 100644 --- a/tests/unit/rpc/handlers/LedgerDataTests.cpp +++ b/tests/unit/rpc/handlers/LedgerDataTests.cpp @@ -42,7 +42,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -170,7 +169,7 @@ TEST_P(LedgerDataParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -186,7 +185,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaIntSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": {} @@ -209,7 +208,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaStringSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": "{}" @@ -228,11 +227,11 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}" @@ -255,12 +254,11 @@ TEST_F(RPCLedgerDataHandlerTest, MarkerNotExist) .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) - .WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "marker": "{}" @@ -301,7 +299,7 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = @@ -318,7 +316,7 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(R"JSON({"limit": 10})JSON"); + auto const req = boost::json::parse(R"JSON({"limit": 10})JSON"); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); @@ -326,7 +324,7 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) // Note: the format of "close_time_human" depends on the platform and might differ per platform. It is however // guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLEDGER_EXPECTED)); EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 10); EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); @@ -359,7 +357,7 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = @@ -376,7 +374,7 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(R"JSON({"limit": 10})JSON"); + auto const req = boost::json::parse(R"JSON({"limit": 10})JSON"); auto output = handler.process(req, Context{.yield = yield, .apiVersion = 2}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); @@ -384,7 +382,7 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) // Note: the format of "close_time_human" depends on the platform and might differ per platform. It is however // guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLEDGER_EXPECTED)); }); } @@ -414,7 +412,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = @@ -432,7 +430,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(R"JSON({ + auto const req = boost::json::parse(R"JSON({ "limit": 10, "type": "state" })JSON"); @@ -444,7 +442,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter) // Note: the format of "close_time_human" depends on the platform and might differ per platform. It is however // guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLEDGER_EXPECTED)); EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 5); EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); @@ -477,7 +475,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + 1); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = @@ -485,7 +483,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) bbs.push_back(line.getSerializer().peekData()); } - auto const amm = createAmmObject(kACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2); + auto const amm = createAmmObject(kACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kACCOUNT2); bbs.push_back(amm.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -493,7 +491,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(R"JSON({ + auto const req = boost::json::parse(R"JSON({ "limit": 6, "type": "amm" })JSON"); @@ -505,7 +503,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) // Note: the format of "close_time_human" depends on the platform and might differ per platform. It is however // guaranteed to be consistent on the same platform. EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLEDGER_EXPECTED)); EXPECT_EQ(output.result->as_object().at("marker").as_string(), kINDEX2); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 1); EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); @@ -538,9 +536,8 @@ TEST_F(RPCLedgerDataHandlerTest, OutOfOrder) // marker return seq std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(2); - ON_CALL(*backend_, doFetchSuccessorKey(kFIRST_KEY, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX2}, kRANGE_MAX, _)) - .WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, doFetchSuccessorKey(kFIRST_KEY, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kINDEX2}, kRANGE_MAX, _)).WillByDefault(Return(std::nullopt)); auto const line = createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123); bbs.push_back(line.getSerializer().peekData()); @@ -550,12 +547,12 @@ TEST_F(RPCLedgerDataHandlerTest, OutOfOrder) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(R"JSON({"limit": 10, "out_of_order": true})JSON"); + auto const req = boost::json::parse(R"JSON({"limit": 10, "out_of_order": true})JSON"); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(output.result->as_object().at("ledger"), json::parse(kLEDGER_EXPECTED)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLEDGER_EXPECTED)); EXPECT_EQ(output.result->as_object().at("marker").as_uint64(), kRANGE_MAX); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 1); EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLEDGER_HASH); @@ -570,7 +567,7 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillByDefault( Return(createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123) .getSerializer() @@ -580,10 +577,10 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) auto limit = 10; std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX2}, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) + .WillByDefault(Return(xrpl::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kINDEX2}, kRANGE_MAX, _)) + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0) { auto const line = @@ -596,7 +593,7 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "limit": 10, @@ -631,9 +628,7 @@ TEST_F(RPCLedgerDataHandlerTest, DiffMarker) auto const line = createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123); bbs.push_back(line.getSerializer().peekData()); - los.emplace_back( - LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}} - ); // NOLINT(modernize-use-emplace) + los.emplace_back(LedgerObject{.key = xrpl::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace) } ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los)); @@ -642,7 +637,7 @@ TEST_F(RPCLedgerDataHandlerTest, DiffMarker) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "limit": 10, @@ -672,7 +667,7 @@ TEST_F(RPCLedgerDataHandlerTest, Binary) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0) { auto const line = @@ -685,7 +680,7 @@ TEST_F(RPCLedgerDataHandlerTest, Binary) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "limit": 10, "binary": true @@ -712,7 +707,7 @@ TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLIMIT_BINARY); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0u) { auto const line = @@ -725,7 +720,7 @@ TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "limit": {}, @@ -755,7 +750,7 @@ TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLIMIT_JSON); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0u) { auto const line = @@ -768,7 +763,7 @@ TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "limit": {}, @@ -795,7 +790,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); auto const issuance = createMptIssuanceObject(kACCOUNT, 2, "metadata"); bbs.push_back(issuance.getSerializer().peekData()); @@ -805,7 +800,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(R"JSON({ + auto const req = boost::json::parse(R"JSON({ "limit": 1, "type": "mpt_issuance" })JSON"); @@ -824,7 +819,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) // make sure mptID is synethetically parsed if object is mptIssuance EXPECT_EQ( objects.front().at("mpt_issuance_id").as_string(), - ripple::to_string(ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))) + xrpl::to_string(xrpl::makeMptID(2, getAccountIdWithString(kACCOUNT))) ); }); } @@ -837,9 +832,9 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPToken) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); - ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)).WillByDefault(Return(xrpl::uint256{kINDEX2})); - auto const mptoken = createMpTokenObject(kACCOUNT, ripple::makeMptID(2, getAccountIdWithString(kACCOUNT))); + auto const mptoken = createMpTokenObject(kACCOUNT, xrpl::makeMptID(2, getAccountIdWithString(kACCOUNT))); bbs.push_back(mptoken.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -847,7 +842,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPToken) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerDataHandler{backend_}}; - auto const req = json::parse(R"JSON({ + auto const req = boost::json::parse(R"JSON({ "limit": 1, "type": "mptoken" })JSON"); diff --git a/tests/unit/rpc/handlers/LedgerEntryTests.cpp b/tests/unit/rpc/handlers/LedgerEntryTests.cpp index 6c691b0a3..0945318f4 100644 --- a/tests/unit/rpc/handlers/LedgerEntryTests.cpp +++ b/tests/unit/rpc/handlers/LedgerEntryTests.cpp @@ -59,7 +59,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -2289,7 +2288,7 @@ TEST_P(LedgerEntryParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -2336,7 +2335,7 @@ TEST_P(IndexTest, InvalidIndexUint256) auto const index = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "{}": "invalid" @@ -2358,7 +2357,7 @@ TEST_P(IndexTest, InvalidIndexNotString) auto const index = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "{}": 123 @@ -2382,12 +2381,12 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotFound) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerHeader)); // return null for ledger entry - auto const key = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const key = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(key, kRANGE_MAX, _)).WillRepeatedly(Return(std::optional{})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "account_root": "{}" @@ -2405,8 +2404,8 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotFound) struct NormalPathTestBundle { std::string testName; std::string testJson; - ripple::uint256 expectedIndex; - ripple::STObject mockedEntity; + xrpl::uint256 expectedIndex; + xrpl::STObject mockedEntity; }; struct RPCLedgerEntryNormalPathTest : public RPCLedgerEntryTest, public WithParamInterface {}; @@ -2416,8 +2415,8 @@ generateTestValuesForNormalPathTest() { auto account1 = getAccountIdWithString(kACCOUNT); auto account2 = getAccountIdWithString(kACCOUNT2); - ripple::Currency currency; - ripple::to_currency(currency, "USD"); + xrpl::Currency currency; + xrpl::toCurrency(currency, "USD"); return std::vector{ NormalPathTestBundle{ @@ -2429,8 +2428,8 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createAccountRootObject(kACCOUNT2, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) + .expectedIndex = xrpl::uint256{kINDEX1}, + .mockedEntity = createAccountRootObject(kACCOUNT2, xrpl::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) }, NormalPathTestBundle{ .testName = "Payment_channel", @@ -2441,7 +2440,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400) }, NormalPathTestBundle{ @@ -2453,7 +2452,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ) @@ -2467,7 +2466,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createCheckLedgerObject(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2479,8 +2478,8 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createOwnerDirLedgerObject(std::vector{ripple::uint256{kINDEX1}}, kINDEX1) + .expectedIndex = xrpl::uint256{kINDEX1}, + .mockedEntity = createOwnerDirLedgerObject(std::vector{xrpl::uint256{kINDEX1}}, kINDEX1) }, NormalPathTestBundle{ .testName = "OfferIndex", @@ -2491,9 +2490,9 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createOfferLedgerObject( - kACCOUNT, 100, 200, "USD", "XRP", kACCOUNT2, ripple::toBase58(ripple::xrpAccount()), kINDEX1 + kACCOUNT, 100, 200, "USD", "XRP", kACCOUNT2, xrpl::toBase58(xrpl::xrpAccount()), kINDEX1 ) }, NormalPathTestBundle{ @@ -2505,7 +2504,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createEscrowLedgerObject(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2517,7 +2516,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createTicketLedgerObject(kACCOUNT, 0) }, NormalPathTestBundle{ @@ -2529,7 +2528,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createDepositPreauthLedgerObjectByAuth(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2541,7 +2540,7 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, + .expectedIndex = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, .mockedEntity = createAccountRootObject(kACCOUNT, 0, 1, 1, 1, kINDEX1, 1) }, NormalPathTestBundle{ @@ -2553,7 +2552,7 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::did(getAccountIdWithString(kACCOUNT)).key, + .expectedIndex = xrpl::keylet::did(getAccountIdWithString(kACCOUNT)).key, .mockedEntity = createDidObject(kACCOUNT, "mydocument", "myURI", "mydata") }, NormalPathTestBundle{ @@ -2568,8 +2567,8 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::keylet::page(ripple::uint256{kINDEX1}, 2).key, - .mockedEntity = createOwnerDirLedgerObject(std::vector{ripple::uint256{kINDEX1}}, kINDEX1) + .expectedIndex = xrpl::keylet::page(xrpl::uint256{kINDEX1}, 2).key, + .mockedEntity = createOwnerDirLedgerObject(std::vector{xrpl::uint256{kINDEX1}}, kINDEX1) }, NormalPathTestBundle{ .testName = "DirectoryViaOwner", @@ -2583,8 +2582,8 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::page(ripple::keylet::ownerDir(account1), 2).key, - .mockedEntity = createOwnerDirLedgerObject(std::vector{ripple::uint256{kINDEX1}}, kINDEX1) + .expectedIndex = xrpl::keylet::page(xrpl::keylet::ownerDir(account1), 2).key, + .mockedEntity = createOwnerDirLedgerObject(std::vector{xrpl::uint256{kINDEX1}}, kINDEX1) }, NormalPathTestBundle{ .testName = "DirectoryViaDefaultSubIndex", @@ -2598,8 +2597,8 @@ generateTestValuesForNormalPathTest() kACCOUNT ), // default sub_index is 0 - .expectedIndex = ripple::keylet::page(ripple::keylet::ownerDir(account1), 0).key, - .mockedEntity = createOwnerDirLedgerObject(std::vector{ripple::uint256{kINDEX1}}, kINDEX1) + .expectedIndex = xrpl::keylet::page(xrpl::keylet::ownerDir(account1), 0).key, + .mockedEntity = createOwnerDirLedgerObject(std::vector{xrpl::uint256{kINDEX1}}, kINDEX1) }, NormalPathTestBundle{ .testName = "Escrow", @@ -2613,7 +2612,7 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::escrow(account1, 1).key, + .expectedIndex = xrpl::keylet::escrow(account1, 1).key, .mockedEntity = createEscrowLedgerObject(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2629,7 +2628,7 @@ generateTestValuesForNormalPathTest() kACCOUNT, kACCOUNT2 ), - .expectedIndex = ripple::keylet::depositPreauth(account1, account2).key, + .expectedIndex = xrpl::keylet::depositPreauth(account1, account2).key, .mockedEntity = createDepositPreauthLedgerObjectByAuth(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2652,7 +2651,7 @@ generateTestValuesForNormalPathTest() kCREDENTIAL_TYPE ), .expectedIndex = - ripple::keylet::depositPreauth( + xrpl::keylet::depositPreauth( account1, credentials::createAuthCredentials(createAuthCredentialArray( std::vector{kACCOUNT2}, std::vector{kCREDENTIAL_TYPE} @@ -2677,12 +2676,10 @@ generateTestValuesForNormalPathTest() kCREDENTIAL_TYPE ), .expectedIndex = - ripple::keylet::credential( + xrpl::keylet::credential( account1, account2, - ripple::Slice( - ripple::strUnHex(kCREDENTIAL_TYPE)->data(), ripple::strUnHex(kCREDENTIAL_TYPE)->size() - ) + xrpl::Slice(xrpl::strUnHex(kCREDENTIAL_TYPE)->data(), xrpl::strUnHex(kCREDENTIAL_TYPE)->size()) ) .key, .mockedEntity = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE) @@ -2700,7 +2697,7 @@ generateTestValuesForNormalPathTest() kACCOUNT, kACCOUNT2 ), - .expectedIndex = ripple::keylet::line(account1, account2, currency).key, + .expectedIndex = xrpl::keylet::line(account1, account2, currency).key, .mockedEntity = createRippleStateLedgerObject("USD", kACCOUNT2, 100, kACCOUNT, 10, kACCOUNT2, 20, kINDEX1, 123, 0) }, @@ -2716,7 +2713,7 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::getTicketIndex(account1, 2), + .expectedIndex = xrpl::getTicketIndex(account1, 2), .mockedEntity = createTicketLedgerObject(kACCOUNT, 0) }, NormalPathTestBundle{ @@ -2731,9 +2728,9 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::offer(account1, 2).key, + .expectedIndex = xrpl::keylet::offer(account1, 2).key, .mockedEntity = createOfferLedgerObject( - kACCOUNT, 100, 200, "USD", "XRP", kACCOUNT2, ripple::toBase58(ripple::xrpAccount()), kINDEX1 + kACCOUNT, 100, 200, "USD", "XRP", kACCOUNT2, xrpl::toBase58(xrpl::xrpAccount()), kINDEX1 ) }, NormalPathTestBundle{ @@ -2745,8 +2742,8 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createAmmObject(kACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2) + .expectedIndex = xrpl::uint256{kINDEX1}, + .mockedEntity = createAmmObject(kACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kACCOUNT2) }, NormalPathTestBundle{ .testName = "AMMViaJson", @@ -2767,9 +2764,8 @@ generateTestValuesForNormalPathTest() kACCOUNT2 ), .expectedIndex = - ripple::keylet::amm(getIssue("XRP", ripple::toBase58(ripple::xrpAccount())), getIssue("JPY", kACCOUNT2)) - .key, - .mockedEntity = createAmmObject(kACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kACCOUNT2) + xrpl::keylet::amm(getIssue("XRP", xrpl::toBase58(xrpl::xrpAccount())), getIssue("JPY", kACCOUNT2)).key, + .mockedEntity = createAmmObject(kACCOUNT, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kACCOUNT2) }, NormalPathTestBundle{ .testName = "BridgeLocking", @@ -2794,14 +2790,14 @@ generateTestValuesForNormalPathTest() kACCOUNT2, kACCOUNT3 ), - .expectedIndex = ripple::keylet::bridge( - ripple::STXChainBridge( + .expectedIndex = xrpl::keylet::bridge( + xrpl::STXChainBridge( getAccountIdWithString(kACCOUNT), - ripple::xrpIssue(), + xrpl::xrpIssue(), getAccountIdWithString(kACCOUNT2), getIssue("JPY", kACCOUNT3) ), - ripple::STXChainBridge::ChainType::locking + xrpl::STXChainBridge::ChainType::Locking ) .key, .mockedEntity = createBridgeObject(kACCOUNT, kACCOUNT, kACCOUNT2, "JPY", kACCOUNT3) @@ -2829,14 +2825,14 @@ generateTestValuesForNormalPathTest() kACCOUNT2, kACCOUNT3 ), - .expectedIndex = ripple::keylet::bridge( - ripple::STXChainBridge( + .expectedIndex = xrpl::keylet::bridge( + xrpl::STXChainBridge( getAccountIdWithString(kACCOUNT), - ripple::xrpIssue(), + xrpl::xrpIssue(), getAccountIdWithString(kACCOUNT2), getIssue("JPY", kACCOUNT3) ), - ripple::STXChainBridge::ChainType::issuing + xrpl::STXChainBridge::ChainType::Issuing ) .key, .mockedEntity = createBridgeObject(kACCOUNT, kACCOUNT, kACCOUNT2, "JPY", kACCOUNT3) @@ -2863,10 +2859,10 @@ generateTestValuesForNormalPathTest() kACCOUNT2, kACCOUNT3 ), - .expectedIndex = ripple::keylet::xChainClaimID( - ripple::STXChainBridge( + .expectedIndex = xrpl::keylet::xChainClaimID( + xrpl::STXChainBridge( getAccountIdWithString(kACCOUNT), - ripple::xrpIssue(), + xrpl::xrpIssue(), getAccountIdWithString(kACCOUNT2), getIssue("JPY", kACCOUNT3) ), @@ -2897,10 +2893,10 @@ generateTestValuesForNormalPathTest() kACCOUNT2, kACCOUNT3 ), - .expectedIndex = ripple::keylet::xChainCreateAccountClaimID( - ripple::STXChainBridge( + .expectedIndex = xrpl::keylet::xChainCreateAccountClaimID( + xrpl::STXChainBridge( getAccountIdWithString(kACCOUNT), - ripple::xrpIssue(), + xrpl::xrpIssue(), getAccountIdWithString(kACCOUNT2), getIssue("JPY", kACCOUNT3) ), @@ -2921,19 +2917,17 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, + .expectedIndex = xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, .mockedEntity = createOracleObject( kACCOUNT, "70726F7669646572", 32u, 1234u, - ripple::Blob(8, 's'), - ripple::Blob(8, 's'), + xrpl::Blob(8, 's'), + xrpl::Blob(8, 's'), kRANGE_MAX - 2, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, - createPriceDataSeries( - {createOraclePriceData(2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3)} - ) + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + createPriceDataSeries({createOraclePriceData(2e4, xrpl::toCurrency("XRP"), xrpl::toCurrency("USD"), 3)}) ) }, NormalPathTestBundle{ @@ -2948,19 +2942,17 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, + .expectedIndex = xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, .mockedEntity = createOracleObject( kACCOUNT, "70726F7669646572", 32u, 1234u, - ripple::Blob(8, 's'), - ripple::Blob(8, 's'), + xrpl::Blob(8, 's'), + xrpl::Blob(8, 's'), kRANGE_MAX - 2, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, - createPriceDataSeries( - {createOraclePriceData(2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3)} - ) + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + createPriceDataSeries({createOraclePriceData(2e4, xrpl::toCurrency("XRP"), xrpl::toCurrency("USD"), 3)}) ) }, NormalPathTestBundle{ @@ -2970,21 +2962,19 @@ generateTestValuesForNormalPathTest() "binary": true, "oracle": "{}" }})JSON", - ripple::to_string(ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key) + xrpl::to_string(xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key) ), - .expectedIndex = ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, + .expectedIndex = xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), 1).key, .mockedEntity = createOracleObject( kACCOUNT, "70726F7669646572", 64u, 4321u, - ripple::Blob(8, 'a'), - ripple::Blob(8, 'a'), + xrpl::Blob(8, 'a'), + xrpl::Blob(8, 'a'), kRANGE_MAX - 4, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, - createPriceDataSeries( - {createOraclePriceData(1e3, ripple::to_currency("USD"), ripple::to_currency("XRP"), 2)} - ) + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + createPriceDataSeries({createOraclePriceData(1e3, xrpl::toCurrency("USD"), xrpl::toCurrency("XRP"), 2)}) ) }, NormalPathTestBundle{ @@ -2994,9 +2984,9 @@ generateTestValuesForNormalPathTest() "binary": true, "mpt_issuance": "{}" }})JSON", - ripple::to_string(ripple::makeMptID(2, account1)) + xrpl::to_string(xrpl::makeMptID(2, account1)) ), - .expectedIndex = ripple::keylet::mptIssuance(ripple::makeMptID(2, account1)).key, + .expectedIndex = xrpl::keylet::mptIssuance(xrpl::makeMptID(2, account1)).key, .mockedEntity = createMptIssuanceObject(kACCOUNT, 2, "metadata") }, NormalPathTestBundle{ @@ -3008,8 +2998,8 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createMpTokenObject(kACCOUNT, ripple::makeMptID(2, account1)) + .expectedIndex = xrpl::uint256{kINDEX1}, + .mockedEntity = createMpTokenObject(kACCOUNT, xrpl::makeMptID(2, account1)) }, NormalPathTestBundle{ .testName = "MPTokenViaObject", @@ -3022,10 +3012,10 @@ generateTestValuesForNormalPathTest() }} }})JSON", kACCOUNT, - ripple::to_string(ripple::makeMptID(2, account1)) + xrpl::to_string(xrpl::makeMptID(2, account1)) ), - .expectedIndex = ripple::keylet::mptoken(ripple::makeMptID(2, account1), account1).key, - .mockedEntity = createMpTokenObject(kACCOUNT, ripple::makeMptID(2, account1)) + .expectedIndex = xrpl::keylet::mptoken(xrpl::makeMptID(2, account1), account1).key, + .mockedEntity = createMpTokenObject(kACCOUNT, xrpl::makeMptID(2, account1)) }, NormalPathTestBundle{ .testName = "PermissionedDomainViaString", @@ -3036,8 +3026,8 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256(kINDEX1), - .mockedEntity = createPermissionedDomainObject(kACCOUNT, kINDEX1, kRANGE_MAX, 0, ripple::uint256{0}, 0) + .expectedIndex = xrpl::uint256(kINDEX1), + .mockedEntity = createPermissionedDomainObject(kACCOUNT, kINDEX1, kRANGE_MAX, 0, xrpl::uint256{0}, 0) }, NormalPathTestBundle{ .testName = "PermissionedDomainViaObject", @@ -3053,9 +3043,8 @@ generateTestValuesForNormalPathTest() kRANGE_MAX ), .expectedIndex = - ripple::keylet::permissionedDomain(ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX) - .key, - .mockedEntity = createPermissionedDomainObject(kACCOUNT, kINDEX1, kRANGE_MAX, 0, ripple::uint256{0}, 0) + xrpl::keylet::permissionedDomain(xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX).key, + .mockedEntity = createPermissionedDomainObject(kACCOUNT, kINDEX1, kRANGE_MAX, 0, xrpl::uint256{0}, 0) }, NormalPathTestBundle{ .testName = "CreateVaultObjectByHexString", @@ -3066,16 +3055,16 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = xrpl::uint256(kINDEX1), .mockedEntity = createVault( kACCOUNT, kACCOUNT, kRANGE_MAX, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{0}, + xrpl::uint256{0}, 0 ) }, @@ -3092,17 +3081,16 @@ generateTestValuesForNormalPathTest() kACCOUNT, kRANGE_MAX ), - .expectedIndex = - ripple::keylet::vault(ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX).key, + .expectedIndex = xrpl::keylet::vault(xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX).key, .mockedEntity = createVault( kACCOUNT, kACCOUNT, kRANGE_MAX, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{0}, + xrpl::uint256{0}, 0 ) }, @@ -3115,8 +3103,8 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, - .mockedEntity = createDelegateObject(kACCOUNT, kACCOUNT2, kINDEX1, 0, ripple::uint256{0}, 0) + .expectedIndex = xrpl::uint256{kINDEX1}, + .mockedEntity = createDelegateObject(kACCOUNT, kACCOUNT2, kINDEX1, 0, xrpl::uint256{0}, 0) }, NormalPathTestBundle{ .testName = "DelegateViaObject", @@ -3132,8 +3120,8 @@ generateTestValuesForNormalPathTest() kACCOUNT2 ), .expectedIndex = - ripple::keylet::delegate(getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2)).key, - .mockedEntity = createDelegateObject(kACCOUNT, kACCOUNT2, kINDEX1, 0, ripple::uint256{0}, 0) + xrpl::keylet::delegate(getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2)).key, + .mockedEntity = createDelegateObject(kACCOUNT, kACCOUNT2, kINDEX1, 0, xrpl::uint256{0}, 0) }, }; } @@ -3160,17 +3148,17 @@ TEST_P(RPCLedgerEntryNormalPathTest, NormalPath) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); auto const& outputJson = output.result.value(); EXPECT_EQ(outputJson.at("ledger_hash").as_string(), kLEDGER_HASH); EXPECT_EQ(outputJson.at("ledger_index").as_uint64(), kRANGE_MAX); EXPECT_EQ( - outputJson.at("node_binary").as_string(), ripple::strHex(testBundle.mockedEntity.getSerializer().peekData()) + outputJson.at("node_binary").as_string(), xrpl::strHex(testBundle.mockedEntity.getSerializer().peekData()) ); EXPECT_EQ( - ripple::uint256(boost::json::value_to(outputJson.at("index")).data()), testBundle.expectedIndex + xrpl::uint256(boost::json::value_to(outputJson.at("index")).data()), testBundle.expectedIndex ); }); } @@ -3205,12 +3193,12 @@ TEST_F(RPCLedgerEntryTest, BinaryFalse) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "payment_channel": "{}" @@ -3220,7 +3208,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalse) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -3237,18 +3225,17 @@ TEST_F(RPCLedgerEntryTest, Vault_BinaryFalse) kACCOUNT, kRANGE_MAX, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{1}, + xrpl::uint256{1}, 0 ); - auto const vaultKey = - ripple::keylet::vault(ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX).key; + auto const vaultKey = xrpl::keylet::vault(xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX).key; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{vault.getSerializer().peekData().data(), vault.getSerializer().peekData().size()}, vaultKey + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{vault.getSerializer().peekData().data(), vault.getSerializer().peekData().size()}, vaultKey }; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKey, testing::_, testing::_)) @@ -3256,7 +3243,7 @@ TEST_F(RPCLedgerEntryTest, Vault_BinaryFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "binary": false, @@ -3285,12 +3272,12 @@ TEST_F(RPCLedgerEntryTest, UnexpectedLedgerType) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "check": "{}" @@ -3311,7 +3298,7 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaIntSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "check": "{}", @@ -3335,7 +3322,7 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaStringSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "check": "{}", @@ -3355,11 +3342,11 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerEntryTest, LedgerNotExistViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillRepeatedly(Return(std::nullopt)); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillRepeatedly(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "check": "{}", @@ -3381,7 +3368,7 @@ TEST_F(RPCLedgerEntryTest, InvalidEntryTypeVersion2) { runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse(R"JSON({})JSON"); + auto const req = boost::json::parse(R"JSON({})JSON"); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -3394,7 +3381,7 @@ TEST_F(RPCLedgerEntryTest, InvalidEntryTypeVersion1) { runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse(R"JSON({})JSON"); + auto const req = boost::json::parse(R"JSON({})JSON"); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -3448,12 +3435,12 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleted) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "index": "{}", @@ -3464,7 +3451,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleted) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -3495,15 +3482,15 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(uint32_t{kRANGE_MAX})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 1, _)) .WillOnce(Return(offer.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "index": "{}", @@ -3514,7 +3501,7 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -3524,16 +3511,16 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotExist) { auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(uint32_t{kRANGE_MAX})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 1, _)) .WillOnce(Return(std::optional{})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "index": "{}", @@ -3581,12 +3568,12 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleteFalse) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "payment_channel": "{}", @@ -3597,7 +3584,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleteFalse) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -3641,14 +3628,14 @@ TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) // return valid ledger entry which can be deserialized auto const line1 = createRippleStateLedgerObject("USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123); auto const line2 = createRippleStateLedgerObject("USD", kACCOUNT, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(line1.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 1, _)) .WillRepeatedly(Return(line2.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "index": "{}", @@ -3659,7 +3646,7 @@ TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -3690,15 +3677,15 @@ TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(uint32_t{kRANGE_MAX - 4})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 5, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 5, _)) .WillOnce(Return(offer.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "index": "{}", @@ -3709,7 +3696,7 @@ TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -3719,14 +3706,14 @@ TEST_F(RPCLedgerEntryTest, ObjectSeqNotExist) { auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "index": "{}", @@ -3766,7 +3753,7 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) } })JSON"; - auto const mptId = ripple::makeMptID(2, getAccountIdWithString(kACCOUNT)); + auto const mptId = xrpl::makeMptID(2, getAccountIdWithString(kACCOUNT)); // return valid ledgerHeader auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); @@ -3774,21 +3761,21 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) // return valid ledger entry which can be deserialized auto const ledgerEntry = createMptIssuanceObject(kACCOUNT, 2, "metadata"); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::mptIssuance(mptId).key, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::mptIssuance(mptId).key, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance": "{}" }})JSON", - ripple::to_string(mptId) + xrpl::to_string(mptId) ) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } diff --git a/tests/unit/rpc/handlers/LedgerIndexTests.cpp b/tests/unit/rpc/handlers/LedgerIndexTests.cpp index 1014ffd78..9713edf05 100644 --- a/tests/unit/rpc/handlers/LedgerIndexTests.cpp +++ b/tests/unit/rpc/handlers/LedgerIndexTests.cpp @@ -45,7 +45,6 @@ constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF2 using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCLedgerIndexTest : HandlerBaseTestStrict { @@ -58,7 +57,7 @@ struct RPCLedgerIndexTest : HandlerBaseTestStrict { TEST_F(RPCLedgerIndexTest, DateStrNotValid) { auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; - auto const req = json::parse(R"JSON({"date": "not_a_number"})JSON"); + auto const req = boost::json::parse(R"JSON({"date": "not_a_number"})JSON"); runSpawn([&](auto yield) { auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -74,7 +73,7 @@ TEST_F(RPCLedgerIndexTest, NoDateGiven) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillOnce(Return(ledgerHeader)); auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; - auto const req = json::parse(R"JSON({})JSON"); + auto const req = boost::json::parse(R"JSON({})JSON"); runSpawn([&](auto yield) { auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); @@ -87,7 +86,7 @@ TEST_F(RPCLedgerIndexTest, NoDateGiven) TEST_F(RPCLedgerIndexTest, EarlierThanMinLedger) { auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; - auto const req = json::parse(R"JSON({"date": "2024-06-25T12:23:05Z"})JSON"); + auto const req = boost::json::parse(R"JSON({"date": "2024-06-25T12:23:05Z"})JSON"); auto const ledgerHeader = createLedgerHeaderWithUnixTime(kLEDGER_HASH, kRANGE_MIN, 1719318190); //"2024-06-25T12:23:10Z" EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MIN, _)).WillOnce(Return(ledgerHeader)); @@ -104,7 +103,7 @@ TEST_F(RPCLedgerIndexTest, ChangeTimeZone) // Note: setenv/unsetenv are included with but misc-include-cleaner still angry setenv("TZ", "EST+5", 1); // NOLINT(misc-include-cleaner) auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; - auto const req = json::parse(R"JSON({"date": "2024-06-25T12:23:05Z"})JSON"); + auto const req = boost::json::parse(R"JSON({"date": "2024-06-25T12:23:05Z"})JSON"); auto const ledgerHeader = createLedgerHeaderWithUnixTime(kLEDGER_HASH, kRANGE_MIN, 1719318190); //"2024-06-25T12:23:10Z" EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MIN, _)).WillOnce(Return(ledgerHeader)); @@ -169,7 +168,7 @@ INSTANTIATE_TEST_CASE_P( TEST_P(LedgerIndexTests, SearchFromLedgerRange) { auto const testBundle = GetParam(); - auto const jv = json::parse(testBundle.json).as_object(); + auto const jv = boost::json::parse(testBundle.json).as_object(); // start from 1719318190 , which is the unix time for 2024-06-25T12:23:10Z to 2024-06-25T12:23:50Z with // step 2 @@ -182,7 +181,7 @@ TEST_P(LedgerIndexTests, SearchFromLedgerRange) } auto const handler = AnyHandler{LedgerIndexHandler{backend_}}; - auto const req = json::parse(testBundle.json); + auto const req = boost::json::parse(testBundle.json); runSpawn([&](auto yield) { auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); diff --git a/tests/unit/rpc/handlers/LedgerRangeTests.cpp b/tests/unit/rpc/handlers/LedgerRangeTests.cpp index 426e74bc7..db6ca4170 100644 --- a/tests/unit/rpc/handlers/LedgerRangeTests.cpp +++ b/tests/unit/rpc/handlers/LedgerRangeTests.cpp @@ -27,7 +27,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -45,7 +44,7 @@ TEST_F(RPCLedgerRangeTest, LedgerRangeMinMaxSame) backend_->updateRange(kRANGE_MIN); auto const handler = AnyHandler{LedgerRangeHandler{backend_}}; - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); auto const json = output.result.value(); @@ -60,7 +59,7 @@ TEST_F(RPCLedgerRangeTest, LedgerRangeFullySet) backend_->setRange(kRANGE_MIN, kRANGE_MAX); auto const handler = AnyHandler{LedgerRangeHandler{backend_}}; - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); auto const json = output.result.value(); diff --git a/tests/unit/rpc/handlers/LedgerTests.cpp b/tests/unit/rpc/handlers/LedgerTests.cpp index 74d240587..2e462771c 100644 --- a/tests/unit/rpc/handlers/LedgerTests.cpp +++ b/tests/unit/rpc/handlers/LedgerTests.cpp @@ -62,7 +62,6 @@ constexpr auto kRANGE_MAX = 30; using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCLedgerHandlerTest : HandlerBaseTest { @@ -188,7 +187,7 @@ TEST_P(LedgerParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -204,7 +203,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaIntSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": {} @@ -227,7 +226,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaStringSequence) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": "{}" @@ -246,11 +245,11 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}" @@ -295,12 +294,12 @@ TEST_F(RPCLedgerHandlerTest, Default) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -312,7 +311,7 @@ TEST_F(RPCLedgerHandlerTest, ConditionallyNotSupportedFieldsDefaultValue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "full": false, "accounts": false, @@ -332,7 +331,7 @@ TEST_F(RPCLedgerHandlerTest, QueryViaLedgerIndex) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(R"JSON({"ledger_index": 15})JSON"); + auto const req = boost::json::parse(R"JSON({"ledger_index": 15})JSON"); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); @@ -343,11 +342,11 @@ TEST_F(RPCLedgerHandlerTest, QueryViaLedgerHash) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kINDEX1}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kINDEX1}, _)).WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(fmt::format(R"JSON({{"ledger_hash": "{}" }})JSON", kINDEX1)); + auto const req = boost::json::parse(fmt::format(R"JSON({{"ledger_hash": "{}" }})JSON", kINDEX1)); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); @@ -373,14 +372,14 @@ TEST_F(RPCLedgerHandlerTest, BinaryTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true })JSON" ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -421,7 +420,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinary) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true, "expand": true, @@ -430,7 +429,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinary) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -471,7 +470,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinaryV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true, "expand": true, @@ -480,7 +479,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinaryV2) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -559,7 +558,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinary) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": false, "expand": true, @@ -570,7 +569,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinary) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -652,7 +651,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinaryV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": false, "expand": true, @@ -663,7 +662,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandNotBinaryV2) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -685,7 +684,7 @@ TEST_F(RPCLedgerHandlerTest, TwoRequestInARowTransactionsExpandNotBinaryV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": false, "expand": true, @@ -695,7 +694,7 @@ TEST_F(RPCLedgerHandlerTest, TwoRequestInARowTransactionsExpandNotBinaryV2) auto output = handler.process(req, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); - auto const req2 = json::parse( + auto const req2 = boost::json::parse( fmt::format( R"JSON({{ "binary": false, @@ -723,11 +722,11 @@ TEST_F(RPCLedgerHandlerTest, TransactionsNotExpand) EXPECT_CALL(*backend_, fetchAllTransactionHashesInLedger).Times(1); ON_CALL(*backend_, fetchAllTransactionHashesInLedger(kRANGE_MAX, _)) - .WillByDefault(Return(std::vector{ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}})); + .WillByDefault(Return(std::vector{xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "transactions": true })JSON" @@ -736,7 +735,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsNotExpand) ASSERT_TRUE(output); EXPECT_EQ( output.result->as_object().at("ledger").at("transactions"), - json::parse(fmt::format(R"JSON(["{}", "{}"])JSON", kINDEX1, kINDEX2)) + boost::json::parse(fmt::format(R"JSON(["{}", "{}"])JSON", kINDEX1, kINDEX2)) ); }); } @@ -774,11 +773,11 @@ TEST_F(RPCLedgerHandlerTest, DiffNotBinary) EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); - los.push_back(LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace) + los.push_back(LedgerObject{.key = xrpl::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace) los.push_back( LedgerObject{ - .key = ripple::uint256{kINDEX1}, - .blob = createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) + .key = xrpl::uint256{kINDEX1}, + .blob = createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) .getSerializer() .peekData() } @@ -788,14 +787,14 @@ TEST_F(RPCLedgerHandlerTest, DiffNotBinary) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "diff": true })JSON" ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("ledger").at("diff"), json::parse(kEXPECTED_OUT)); + EXPECT_EQ(output.result->at("ledger").at("diff"), boost::json::parse(kEXPECTED_OUT)); }); } @@ -821,11 +820,11 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary) EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); - los.push_back(LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace) + los.push_back(LedgerObject{.key = xrpl::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace) los.push_back( LedgerObject{ - .key = ripple::uint256{kINDEX1}, - .blob = createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) + .key = xrpl::uint256{kINDEX1}, + .blob = createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3) .getSerializer() .peekData() } @@ -835,7 +834,7 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "diff": true, "binary": true @@ -843,7 +842,7 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->at("ledger").at("diff"), json::parse(kEXPECTED_OUT)); + EXPECT_EQ(output.result->at("ledger").at("diff"), boost::json::parse(kEXPECTED_OUT)); }); } @@ -922,7 +921,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsEmpty) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": false, "expand": true, @@ -934,7 +933,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsEmpty) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1002,7 +1001,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; auto const accountObject = createAccountRootObject( kACCOUNT, 0, kRANGE_MAX, 200 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 @@ -1013,7 +1012,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) // fee object 2*2+3->7 ; balance 200 - 7 -> 193 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)).WillByDefault(Return(feeBlob)); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRANGE_MAX, _)).WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1030,7 +1029,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": false, "expand": true, @@ -1042,7 +1041,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) ASSERT_TRUE(output); // remove human readable time, it is slightly different cross the platform EXPECT_EQ(output.result->as_object().at("ledger").as_object().erase("close_time_human"), 1); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1071,7 +1070,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; auto const accountObject = createAccountRootObject( kACCOUNT, 0, kRANGE_MAX, 200 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 @@ -1082,7 +1081,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) // fee object 2*2+3->7 ; balance 200 - 7 -> 193 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)).WillByDefault(Return(feeBlob)); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRANGE_MAX, _)).WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1099,7 +1098,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true, "expand": true, @@ -1109,7 +1108,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) ); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1132,7 +1131,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsIssuerIsSelf) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true, "expand": true, @@ -1175,7 +1174,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; auto const accountObject = createAccountRootObject(kACCOUNT, 0, kRANGE_MAX, 6 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0) .getSerializer() @@ -1184,7 +1183,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) // fee object 2*2+3->7 ; balance 6 - 7 -> -1 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)).WillByDefault(Return(feeBlob)); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRANGE_MAX, _)).WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1201,7 +1200,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true, "expand": true, @@ -1211,7 +1210,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) ); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUT)); }); } @@ -1224,10 +1223,10 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotXRP) // mock line auto const line = createRippleStateLedgerObject(kCURRENCY, kACCOUNT2, 50 /*balance*/, kACCOUNT, 10, kACCOUNT2, 20, kINDEX1, 123); - auto lineKey = ripple::keylet::line( + auto lineKey = xrpl::keylet::line( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::to_currency(std::string(kCURRENCY)) + xrpl::toCurrency(std::string(kCURRENCY)) ) .key; ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRANGE_MAX, _)) @@ -1247,7 +1246,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotXRP) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true, "expand": true, @@ -1285,12 +1284,12 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsIgnoreFreezeLine) 20, kINDEX1, 123, - ripple::lsfLowFreeze | ripple::lsfHighFreeze + xrpl::lsfLowFreeze | xrpl::lsfHighFreeze ); - auto lineKey = ripple::keylet::line( + auto lineKey = xrpl::keylet::line( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::to_currency(std::string(kCURRENCY)) + xrpl::toCurrency(std::string(kCURRENCY)) ) .key; ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRANGE_MAX, _)) @@ -1310,7 +1309,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsIgnoreFreezeLine) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( R"JSON({ "binary": true, "expand": true, diff --git a/tests/unit/rpc/handlers/MPTHoldersTests.cpp b/tests/unit/rpc/handlers/MPTHoldersTests.cpp index ca7f4edd9..2f72da8fd 100644 --- a/tests/unit/rpc/handlers/MPTHoldersTests.cpp +++ b/tests/unit/rpc/handlers/MPTHoldersTests.cpp @@ -30,10 +30,10 @@ #include #include #include -#include -#include -#include +#include #include +#include +#include #include #include @@ -42,7 +42,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -81,7 +80,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonHexLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -103,7 +102,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonStringLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -125,7 +124,7 @@ TEST_F(RPCMPTHoldersHandlerTest, InvalidLedgerIndexString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -148,7 +147,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MPTIDInvalidFormat) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "mpt_issuance_id": "xxx" })JSON"); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -164,7 +163,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MPTIDMissing) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse(R"JSON({})JSON"); + auto const input = boost::json::parse(R"JSON({})JSON"); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -178,7 +177,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MPTIDNotString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "mpt_issuance_id": 12 })JSON"); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -195,7 +194,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerInvalidFormat) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -217,7 +216,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerNotString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -239,10 +238,10 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -267,8 +266,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -290,8 +289,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerStringIndex) TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -316,9 +315,9 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerinfo = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerinfo)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerinfo)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -344,7 +343,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2) // no need to check from db,call fetchLedgerBySequence 0 time // differ from previous logic EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -367,12 +366,12 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCMPTHoldersHandlerTest, MPTNotFound) { auto ledgerinfo = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerinfo)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerinfo)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -409,19 +408,18 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( - *backend_, - fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) + *backend_, fetchMPTHolders(xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}" @@ -433,7 +431,7 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters) auto handler = AnyHandler{MPTHoldersHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -459,19 +457,18 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID), 0); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID), 0); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( - *backend_, - fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) + *backend_, fetchMPTHolders(xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}" @@ -483,7 +480,7 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts) auto handler = AnyHandler{MPTHoldersHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -506,22 +503,22 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, specificLedger); ON_CALL(*backend_, fetchLedgerBySequence(specificLedger, _)).WillByDefault(Return(ledgerInfo)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, specificLedger, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(specificLedger), testing::_ + xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(specificLedger), testing::_ ) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -535,7 +532,7 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex) auto handler = AnyHandler{MPTHoldersHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -552,25 +549,25 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter) }})JSON", kMPT_ID, kMPT_OUT2, - ripple::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)) + xrpl::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)) ); auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; auto const marker = getAccountIdWithString(kHOLDE_R1_ACCOUNT); ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = marker})); EXPECT_CALL( - *backend_, fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_) + *backend_, fetchMPTHolders(xrpl::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_) ) .Times(1); - auto const holder1AccountId = ripple::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)); - auto const input = json::parse( + auto const holder1AccountId = xrpl::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -584,7 +581,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter) auto handler = AnyHandler{MPTHoldersHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -605,20 +602,19 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); - auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); + auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken1.getSerializer().peekData(), mptoken2.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( - *backend_, - fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) + *backend_, fetchMPTHolders(xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}" @@ -630,7 +626,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) auto handler = AnyHandler{MPTHoldersHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -650,16 +646,16 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), + xrpl::uint192(kMPT_ID), Const(MPTHoldersHandler::kLIMIT_MAX), testing::Eq(std::nullopt), Const(30), @@ -668,7 +664,7 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -682,6 +678,6 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx) auto handler = AnyHandler{MPTHoldersHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } diff --git a/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp b/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp index a511c5b8e..fd1204a8b 100644 --- a/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp @@ -42,7 +42,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -66,7 +65,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonHexLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -88,7 +87,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitNotInt) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -109,7 +108,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitNegative) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -130,7 +129,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitZero) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -151,7 +150,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonStringLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -173,7 +172,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, InvalidLedgerIndexString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -196,7 +195,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NFTIDInvalidFormat) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "nft_id": "00080000B4F4AFC5FBCBD76873F18006173D2193467D3EE7" })JSON"); auto const output = handler.process(input, Context{.yield = yield}); @@ -212,7 +211,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NFTIDNotString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "nft_id": 12 })JSON"); auto const output = handler.process(input, Context{.yield = yield}); @@ -228,11 +227,11 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -257,9 +256,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -284,9 +283,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -312,7 +311,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex2) // no need to check from db, call fetchLedgerBySequence 0 time // differ from previous logic EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -335,11 +334,11 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTBuyOffersHandlerTest, NoNFT) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::nullopt)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -363,7 +362,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MarkerNotString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -382,12 +381,12 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MarkerNotString) } // error case : invalid marker -// marker format in this RPC is a hex-string of a ripple::uint256. +// marker format in this RPC is a hex-string of a xrpl::uint256. TEST_F(RPCNFTBuyOffersHandlerTest, InvalidMarker) { runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -405,7 +404,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, InvalidMarker) }); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -449,8 +448,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNFT_ID}); + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -464,7 +463,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -477,7 +476,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCORRECT_OUTPUT), *output.result); }); } @@ -489,16 +488,16 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 500; auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -506,7 +505,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -537,28 +536,28 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsForInputWithMarkerAndLimit) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 500; auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorBuyOffer = createNftBuyOffer(kNFT_ID, kACCOUNT); // first is nft offer object - auto const cursor = ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + auto const cursor = xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorBuyOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(3); @@ -566,7 +565,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsForInputWithMarkerAndLimit) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -600,28 +599,28 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 100; auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorBuyOffer = createNftBuyOffer(kNFT_ID, kACCOUNT); // first is nft offer object - auto const cursor = ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + auto const cursor = xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorBuyOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(7); @@ -631,7 +630,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi runSpawn([&, this](auto yield) { auto handler = AnyHandler{NFTBuyOffersHandler{this->backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -652,7 +651,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -667,7 +666,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLimi runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -688,9 +687,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNFT_ID}); auto const ownerDir = - createOwnerDirLedgerObject(std::vector{NFTBuyOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject(std::vector{NFTBuyOffersHandler::kLIMIT_MIN + 1, xrpl::uint256{kINDEX1}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -705,7 +704,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitLessThanMin) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -732,9 +731,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNFT_ID}); auto const ownerDir = - createOwnerDirLedgerObject(std::vector{NFTBuyOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1); + createOwnerDirLedgerObject(std::vector{NFTBuyOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -749,7 +748,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitMoreThanMax) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", diff --git a/tests/unit/rpc/handlers/NFTHistoryTests.cpp b/tests/unit/rpc/handlers/NFTHistoryTests.cpp index f79820c01..c2a29df18 100644 --- a/tests/unit/rpc/handlers/NFTHistoryTests.cpp +++ b/tests/unit/rpc/handlers/NFTHistoryTests.cpp @@ -40,7 +40,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -255,7 +254,7 @@ TEST_P(NFTHistoryParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -270,19 +269,19 @@ genTransactions(uint32_t seq1, uint32_t seq2) { auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = seq1; - ripple::STObject const metaObj = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + xrpl::STObject const metaObj = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); trans1.metadata = metaObj.getSerializer().peekData(); trans1.date = 1; transactions.push_back(trans1); auto trans2 = TransactionAndMetadata(); - ripple::STObject const obj2 = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj2 = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32); trans2.transaction = obj.getSerializer().peekData(); trans2.ledgerSequence = seq2; - ripple::STObject const metaObj2 = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); + xrpl::STObject const metaObj2 = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23); trans2.metadata = metaObj2.getSerializer().peekData(); trans2.date = 2; transactions.push_back(trans2); @@ -308,7 +307,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -326,7 +325,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_FALSE(output.result->as_object().contains("limit")); }); @@ -446,7 +445,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV1) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -586,7 +585,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -620,7 +619,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -638,7 +637,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_FALSE(output.result->as_object().contains("limit")); }); @@ -663,7 +662,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -681,7 +680,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_FALSE(output.result->as_object().contains("limit")); }); @@ -706,7 +705,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -724,7 +723,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( output.result->at("transactions").as_array()[0].as_object().at("meta").as_string(), @@ -762,7 +761,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -780,7 +779,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( output.result->at("transactions").as_array()[0].as_object().at("meta_blob").as_string(), @@ -815,7 +814,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -836,7 +835,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ); EXPECT_EQ(output.result->at("limit").as_uint64(), 2); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); }); } @@ -865,7 +864,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerIndex) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -893,7 +892,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificNonexistLedgerIntIndex) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -918,7 +917,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificNonexistLedgerStringIndex) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -956,11 +955,11 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -1000,7 +999,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -1043,7 +1042,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -1063,7 +1062,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 2); EXPECT_EQ(output.result->at("transactions").as_array().size(), 1); EXPECT_FALSE(output.result->as_object().contains("limit")); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); }); } @@ -1086,7 +1085,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTHistoryHandler{backend_}}; - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -1106,7 +1105,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) EXPECT_EQ(output.result->at("nft_id").as_string(), kNFT_ID); EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1); EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1); - EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); + EXPECT_EQ(output.result->at("marker").as_object(), boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON")); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ(output.result->as_object().at("limit").as_uint64(), NFTHistoryHandler::kLIMIT_MAX); }); diff --git a/tests/unit/rpc/handlers/NFTInfoTests.cpp b/tests/unit/rpc/handlers/NFTInfoTests.cpp index 937291ba6..2d0c426d1 100644 --- a/tests/unit/rpc/handlers/NFTInfoTests.cpp +++ b/tests/unit/rpc/handlers/NFTInfoTests.cpp @@ -38,7 +38,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -61,7 +60,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonHexLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTInfoHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -83,7 +82,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonStringLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTInfoHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -105,7 +104,7 @@ TEST_F(RPCNFTInfoHandlerTest, InvalidLedgerIndexString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTInfoHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -128,7 +127,7 @@ TEST_F(RPCNFTInfoHandlerTest, NFTIDInvalidFormat) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTInfoHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "nft_id": "00080000B4F4AFC5FBCBD76873F18006173D2193467D3EE7" })JSON"); auto const output = handler.process(input, Context{.yield = yield}); @@ -144,7 +143,7 @@ TEST_F(RPCNFTInfoHandlerTest, NFTIDNotString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTInfoHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "nft_id": 12 })JSON"); auto const output = handler.process(input, Context{.yield = yield}); @@ -160,11 +159,11 @@ TEST_F(RPCNFTInfoHandlerTest, NFTIDNotString) TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -189,9 +188,9 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -213,9 +212,9 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerStringIndex) TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -240,9 +239,9 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -268,7 +267,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2) // no need to check from db,call fetchLedgerBySequence 0 time // differ from previous logic EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -291,12 +290,12 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTInfoHandlerTest, NonExistNFT) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch nft return empty ON_CALL(*backend_, fetchNFT).WillByDefault(Return(std::optional{})); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); - auto const input = json::parse( + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -340,9 +339,9 @@ TEST_F(RPCNFTInfoHandlerTest, DefaultParameters) // fetch nft return something auto const nft = std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -354,7 +353,7 @@ TEST_F(RPCNFTInfoHandlerTest, DefaultParameters) auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCURRENT_OUTPUT), *output.result); }); } @@ -381,11 +380,11 @@ TEST_F(RPCNFTInfoHandlerTest, BurnedNFT) // fetch nft return something auto const nft = - std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, ripple::Blob{'u', 'r', 'i'}, true)); + std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, xrpl::Blob{'u', 'r', 'i'}, true)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -397,7 +396,7 @@ TEST_F(RPCNFTInfoHandlerTest, BurnedNFT) auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCURRENT_OUTPUT), *output.result); }); } @@ -423,11 +422,11 @@ TEST_F(RPCNFTInfoHandlerTest, NotBurnedNFTWithoutURI) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // fetch nft return something - auto const nft = std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, ripple::Blob{})); + auto const nft = std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, xrpl::Blob{})); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -439,7 +438,7 @@ TEST_F(RPCNFTInfoHandlerTest, NotBurnedNFTWithoutURI) auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCURRENT_OUTPUT), *output.result); }); } @@ -467,9 +466,9 @@ TEST_F(RPCNFTInfoHandlerTest, NFTWithExtraFieldsSet) // fetch nft return something auto const nft = std::make_optional(createNft(kNFT_ID2, kACCOUNT, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID2}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID2}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -481,6 +480,6 @@ TEST_F(RPCNFTInfoHandlerTest, NFTWithExtraFieldsSet) auto handler = AnyHandler{NFTInfoHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCURRENT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCURRENT_OUTPUT), *output.result); }); } diff --git a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp index 3f52db17e..d595cd186 100644 --- a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp @@ -42,7 +42,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -66,7 +65,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitNotInt) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -87,7 +86,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitNegative) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -108,7 +107,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitZero) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -129,7 +128,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonHexLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -151,7 +150,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonStringLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -173,7 +172,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, InvalidLedgerIndexString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -196,7 +195,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NFTIDInvalidFormat) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "nft_id": "00080000B4F4AFC5FBCBD76873F18006173D2193467D3EE7" })JSON"); auto const output = handler.process(input, Context{.yield = yield}); @@ -212,7 +211,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NFTIDNotString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "nft_id": 12 })JSON"); auto const output = handler.process(input, Context{.yield = yield}); @@ -228,11 +227,11 @@ TEST_F(RPCNFTSellOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -257,9 +256,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -284,9 +283,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -312,7 +311,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex2) // no need to check from db, call fetchLedgerBySequence 0 time // differ from previous logic EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -335,11 +334,11 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTSellOffersHandlerTest, NoNFT) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::nullopt)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -363,7 +362,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, MarkerNotString) { runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -382,12 +381,12 @@ TEST_F(RPCNFTSellOffersHandlerTest, MarkerNotString) } // error case : invalid marker -// marker format in this RPC is a hex-string of a ripple::uint256. +// marker format in this RPC is a hex-string of a xrpl::uint256. TEST_F(RPCNFTSellOffersHandlerTest, InvalidMarker) { runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -405,7 +404,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, InvalidMarker) }); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -449,8 +448,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNFT_ID}); + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -464,7 +463,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -477,7 +476,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCORRECT_OUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kCORRECT_OUTPUT), *output.result); }); } @@ -489,16 +488,16 @@ TEST_F(RPCNFTSellOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 500; auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -506,7 +505,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -537,28 +536,28 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsForInputWithMarkerAndLimit) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 500; auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorSellOffer = createNftSellOffer(kNFT_ID, kACCOUNT); // first is nft offer object - auto const cursor = ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + auto const cursor = xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorSellOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(3); @@ -566,7 +565,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsForInputWithMarkerAndLimit) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -600,28 +599,28 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(3); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 100; auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorSellOffer = createNftSellOffer(kNFT_ID, kACCOUNT); // first is nft offer object - auto const cursor = ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + auto const cursor = xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorSellOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(7); @@ -631,7 +630,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim runSpawn([&, this](auto yield) { auto handler = AnyHandler{NFTSellOffersHandler{this->backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -652,7 +651,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -667,7 +666,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, ResultsWithoutMarkerForInputWithMarkerAndLim runSpawn([this](auto yield) { auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -688,10 +687,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); - auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 - ); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNFT_ID}); + auto const ownerDir = + createOwnerDirLedgerObject(std::vector{NFTSellOffersHandler::kLIMIT_MIN + 1, xrpl::uint256{kINDEX1}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -706,7 +704,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitLessThanMin) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -733,10 +731,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); - auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 - ); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNFT_ID}); + auto const ownerDir = + createOwnerDirLedgerObject(std::vector{NFTSellOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -751,7 +748,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitMoreThanMax) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", diff --git a/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp b/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp index 2caa90117..a7585cf33 100644 --- a/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp +++ b/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp @@ -41,7 +41,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -105,7 +104,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonHexLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -127,7 +126,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonStringLedgerHash) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -149,7 +148,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, InvalidLedgerIndexString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -172,7 +171,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NFTIssuerInvalidFormat) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "issuer": "xxx" })JSON"); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -188,7 +187,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NFTIssuerMissing) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; - auto const input = json::parse(R"JSON({})JSON"); + auto const input = boost::json::parse(R"JSON({})JSON"); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -202,7 +201,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NFTIssuerNotString) { runSpawn([this](boost::asio::yield_context yield) { auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "issuer": 12 })JSON"); auto const output = handler.process(input, Context{.yield = std::ref(yield)}); @@ -219,10 +218,10 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -247,8 +246,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -270,8 +269,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerStringIndex) TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty - EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); - auto const input = json::parse( + EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -296,9 +295,9 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -324,7 +323,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIndex2) // no need to check from db,call fetchLedgerBySequence 0 time // differ from previous logic EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -347,12 +346,12 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTsByIssuerHandlerTest, AccountNotFound) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -389,7 +388,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); std::vector const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; @@ -397,7 +396,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), _, Eq(std::nullopt), _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}" @@ -409,7 +408,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -442,7 +441,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, specificLedger); ON_CALL(*backend_, fetchLedgerBySequence(specificLedger, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, specificLedger, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); @@ -452,7 +451,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex) EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(specificLedger), _, Eq(std::nullopt), _)) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -466,7 +465,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex) auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -487,7 +486,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); std::vector const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; @@ -495,7 +494,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Optional(0), Const(30), _, Eq(std::nullopt), _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -508,7 +507,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -529,16 +528,16 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MarkerParameter) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); std::vector const nfts = {createNft(kNFT_ID3, kACCOUNT, 29)}; auto const account = getAccountIdWithString(kACCOUNT); ON_CALL(*backend_, fetchNFTsByIssuer) - .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = ripple::uint256{kNFT_ID3}})); - EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(ripple::uint256{kNFT_ID1}), _)).Times(1); + .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = xrpl::uint256{kNFT_ID3}})); + EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(xrpl::uint256{kNFT_ID1}), _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -552,7 +551,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MarkerParameter) auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -574,7 +573,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); std::vector const nfts = { @@ -584,7 +583,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}})); EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), _, Eq(std::nullopt), _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}" @@ -596,7 +595,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } @@ -616,7 +615,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); std::vector const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; @@ -628,7 +627,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -642,6 +641,6 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(currentOutput), *output.result); + EXPECT_EQ(boost::json::parse(currentOutput), *output.result); }); } diff --git a/tests/unit/rpc/handlers/NoRippleCheckTests.cpp b/tests/unit/rpc/handlers/NoRippleCheckTests.cpp index 18a03e08f..b5d4fbae0 100644 --- a/tests/unit/rpc/handlers/NoRippleCheckTests.cpp +++ b/tests/unit/rpc/handlers/NoRippleCheckTests.cpp @@ -40,7 +40,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -174,7 +173,7 @@ TEST_P(NoRippleCheckParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2}); ASSERT_FALSE(output); @@ -197,7 +196,7 @@ TEST_F(NoRippleCheckParameterTest, V1ApiTransactionsIsNotBool) EXPECT_CALL(*backend_, fetchLedgerBySequence); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; - auto const req = json::parse(kREQ_JSON); + auto const req = boost::json::parse(kREQ_JSON); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1}); ASSERT_FALSE(output); @@ -211,9 +210,9 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -242,7 +241,7 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaIntIndex) // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -271,7 +270,7 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaStringIndex) // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kSEQ, _)).WillByDefault(Return(std::nullopt)); - static auto const kINPUT = json::parse( + static auto const kINPUT = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -295,12 +294,12 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaStringIndex) TEST_F(RPCNoRippleCheckTest, AccountNotExist) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -335,26 +334,26 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return(createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData())); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + .WillByDefault(Return( + createAccountRootObject(kACCOUNT, xrpl::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + )); + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -364,7 +363,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -379,7 +378,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } @@ -398,14 +397,14 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -421,7 +420,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -436,7 +435,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } @@ -455,26 +454,26 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return(createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData())); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + .WillByDefault(Return( + createAccountRootObject(kACCOUNT, xrpl::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + )); + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -484,7 +483,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -499,7 +498,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } @@ -517,14 +516,14 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -540,7 +539,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -555,7 +554,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } @@ -564,17 +563,17 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR static constexpr auto kSEQ = 30; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); @@ -589,7 +588,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -615,26 +614,26 @@ TEST_F(RPCNoRippleCheckTest, NormalPathLimit) constexpr auto kSEQ = 30; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return(createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData())); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + .WillByDefault(Return( + createAccountRootObject(kACCOUNT, xrpl::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + )); + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -644,7 +643,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathLimit) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -714,13 +713,13 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) }})JSON", kTRANSACTION_SEQ, kTRANSACTION_SEQ + 1, - ripple::tfClearNoRipple, + xrpl::tfClearNoRipple, kTRANSACTION_SEQ + 2, - ripple::tfClearNoRipple + xrpl::tfClearNoRipple ); auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -728,20 +727,20 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) .WillByDefault(Return( createAccountRootObject(kACCOUNT, 0, kTRANSACTION_SEQ, 200, 2, kINDEX1, 2).getSerializer().peekData() )); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -751,7 +750,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -767,7 +766,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(expectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(expectedOutput)); }); } @@ -776,24 +775,23 @@ TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax) constexpr auto kSEQ = 30; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return(createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData())); - auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NoRippleCheckHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 - ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + .WillByDefault(Return( + createAccountRootObject(kACCOUNT, xrpl::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() + )); + auto const ownerDir = + createOwnerDirLedgerObject(std::vector{NoRippleCheckHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -805,7 +803,7 @@ TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax) ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", diff --git a/tests/unit/rpc/handlers/ServerInfoTests.cpp b/tests/unit/rpc/handlers/ServerInfoTests.cpp index a35471ccb..e4c4c265d 100644 --- a/tests/unit/rpc/handlers/ServerInfoTests.cpp +++ b/tests/unit/rpc/handlers/ServerInfoTests.cpp @@ -43,7 +43,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using TestServerInfoHandler = BaseServerInfoHandler; @@ -143,7 +142,7 @@ TEST_F(RPCServerInfoHandlerTest, NoLedgerHeaderErrorsOutWithInternal) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -164,7 +163,7 @@ TEST_F(RPCServerInfoHandlerTest, NoFeesErrorsOutWithInternal) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -198,7 +197,7 @@ TEST_F(RPCServerInfoHandlerTest, DefaultOutputIsPresent) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); validateNormalOutput(output); @@ -235,7 +234,7 @@ TEST_F(RPCServerInfoHandlerTest, AmendmentBlockedIsPresentIfSet) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); validateNormalOutput(output); @@ -270,7 +269,7 @@ TEST_F(RPCServerInfoHandlerTest, CorruptionDetectedIsPresentIfSet) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); validateNormalOutput(output); @@ -303,7 +302,7 @@ TEST_F(RPCServerInfoHandlerTest, CacheReportsEnabledFlagCorrectly) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); validateNormalOutput(output); @@ -316,7 +315,7 @@ TEST_F(RPCServerInfoHandlerTest, CacheReportsEnabledFlagCorrectly) backend_->cache().setDisabled(); runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, false, kCLIENT_IP}); validateNormalOutput(output); @@ -333,7 +332,7 @@ TEST_F(RPCServerInfoHandlerTest, AdminSectionPresentWhenAdminFlagIsSet) MockCounters* rawCountersPtr = mockCountersPtr_.get(); MockETLService* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -358,7 +357,7 @@ TEST_F(RPCServerInfoHandlerTest, AdminSectionPresentWhenAdminFlagIsSet) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, true}); validateNormalOutput(output); @@ -372,7 +371,7 @@ TEST_F(RPCServerInfoHandlerTest, BackendCountersPresentWhenRequestWithParam) MockCounters* rawCountersPtr = mockCountersPtr_.get(); MockETLService* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -399,7 +398,7 @@ TEST_F(RPCServerInfoHandlerTest, BackendCountersPresentWhenRequestWithParam) }}; runSpawn([&](auto yield) { - auto const req = json::parse(R"JSON( + auto const req = boost::json::parse(R"JSON( { "backend_counters": true } @@ -417,7 +416,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent) MockCounters* rawCountersPtr = mockCountersPtr_.get(); MockETLService* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -428,7 +427,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent) EXPECT_CALL(*rawETLServicePtr, isAmendmentBlocked).WillOnce(Return(false)); - auto const rippledObj = json::parse(R"JSON({ + auto const rippledObj = boost::json::parse(R"JSON({ "result": { "info": { "build_version": "1234", @@ -452,7 +451,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, true}); validateNormalOutput(output); @@ -467,7 +466,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesMissingNoExceptionThrown) MockCounters* rawCountersPtr = mockCountersPtr_.get(); MockETLService* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -478,7 +477,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesMissingNoExceptionThrown) EXPECT_CALL(*rawETLServicePtr, isAmendmentBlocked).WillOnce(Return(false)); - auto const rippledObj = json::parse(R"JSON({ + auto const rippledObj = boost::json::parse(R"JSON({ "result": { "info": {} } @@ -497,7 +496,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesMissingNoExceptionThrown) }}; runSpawn([&](auto yield) { - auto const req = json::parse("{}"); + auto const req = boost::json::parse("{}"); auto const output = handler.process(req, Context{yield, {}, true}); validateNormalOutput(output); diff --git a/tests/unit/rpc/handlers/SubscribeTests.cpp b/tests/unit/rpc/handlers/SubscribeTests.cpp index c24a21915..eeedef55b 100644 --- a/tests/unit/rpc/handlers/SubscribeTests.cpp +++ b/tests/unit/rpc/handlers/SubscribeTests.cpp @@ -51,7 +51,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using std::chrono::milliseconds; @@ -584,7 +583,7 @@ TEST_P(SubscribeParameterTest, InvalidParams) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{SubscribeHandler{backend_, mockAmendmentCenterPtr_, mockSubscriptionManagerPtr_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -599,7 +598,7 @@ TEST_F(RPCSubscribeHandlerTest, EmptyResponse) auto const handler = AnyHandler{SubscribeHandler{backend_, mockAmendmentCenterPtr_, mockSubscriptionManagerPtr_}}; EXPECT_CALL(*mockSession_, setApiSubversion(0)); - auto const output = handler.process(json::parse(R"JSON({})JSON"), Context{yield, session_}); + auto const output = handler.process(boost::json::parse(R"JSON({})JSON"), Context{yield, session_}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().empty()); }); @@ -608,7 +607,7 @@ TEST_F(RPCSubscribeHandlerTest, EmptyResponse) TEST_F(RPCSubscribeHandlerTest, StreamsWithoutLedger) { // these streams don't return response - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "streams": ["transactions_proposed", "transactions", "validations", "manifests", "book_changes"] })JSON" @@ -642,7 +641,7 @@ TEST_F(RPCSubscribeHandlerTest, StreamsLedger) "reserve_inc": 2 })JSON"; - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "streams": ["ledger"] })JSON" @@ -657,13 +656,13 @@ TEST_F(RPCSubscribeHandlerTest, StreamsLedger) EXPECT_CALL(*mockSession_, setApiSubversion(0)); auto const output = handler.process(input, Context{yield, session_}); ASSERT_TRUE(output); - EXPECT_EQ(output.result->as_object(), json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(output.result->as_object(), boost::json::parse(kEXPECTED_OUTPUT)); }); } TEST_F(RPCSubscribeHandlerTest, Accounts) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "accounts": ["{}", "{}", "{}"] @@ -688,7 +687,7 @@ TEST_F(RPCSubscribeHandlerTest, Accounts) TEST_F(RPCSubscribeHandlerTest, AccountsProposed) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "accounts_proposed": ["{}", "{}", "{}"] @@ -714,7 +713,7 @@ TEST_F(RPCSubscribeHandlerTest, AccountsProposed) TEST_F(RPCSubscribeHandlerTest, JustBooks) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "books": [ @@ -745,7 +744,7 @@ TEST_F(RPCSubscribeHandlerTest, JustBooks) TEST_F(RPCSubscribeHandlerTest, BooksBothSet) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "books": [ @@ -777,7 +776,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSet) TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "books": [ @@ -802,57 +801,55 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) auto const issuer = getAccountIdWithString(kACCOUNT); auto const getsXRPPaysUSDBook = getBookBase( - rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount(), std::nullopt) - .value() + rpc::parseBook(xrpl::toCurrency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt).value() ); auto const reversedBook = getBookBase( - rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), issuer, std::nullopt) - .value() + rpc::parseBook(xrpl::xrpCurrency(), xrpl::xrpAccount(), xrpl::toCurrency("USD"), issuer, std::nullopt).value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) .WillByDefault(Return(std::nullopt)); ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(4); // 2 book dirs + 2 issuer global freeze + 2 transferRate + 1 owner root + 1 fee EXPECT_CALL(*backend_, doFetchLedgerObject).Times(8); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) + auto const indexes = std::vector(10, xrpl::uint256{kINDEX2}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) .WillByDefault(Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData())); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kINDEX1}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _)) + auto const indexes2 = std::vector(10, xrpl::uint256{kINDEX1}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _)) .WillByDefault(Return(createOwnerDirLedgerObject(indexes2, kINDEX2).getSerializer().peekData())); // offer owner account root - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _)) .WillByDefault(Return(createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); // issuer account root - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _)) .WillByDefault(Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMAX_SEQ, _)).WillByDefault(Return(feeBlob)); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kMAX_SEQ, _)).WillByDefault(Return(feeBlob)); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -863,10 +860,10 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); @@ -938,16 +935,17 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("bids").as_array().size(), 10); EXPECT_EQ(output.result->as_object().at("asks").as_array().size(), 10); - EXPECT_EQ(output.result->as_object().at("bids").as_array()[0].as_object(), json::parse(kEXPECTED_OFFER)); + EXPECT_EQ(output.result->as_object().at("bids").as_array()[0].as_object(), boost::json::parse(kEXPECTED_OFFER)); EXPECT_EQ( - output.result->as_object().at("asks").as_array()[0].as_object(), json::parse(kEXPECTED_REVERSED_OFFER) + output.result->as_object().at("asks").as_array()[0].as_object(), + boost::json::parse(kEXPECTED_REVERSED_OFFER) ); }); } TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "books": [ @@ -971,56 +969,54 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) auto const issuer = getAccountIdWithString(kACCOUNT); auto const getsXRPPaysUSDBook = getBookBase( - rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount(), std::nullopt) - .value() + rpc::parseBook(xrpl::toCurrency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt).value() ); auto const reversedBook = getBookBase( - rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), issuer, std::nullopt) - .value() + rpc::parseBook(xrpl::xrpCurrency(), xrpl::xrpAccount(), xrpl::toCurrency("USD"), issuer, std::nullopt).value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) .WillByDefault(Return(std::nullopt)); ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(2); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) + auto const indexes = std::vector(10, xrpl::uint256{kINDEX2}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _)) .WillByDefault(Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData())); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kINDEX1}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _)) + auto const indexes2 = std::vector(10, xrpl::uint256{kINDEX1}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _)) .WillByDefault(Return(createOwnerDirLedgerObject(indexes2, kINDEX2).getSerializer().peekData())); // offer owner account root - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _)) .WillByDefault(Return(createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); // issuer account root - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _)) .WillByDefault(Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData())); // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMAX_SEQ, _)).WillByDefault(Return(feeBlob)); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kMAX_SEQ, _)).WillByDefault(Return(feeBlob)); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -1031,10 +1027,10 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::toCurrency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); @@ -1081,13 +1077,15 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) auto const output = handler.process(input, Context{yield, session_}); ASSERT_TRUE(output); EXPECT_EQ(output.result->as_object().at("offers").as_array().size(), 10); - EXPECT_EQ(output.result->as_object().at("offers").as_array()[0].as_object(), json::parse(kEXPECTED_OFFER)); + EXPECT_EQ( + output.result->as_object().at("offers").as_array()[0].as_object(), boost::json::parse(kEXPECTED_OFFER) + ); }); } TEST_F(RPCSubscribeHandlerTest, APIVersion) { - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "streams": ["transactions_proposed"] })JSON" diff --git a/tests/unit/rpc/handlers/TestHandlerTests.cpp b/tests/unit/rpc/handlers/TestHandlerTests.cpp index faf929791..e32dd413e 100644 --- a/tests/unit/rpc/handlers/TestHandlerTests.cpp +++ b/tests/unit/rpc/handlers/TestHandlerTests.cpp @@ -31,8 +31,6 @@ using namespace rpc; using namespace rpc::validation; using namespace tests::common; -namespace json = boost::json; - class RPCTestHandlerTest : public HandlerBaseTest {}; // example handler tests @@ -40,7 +38,7 @@ TEST_F(RPCTestHandlerTest, HandlerSuccess) { runSpawn([](auto yield) { auto const handler = AnyHandler{HandlerFake{}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "hello": "world", "limit": 10 })JSON"); @@ -57,7 +55,7 @@ TEST_F(RPCTestHandlerTest, NoInputHandlerSuccess) { runSpawn([](auto yield) { auto const handler = AnyHandler{NoInputHandlerFake{}}; - auto const output = handler.process(json::parse(R"JSON({})JSON"), Context{yield}); + auto const output = handler.process(boost::json::parse(R"JSON({})JSON"), Context{yield}); ASSERT_TRUE(output); auto const val = output.result.value(); @@ -69,7 +67,7 @@ TEST_F(RPCTestHandlerTest, HandlerErrorHandling) { runSpawn([](auto yield) { auto const handler = AnyHandler{HandlerFake{}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "hello": "not world", "limit": 10 })JSON"); @@ -79,7 +77,7 @@ TEST_F(RPCTestHandlerTest, HandlerErrorHandling) auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "invalidParams"); - EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::rpcINVALID_PARAMS); + EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::RpcInvalidParams); EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters."); }); } @@ -88,7 +86,7 @@ TEST_F(RPCTestHandlerTest, HandlerInnerErrorHandling) { runSpawn([](auto yield) { auto const handler = AnyHandler{FailingHandlerFake{}}; - auto const input = json::parse(R"JSON({ + auto const input = boost::json::parse(R"JSON({ "hello": "world", "limit": 10 })JSON"); diff --git a/tests/unit/rpc/handlers/TransactionEntryTests.cpp b/tests/unit/rpc/handlers/TransactionEntryTests.cpp index d3eed0aae..66b089540 100644 --- a/tests/unit/rpc/handlers/TransactionEntryTests.cpp +++ b/tests/unit/rpc/handlers/TransactionEntryTests.cpp @@ -36,7 +36,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -60,7 +59,7 @@ TEST_F(RPCTransactionEntryHandlerTest, TxHashNotProvide) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TransactionEntryHandler{backend_}}; - auto const output = handler.process(json::parse("{}"), Context{yield}); + auto const output = handler.process(boost::json::parse("{}"), Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "fieldNotFoundTransaction"); @@ -72,7 +71,7 @@ TEST_F(RPCTransactionEntryHandlerTest, TxHashWrongFormat) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TransactionEntryHandler{backend_}}; - auto const output = handler.process(json::parse(R"JSON({"tx_hash": "123"})JSON"), Context{yield}); + auto const output = handler.process(boost::json::parse(R"JSON({"tx_hash": "123"})JSON"), Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "invalidParams"); @@ -83,11 +82,11 @@ TEST_F(RPCTransactionEntryHandlerTest, TxHashWrongFormat) TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kINDEX}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kINDEX}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -111,9 +110,9 @@ TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerHash) TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerIndex) { // mock fetchLedgerBySequence return empty - ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": "4", @@ -136,12 +135,12 @@ TEST_F(RPCTransactionEntryHandlerTest, TXNotFound) { ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kINDEX, 30))); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchTransaction).Times(1); runSpawn([this](auto yield) { auto const handler = AnyHandler{TransactionEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "tx_hash": "{}" @@ -165,7 +164,7 @@ TEST_F(RPCTransactionEntryHandlerTest, LedgerSeqNotMatch) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 10; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kINDEX, 30))); @@ -173,7 +172,7 @@ TEST_F(RPCTransactionEntryHandlerTest, LedgerSeqNotMatch) runSpawn([this](auto yield) { auto const handler = AnyHandler{TransactionEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "tx_hash": "{}", @@ -237,7 +236,7 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPath) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 30; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kINDEX, tx.ledgerSequence))); @@ -245,7 +244,7 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPath) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{TransactionEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "tx_hash": "{}", @@ -257,7 +256,7 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPath) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kOUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kOUTPUT), *output.result); }); } @@ -309,12 +308,12 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 30; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(createLedgerHeader(kINDEX, tx.ledgerSequence))); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{TransactionEntryHandler{backend_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "tx_hash": "{}", @@ -326,6 +325,6 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kOUTPUT), *output.result); + EXPECT_EQ(boost::json::parse(kOUTPUT), *output.result); }); } diff --git a/tests/unit/rpc/handlers/TxTests.cpp b/tests/unit/rpc/handlers/TxTests.cpp index adb6e1c70..219e3d2a5 100644 --- a/tests/unit/rpc/handlers/TxTests.cpp +++ b/tests/unit/rpc/handlers/TxTests.cpp @@ -41,7 +41,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using TestTxHandler = TxHandler; @@ -150,7 +149,7 @@ TEST_F(RPCTxTest, ExcessiveLgrRange) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -178,7 +177,7 @@ TEST_F(RPCTxTest, InvalidBinaryV1) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -186,7 +185,7 @@ TEST_F(RPCTxTest, InvalidBinaryV1) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -205,7 +204,7 @@ TEST_F(RPCTxTest, InvalidBinaryV2) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -228,7 +227,7 @@ TEST_F(RPCTxTest, InvalidLgrRange) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -250,7 +249,7 @@ TEST_F(RPCTxTest, InvalidLgrRange) TEST_F(RPCTxTest, TxnNotFound) { - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -259,7 +258,7 @@ TEST_F(RPCTxTest, TxnNotFound) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -280,7 +279,7 @@ TEST_F(RPCTxTest, TxnNotFound) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) { backend_->setRange(10, 30); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -289,7 +288,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -313,7 +312,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue) { backend_->setRange(1, 1000); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -322,7 +321,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -356,7 +355,7 @@ TEST_F(RPCTxTest, CtidNotFoundSearchAllFalse) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "ctid": "{}", @@ -385,7 +384,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -393,7 +392,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -405,7 +404,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1) auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kDEFAULT_OUT1)); + EXPECT_EQ(*output.result, boost::json::parse(kDEFAULT_OUT1)); }); } @@ -417,7 +416,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v1) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -425,7 +424,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v1) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -449,7 +448,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v2) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)).WillOnce(Return(std::nullopt)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -458,7 +457,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v2) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -484,7 +483,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, tx.ledgerSequence); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)).WillOnce(Return(ledgerHeader)); @@ -494,7 +493,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -505,7 +504,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2) ); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kDEFAULT_OUT2)); + EXPECT_EQ(*output.result, boost::json::parse(kDEFAULT_OUT2)); }); } @@ -529,7 +528,7 @@ TEST_F(RPCTxTest, ReturnBinary) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -537,7 +536,7 @@ TEST_F(RPCTxTest, ReturnBinary) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -549,7 +548,7 @@ TEST_F(RPCTxTest, ReturnBinary) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -574,7 +573,7 @@ TEST_F(RPCTxTest, ReturnBinaryWithCTID) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -582,7 +581,7 @@ TEST_F(RPCTxTest, ReturnBinaryWithCTID) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -594,7 +593,7 @@ TEST_F(RPCTxTest, ReturnBinaryWithCTID) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -661,7 +660,7 @@ TEST_F(RPCTxTest, MintNFT) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -669,7 +668,7 @@ TEST_F(RPCTxTest, MintNFT) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -680,7 +679,7 @@ TEST_F(RPCTxTest, MintNFT) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -690,7 +689,7 @@ TEST_F(RPCTxTest, NFTAcceptOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -698,7 +697,7 @@ TEST_F(RPCTxTest, NFTAcceptOffer) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -720,7 +719,7 @@ TEST_F(RPCTxTest, NFTCancelOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -728,7 +727,7 @@ TEST_F(RPCTxTest, NFTCancelOffer) runSpawn([this, &ids](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -757,7 +756,7 @@ TEST_F(RPCTxTest, NFTCreateOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -765,7 +764,7 @@ TEST_F(RPCTxTest, NFTCreateOffer) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -784,7 +783,7 @@ TEST_F(RPCTxTest, CTIDAndTransactionBothProvided) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -808,7 +807,7 @@ TEST_F(RPCTxTest, CTIDAndTransactionBothNotProvided) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse(R"JSON({ "command": "tx"})JSON"); + auto const req = boost::json::parse(R"JSON({ "command": "tx"})JSON"); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -822,7 +821,7 @@ TEST_F(RPCTxTest, CTIDInvalidType) { runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse(R"JSON({ "command": "tx", "ctid": 123})JSON"); + auto const req = boost::json::parse(R"JSON({ "command": "tx", "ctid": 123})JSON"); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -840,7 +839,7 @@ TEST_F(RPCTxTest, CTIDInvalidString) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse(R"JSON({ "command": "tx", "ctid": "B002807000010002"})JSON"); + auto const req = boost::json::parse(R"JSON({ "command": "tx", "ctid": "B002807000010002"})JSON"); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); @@ -858,7 +857,7 @@ TEST_F(RPCTxTest, CTIDNotMatch) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -872,7 +871,7 @@ TEST_F(RPCTxTest, CTIDNotMatch) auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "wrongNetwork"); - EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::rpcWRONG_NETWORK); + EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::RpcWrongNetwork); EXPECT_EQ( err.at("error_message").as_string(), "Wrong network. You should submit this request to a node running on NetworkID: 2" @@ -927,7 +926,7 @@ TEST_F(RPCTxTest, ReturnCTIDForTxInput) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -935,7 +934,7 @@ TEST_F(RPCTxTest, ReturnCTIDForTxInput) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -946,7 +945,7 @@ TEST_F(RPCTxTest, ReturnCTIDForTxInput) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -996,7 +995,7 @@ TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) createCreateOfferTransactionObject(kACCOUNT, 2, 100, kCURRENCY, kACCOUNT2, 200, 300).getSerializer().peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -1004,7 +1003,7 @@ TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -1015,7 +1014,7 @@ TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -1085,7 +1084,7 @@ TEST_F(RPCTxTest, ViaCTID) runSpawn([this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", @@ -1096,7 +1095,7 @@ TEST_F(RPCTxTest, ViaCTID) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kOUT)); + EXPECT_EQ(*output.result, boost::json::parse(kOUT)); }); } @@ -1125,7 +1124,7 @@ TEST_F(RPCTxTest, ViaLowercaseCTID) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}}; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "command": "tx", diff --git a/tests/unit/rpc/handlers/UnsubscribeTests.cpp b/tests/unit/rpc/handlers/UnsubscribeTests.cpp index b0c8e16ab..360ca84a3 100644 --- a/tests/unit/rpc/handlers/UnsubscribeTests.cpp +++ b/tests/unit/rpc/handlers/UnsubscribeTests.cpp @@ -42,7 +42,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using namespace feed; @@ -509,7 +508,7 @@ TEST_P(UnsubscribeParameterTest, InvalidParams) auto const testBundle = GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{UnsubscribeHandler{mockSubscriptionManagerPtr_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{yield}); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -522,7 +521,7 @@ TEST_F(RPCUnsubscribeTest, EmptyResponse) { runSpawn([&, this](auto yield) { auto const handler = AnyHandler{UnsubscribeHandler{mockSubscriptionManagerPtr_}}; - auto const output = handler.process(json::parse(R"JSON({})JSON"), Context{yield, session_}); + auto const output = handler.process(boost::json::parse(R"JSON({})JSON"), Context{yield, session_}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().empty()); }); @@ -530,7 +529,7 @@ TEST_F(RPCUnsubscribeTest, EmptyResponse) TEST_F(RPCUnsubscribeTest, Streams) { - auto const input = json::parse( + auto const input = boost::json::parse( R"JSON({ "streams": ["transactions_proposed", "transactions", "validations", "manifests", "book_changes", "ledger"] })JSON" @@ -553,7 +552,7 @@ TEST_F(RPCUnsubscribeTest, Streams) TEST_F(RPCUnsubscribeTest, Accounts) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "accounts": ["{}", "{}"] @@ -577,7 +576,7 @@ TEST_F(RPCUnsubscribeTest, Accounts) TEST_F(RPCUnsubscribeTest, AccountsProposed) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "accounts_proposed": ["{}", "{}"] @@ -602,7 +601,7 @@ TEST_F(RPCUnsubscribeTest, AccountsProposed) TEST_F(RPCUnsubscribeTest, Books) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "books": [ @@ -626,7 +625,7 @@ TEST_F(RPCUnsubscribeTest, Books) auto const book = parsedBookMaybe.value(); EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(book, _)).Times(1); - EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(ripple::reversed(book), _)).Times(1); + EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(xrpl::reversed(book), _)).Times(1); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{UnsubscribeHandler{mockSubscriptionManagerPtr_}}; @@ -638,7 +637,7 @@ TEST_F(RPCUnsubscribeTest, Books) TEST_F(RPCUnsubscribeTest, SingleBooks) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "books": [ diff --git a/tests/unit/rpc/handlers/VaultInfoTests.cpp b/tests/unit/rpc/handlers/VaultInfoTests.cpp index a7aa80f33..ae3705424 100644 --- a/tests/unit/rpc/handlers/VaultInfoTests.cpp +++ b/tests/unit/rpc/handlers/VaultInfoTests.cpp @@ -43,7 +43,6 @@ using namespace rpc; using namespace data; using namespace testing; -namespace json = boost::json; namespace { @@ -175,7 +174,7 @@ TEST_P(VaultInfoParameterTest, InvalidParams) auto const testBundle = VaultInfoParameterTest::GetParam(); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{VaultInfoHandler{backend_}}; - auto const req = json::parse(testBundle.testJson); + auto const req = boost::json::parse(testBundle.testJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2}); ASSERT_FALSE(output); @@ -217,7 +216,7 @@ TEST_F(RPCVaultInfoHandlerTest, VaultIDFailsVaultDeserializationReturnsEntryNotF EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Mock: vault_id exists, but data is not a valid vault object - ripple::uint256 const vaultKey = ripple::uint256{kVAULT_ID}; + xrpl::uint256 const vaultKey = xrpl::uint256{kVAULT_ID}; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKey, kSEQ, _)) .WillOnce(Return(std::nullopt)); // intentionally invalid vault @@ -245,8 +244,8 @@ TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) auto const ledgerHeader = createLedgerHeader(kINDEX1, kSEQ); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - ripple::uint192 const mptSharesID{123}; - ripple::uint256 const prevTxId{2}; + xrpl::uint192 const mptSharesID{123}; + xrpl::uint256 const prevTxId{2}; uint32_t const prevTxSeq = 3; uint64_t const ownerNode = 4; @@ -254,8 +253,8 @@ TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) kACCOUNT, kACCOUNT2, kSEQ, kASSET_CURRENCY, kASSET_ISSUER, mptSharesID, ownerNode, prevTxId, prevTxSeq ); - auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVAULT_ID}).key; - auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; + auto const vaultKeylet = xrpl::keylet::vault(xrpl::uint256{kVAULT_ID}).key; + auto const mptIssuance = xrpl::keylet::mptIssuance(mptSharesID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSEQ, _)) .WillOnce(Return(vault.getSerializer().peekData())); @@ -295,7 +294,6 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) "AssetsTotal": "300", "Flags": 0, "LedgerEntryType": "Vault", - "LossUnrealized": "1", "Owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "OwnerNode": "4", "PreviousTxnID": "0000000000000000000000000000000000000000000000000000000000000002", @@ -324,8 +322,8 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Vault params - ripple::uint192 const mptSharesID{123}; - ripple::uint256 const prevTxId{2}; + xrpl::uint192 const mptSharesID{123}; + xrpl::uint256 const prevTxId{2}; uint32_t const prevTxSeq = 3; uint64_t const ownerNode = 4; @@ -336,8 +334,8 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) // Set up keylet based on vaultID auto const issuance = createMptIssuanceObject(kACCOUNT, kSEQ, "metadata"); - auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVAULT_ID}).key; - auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; + auto const vaultKeylet = xrpl::keylet::vault(xrpl::uint256{kVAULT_ID}).key; + auto const mptIssuance = xrpl::keylet::mptIssuance(mptSharesID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSEQ, _)) .WillOnce(Return(vault.getSerializer().peekData())); @@ -359,7 +357,7 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } @@ -378,7 +376,6 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) "AssetsTotal": "300", "Flags": 0, "LedgerEntryType": "Vault", - "LossUnrealized": "1", "Owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "OwnerNode": "4", "PreviousTxnID": "0000000000000000000000000000000000000000000000000000000000000002", @@ -407,8 +404,8 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Vault params - ripple::uint192 const mptSharesID{123}; - ripple::uint256 const prevTxId{2}; + xrpl::uint192 const mptSharesID{123}; + xrpl::uint256 const prevTxId{2}; uint32_t const prevTxSeq = 3; uint64_t const ownerNode = 4; @@ -421,9 +418,9 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) auto const accountRoot = createAccountRootObject(kACCOUNT, 0, kSEQ, 200, 2, kINDEX1, 2); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKeylet = ripple::keylet::account(account).key; - auto const vaultKeylet = ripple::keylet::vault(account, kSEQ).key; - auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; + auto const accountKeylet = xrpl::keylet::account(account).key; + auto const vaultKeylet = xrpl::keylet::vault(account, kSEQ).key; + auto const mptIssuance = xrpl::keylet::mptIssuance(mptSharesID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKeylet, kSEQ, _)) .WillOnce(Return(accountRoot.getSerializer().peekData())); @@ -450,6 +447,6 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) runSpawn([&](auto yield) { auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kEXPECTED_OUTPUT)); + EXPECT_EQ(*output.result, boost::json::parse(kEXPECTED_OUTPUT)); }); } diff --git a/tests/unit/util/AccountUtilsTests.cpp b/tests/unit/util/AccountUtilsTests.cpp index b2ea54d7b..c51b21ffc 100644 --- a/tests/unit/util/AccountUtilsTests.cpp +++ b/tests/unit/util/AccountUtilsTests.cpp @@ -30,17 +30,17 @@ constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; TEST(AccountUtils, parseBase58Wrapper) { - EXPECT_FALSE(util::parseBase58Wrapper("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp!")); - EXPECT_TRUE(util::parseBase58Wrapper(kACCOUNT)); + EXPECT_FALSE(util::parseBase58Wrapper("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp!")); + EXPECT_TRUE(util::parseBase58Wrapper(kACCOUNT)); EXPECT_TRUE( - util::parseBase58Wrapper( - ripple::TokenType::NodePrivate, "paQmjZ37pKKPMrgadBLsuf9ab7Y7EUNzh27LQrZqoexpAs31nJi" + util::parseBase58Wrapper( + xrpl::TokenType::NodePrivate, "paQmjZ37pKKPMrgadBLsuf9ab7Y7EUNzh27LQrZqoexpAs31nJi" ) ); EXPECT_FALSE( - util::parseBase58Wrapper( - ripple::TokenType::NodePrivate, "??paQmjZ37pKKPMrgadBLsuf9ab7Y7EUNzh27LQrZqoexpAs31n" + util::parseBase58Wrapper( + xrpl::TokenType::NodePrivate, "??paQmjZ37pKKPMrgadBLsuf9ab7Y7EUNzh27LQrZqoexpAs31n" ) ); } diff --git a/tests/unit/util/ChannelTests.cpp b/tests/unit/util/ChannelTests.cpp index 13809c453..fd5c44a5a 100644 --- a/tests/unit/util/ChannelTests.cpp +++ b/tests/unit/util/ChannelTests.cpp @@ -164,12 +164,15 @@ TEST_P(ChannelSpawnTest, MultipleSendersOneReceiver) { auto localSender = std::move(sender); for (auto senderId = 0uz; senderId < kNUM_SENDERS; ++senderId) { - util::spawn(executor, [senderCopy = localSender, senderId](boost::asio::yield_context yield) mutable { - for (auto i = 0uz; i < kVALUES_PER_SENDER; ++i) { - if (not senderCopy.asyncSend(generateValue(senderId, i), yield)) - break; + auto senderCopy = localSender; // gcc-15 is not happy if it is done in lambda capture list + util::spawn( + executor, [senderCopy = std::move(senderCopy), senderId](boost::asio::yield_context yield) mutable { + for (auto i = 0uz; i < kVALUES_PER_SENDER; ++i) { + if (not senderCopy.asyncSend(generateValue(senderId, i), yield)) + break; + } } - }); + ); } } diff --git a/tests/unit/util/LedgerUtilsTests.cpp b/tests/unit/util/LedgerUtilsTests.cpp index b563ae1cd..c10dd9dab 100644 --- a/tests/unit/util/LedgerUtilsTests.cpp +++ b/tests/unit/util/LedgerUtilsTests.cpp @@ -72,16 +72,16 @@ TEST(LedgerUtilsTests, LedgerObjectTypeList) TEST(LedgerUtilsTests, StrToType) { - EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("mess"), ripple::ltANY); - EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("tomato"), ripple::ltANY); - EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("account"), ripple::ltACCOUNT_ROOT); - EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("AccoUnt"), ripple::ltANY); - EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("AccountRoot"), ripple::ltACCOUNT_ROOT); - EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("ACCOUNTRoot"), ripple::ltACCOUNT_ROOT); + EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("mess"), xrpl::ltANY); + EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("tomato"), xrpl::ltANY); + EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("account"), xrpl::ltACCOUNT_ROOT); + EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("AccoUnt"), xrpl::ltANY); + EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("AccountRoot"), xrpl::ltACCOUNT_ROOT); + EXPECT_EQ(util::LedgerTypes::getLedgerEntryTypeFromStr("ACCOUNTRoot"), xrpl::ltACCOUNT_ROOT); constexpr auto kTYPES = util::LedgerTypes::getLedgerEntryTypeStrList(); std::ranges::for_each(kTYPES, [](auto const& typeStr) { - EXPECT_NE(util::LedgerTypes::getLedgerEntryTypeFromStr(typeStr), ripple::ltANY); + EXPECT_NE(util::LedgerTypes::getLedgerEntryTypeFromStr(typeStr), xrpl::ltANY); }); } @@ -89,18 +89,18 @@ TEST(LedgerUtilsTests, DeletionBlockerTypes) { constexpr auto kTESTED_TYPES = util::LedgerTypes::getDeletionBlockerLedgerTypes(); - static constexpr ripple::LedgerEntryType kDELETION_BLOCKERS[] = { - ripple::ltCHECK, - ripple::ltESCROW, - ripple::ltNFTOKEN_PAGE, - ripple::ltPAYCHAN, - ripple::ltRIPPLE_STATE, - ripple::ltXCHAIN_OWNED_CLAIM_ID, - ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID, - ripple::ltBRIDGE, - ripple::ltMPTOKEN_ISSUANCE, - ripple::ltMPTOKEN, - ripple::ltPERMISSIONED_DOMAIN + static constexpr xrpl::LedgerEntryType kDELETION_BLOCKERS[] = { + xrpl::ltCHECK, + xrpl::ltESCROW, + xrpl::ltNFTOKEN_PAGE, + xrpl::ltPAYCHAN, + xrpl::ltRIPPLE_STATE, + xrpl::ltXCHAIN_OWNED_CLAIM_ID, + xrpl::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID, + xrpl::ltBRIDGE, + xrpl::ltMPTOKEN_ISSUANCE, + xrpl::ltMPTOKEN, + xrpl::ltPERMISSIONED_DOMAIN }; static_assert(std::size(kDELETION_BLOCKERS) == kTESTED_TYPES.size()); @@ -112,90 +112,90 @@ TEST(LedgerUtilsTests, DeletionBlockerTypes) struct LedgerEntryTypeParam { std::string input; - ripple::LedgerEntryType expected; + xrpl::LedgerEntryType expected; }; static LedgerEntryTypeParam const kCHAIN_TEST_CASES[] = { // Using RPC name with exact match - {.input = "amendments", .expected = ripple::ltAMENDMENTS}, - {.input = "directory", .expected = ripple::ltDIR_NODE}, - {.input = "fee", .expected = ripple::ltFEE_SETTINGS}, - {.input = "hashes", .expected = ripple::ltLEDGER_HASHES}, - {.input = "nunl", .expected = ripple::ltNEGATIVE_UNL}, + {.input = "amendments", .expected = xrpl::ltAMENDMENTS}, + {.input = "directory", .expected = xrpl::ltDIR_NODE}, + {.input = "fee", .expected = xrpl::ltFEE_SETTINGS}, + {.input = "hashes", .expected = xrpl::ltLEDGER_HASHES}, + {.input = "nunl", .expected = xrpl::ltNEGATIVE_UNL}, // Using canonical name with exact match - {.input = "Amendments", .expected = ripple::ltAMENDMENTS}, - {.input = "DirectoryNode", .expected = ripple::ltDIR_NODE}, - {.input = "FeeSettings", .expected = ripple::ltFEE_SETTINGS}, - {.input = "LedgerHashes", .expected = ripple::ltLEDGER_HASHES}, - {.input = "NegativeUNL", .expected = ripple::ltNEGATIVE_UNL} + {.input = "Amendments", .expected = xrpl::ltAMENDMENTS}, + {.input = "DirectoryNode", .expected = xrpl::ltDIR_NODE}, + {.input = "FeeSettings", .expected = xrpl::ltFEE_SETTINGS}, + {.input = "LedgerHashes", .expected = xrpl::ltLEDGER_HASHES}, + {.input = "NegativeUNL", .expected = xrpl::ltNEGATIVE_UNL} }; static LedgerEntryTypeParam const kACCOUNT_OWNED_TEST_CASES[] = { // Using RPC name with exact match - {.input = "account", .expected = ripple::ltACCOUNT_ROOT}, - {.input = "check", .expected = ripple::ltCHECK}, - {.input = "deposit_preauth", .expected = ripple::ltDEPOSIT_PREAUTH}, - {.input = "escrow", .expected = ripple::ltESCROW}, - {.input = "offer", .expected = ripple::ltOFFER}, - {.input = "payment_channel", .expected = ripple::ltPAYCHAN}, - {.input = "signer_list", .expected = ripple::ltSIGNER_LIST}, - {.input = "state", .expected = ripple::ltRIPPLE_STATE}, - {.input = "ticket", .expected = ripple::ltTICKET}, - {.input = "nft_offer", .expected = ripple::ltNFTOKEN_OFFER}, - {.input = "nft_page", .expected = ripple::ltNFTOKEN_PAGE}, - {.input = "amm", .expected = ripple::ltAMM}, - {.input = "bridge", .expected = ripple::ltBRIDGE}, - {.input = "xchain_owned_claim_id", .expected = ripple::ltXCHAIN_OWNED_CLAIM_ID}, - {.input = "xchain_owned_create_account_claim_id", .expected = ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, - {.input = "did", .expected = ripple::ltDID}, - {.input = "oracle", .expected = ripple::ltORACLE}, - {.input = "credential", .expected = ripple::ltCREDENTIAL}, - {.input = "mpt_issuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, - {.input = "mptoken", .expected = ripple::ltMPTOKEN}, - {.input = "permissioned_domain", .expected = ripple::ltPERMISSIONED_DOMAIN}, - {.input = "vault", .expected = ripple::ltVAULT}, - {.input = "delegate", .expected = ripple::ltDELEGATE}, + {.input = "account", .expected = xrpl::ltACCOUNT_ROOT}, + {.input = "check", .expected = xrpl::ltCHECK}, + {.input = "deposit_preauth", .expected = xrpl::ltDEPOSIT_PREAUTH}, + {.input = "escrow", .expected = xrpl::ltESCROW}, + {.input = "offer", .expected = xrpl::ltOFFER}, + {.input = "payment_channel", .expected = xrpl::ltPAYCHAN}, + {.input = "signer_list", .expected = xrpl::ltSIGNER_LIST}, + {.input = "state", .expected = xrpl::ltRIPPLE_STATE}, + {.input = "ticket", .expected = xrpl::ltTICKET}, + {.input = "nft_offer", .expected = xrpl::ltNFTOKEN_OFFER}, + {.input = "nft_page", .expected = xrpl::ltNFTOKEN_PAGE}, + {.input = "amm", .expected = xrpl::ltAMM}, + {.input = "bridge", .expected = xrpl::ltBRIDGE}, + {.input = "xchain_owned_claim_id", .expected = xrpl::ltXCHAIN_OWNED_CLAIM_ID}, + {.input = "xchain_owned_create_account_claim_id", .expected = xrpl::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, + {.input = "did", .expected = xrpl::ltDID}, + {.input = "oracle", .expected = xrpl::ltORACLE}, + {.input = "credential", .expected = xrpl::ltCREDENTIAL}, + {.input = "mpt_issuance", .expected = xrpl::ltMPTOKEN_ISSUANCE}, + {.input = "mptoken", .expected = xrpl::ltMPTOKEN}, + {.input = "permissioned_domain", .expected = xrpl::ltPERMISSIONED_DOMAIN}, + {.input = "vault", .expected = xrpl::ltVAULT}, + {.input = "delegate", .expected = xrpl::ltDELEGATE}, // Using canonical name with exact match - {.input = "AccountRoot", .expected = ripple::ltACCOUNT_ROOT}, - {.input = "Check", .expected = ripple::ltCHECK}, - {.input = "DepositPreauth", .expected = ripple::ltDEPOSIT_PREAUTH}, - {.input = "Escrow", .expected = ripple::ltESCROW}, - {.input = "Offer", .expected = ripple::ltOFFER}, - {.input = "PayChannel", .expected = ripple::ltPAYCHAN}, - {.input = "SignerList", .expected = ripple::ltSIGNER_LIST}, - {.input = "RippleState", .expected = ripple::ltRIPPLE_STATE}, - {.input = "Ticket", .expected = ripple::ltTICKET}, - {.input = "NFTokenOffer", .expected = ripple::ltNFTOKEN_OFFER}, - {.input = "NFTokenPage", .expected = ripple::ltNFTOKEN_PAGE}, - {.input = "AMM", .expected = ripple::ltAMM}, - {.input = "Bridge", .expected = ripple::ltBRIDGE}, - {.input = "XChainOwnedClaimID", .expected = ripple::ltXCHAIN_OWNED_CLAIM_ID}, - {.input = "XChainOwnedCreateAccountClaimID", .expected = ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, - {.input = "DID", .expected = ripple::ltDID}, - {.input = "Oracle", .expected = ripple::ltORACLE}, - {.input = "Credential", .expected = ripple::ltCREDENTIAL}, - {.input = "MPTokenIssuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, - {.input = "MPToken", .expected = ripple::ltMPTOKEN}, - {.input = "PermissionedDomain", .expected = ripple::ltPERMISSIONED_DOMAIN}, - {.input = "Vault", .expected = ripple::ltVAULT}, - {.input = "Delegate", .expected = ripple::ltDELEGATE} + {.input = "AccountRoot", .expected = xrpl::ltACCOUNT_ROOT}, + {.input = "Check", .expected = xrpl::ltCHECK}, + {.input = "DepositPreauth", .expected = xrpl::ltDEPOSIT_PREAUTH}, + {.input = "Escrow", .expected = xrpl::ltESCROW}, + {.input = "Offer", .expected = xrpl::ltOFFER}, + {.input = "PayChannel", .expected = xrpl::ltPAYCHAN}, + {.input = "SignerList", .expected = xrpl::ltSIGNER_LIST}, + {.input = "RippleState", .expected = xrpl::ltRIPPLE_STATE}, + {.input = "Ticket", .expected = xrpl::ltTICKET}, + {.input = "NFTokenOffer", .expected = xrpl::ltNFTOKEN_OFFER}, + {.input = "NFTokenPage", .expected = xrpl::ltNFTOKEN_PAGE}, + {.input = "AMM", .expected = xrpl::ltAMM}, + {.input = "Bridge", .expected = xrpl::ltBRIDGE}, + {.input = "XChainOwnedClaimID", .expected = xrpl::ltXCHAIN_OWNED_CLAIM_ID}, + {.input = "XChainOwnedCreateAccountClaimID", .expected = xrpl::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}, + {.input = "DID", .expected = xrpl::ltDID}, + {.input = "Oracle", .expected = xrpl::ltORACLE}, + {.input = "Credential", .expected = xrpl::ltCREDENTIAL}, + {.input = "MPTokenIssuance", .expected = xrpl::ltMPTOKEN_ISSUANCE}, + {.input = "MPToken", .expected = xrpl::ltMPTOKEN}, + {.input = "PermissionedDomain", .expected = xrpl::ltPERMISSIONED_DOMAIN}, + {.input = "Vault", .expected = xrpl::ltVAULT}, + {.input = "Delegate", .expected = xrpl::ltDELEGATE} }; static LedgerEntryTypeParam const kCASE_INSENSITIVE_TEST_CASES[] = { // With canonical name in mixedcase - {.input = "mPtOKenIssuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, + {.input = "mPtOKenIssuance", .expected = xrpl::ltMPTOKEN_ISSUANCE}, // With canonical name in lowercase - {.input = "mptokenissuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, + {.input = "mptokenissuance", .expected = xrpl::ltMPTOKEN_ISSUANCE}, }; static LedgerEntryTypeParam const kINVALID_TEST_CASES[] = { - {.input = "", .expected = ripple::ltANY}, - {.input = "1234", .expected = ripple::ltANY}, - {.input = "unknown", .expected = ripple::ltANY}, + {.input = "", .expected = xrpl::ltANY}, + {.input = "1234", .expected = xrpl::ltANY}, + {.input = "unknown", .expected = xrpl::ltANY}, // With RPC name with inexact match - {.input = "MPT_Issuance", .expected = ripple::ltANY} + {.input = "MPT_Issuance", .expected = xrpl::ltANY} }; class LedgerEntryTypeFromStrTest : public ::testing::TestWithParam {}; @@ -237,7 +237,7 @@ INSTANTIATE_TEST_SUITE_P( v.insert(v.end(), std::begin(kACCOUNT_OWNED_TEST_CASES), std::end(kACCOUNT_OWNED_TEST_CASES)); v.insert(v.end(), std::begin(kCASE_INSENSITIVE_TEST_CASES), std::end(kCASE_INSENSITIVE_TEST_CASES)); v.insert(v.end(), std::begin(kINVALID_TEST_CASES), std::end(kINVALID_TEST_CASES)); - v.push_back({"amendments", ripple::ltANY}); // chain type should return ltANY + v.push_back({"amendments", xrpl::ltANY}); // chain type should return ltANY return v; }()) ); diff --git a/tests/unit/util/ShasumTests.cpp b/tests/unit/util/ShasumTests.cpp index a7bf9738c..7a27dfe7d 100644 --- a/tests/unit/util/ShasumTests.cpp +++ b/tests/unit/util/ShasumTests.cpp @@ -35,7 +35,7 @@ struct ShasumTest : testing::Test { TEST_F(ShasumTest, sha256sum) { - ripple::uint256 expected; + xrpl::uint256 expected; ASSERT_TRUE(expected.parseHex(kEMPTY_HASH)); EXPECT_EQ(sha256sum(""), expected); @@ -55,7 +55,7 @@ TEST_F(ShasumTest, Sha256sumStreamingEmpty) Sha256sum hasher; auto result = std::move(hasher).finalize(); - ripple::uint256 expected; + xrpl::uint256 expected; ASSERT_TRUE(expected.parseHex(kEMPTY_HASH)); EXPECT_EQ(result, expected); } @@ -67,7 +67,7 @@ TEST_F(ShasumTest, Sha256sumStreamingSingleUpdate) hasher.update(data.data(), data.size()); auto result = std::move(hasher).finalize(); - ripple::uint256 expected; + xrpl::uint256 expected; ASSERT_TRUE(expected.parseHex(kHELLO_WORLD_HASH)); EXPECT_EQ(result, expected); } @@ -80,7 +80,7 @@ TEST_F(ShasumTest, Sha256sumStreamingMultipleUpdates) hasher.update("world", 5); auto result = std::move(hasher).finalize(); - ripple::uint256 expected; + xrpl::uint256 expected; ASSERT_TRUE(expected.parseHex(kHELLO_WORLD_HASH)); EXPECT_EQ(result, expected); } diff --git a/tests/unit/util/TimeUtilsTests.cpp b/tests/unit/util/TimeUtilsTests.cpp index 3c779bcf1..342c32053 100644 --- a/tests/unit/util/TimeUtilsTests.cpp +++ b/tests/unit/util/TimeUtilsTests.cpp @@ -92,6 +92,6 @@ TEST(TimeUtilTests, SystemTpFromLedgerCloseTime) { using namespace std::chrono; - auto const tp = util::systemTpFromLedgerCloseTime(ripple::NetClock::time_point{seconds{0}}); - EXPECT_EQ(tp.time_since_epoch(), ripple::epoch_offset); + auto const tp = util::systemTpFromLedgerCloseTime(xrpl::NetClock::time_point{seconds{0}}); + EXPECT_EQ(tp.time_since_epoch(), xrpl::kEpochOffset); } diff --git a/tests/unit/util/TxUtilTests.cpp b/tests/unit/util/TxUtilTests.cpp index 9f979e0a3..e4b373a02 100644 --- a/tests/unit/util/TxUtilTests.cpp +++ b/tests/unit/util/TxUtilTests.cpp @@ -31,13 +31,11 @@ TEST(TxUtilTests, txTypesInLowercase) { auto const& types = util::getTxTypesInLowercase(); ASSERT_TRUE( - std::size_t(std::distance(ripple::TxFormats::getInstance().begin(), ripple::TxFormats::getInstance().end())) == + std::size_t(std::distance(xrpl::TxFormats::getInstance().begin(), xrpl::TxFormats::getInstance().end())) == types.size() ); - std::for_each( - ripple::TxFormats::getInstance().begin(), ripple::TxFormats::getInstance().end(), [&](auto const& pair) { - EXPECT_TRUE(types.find(util::toLower(pair.getName())) != types.end()); - } - ); + std::for_each(xrpl::TxFormats::getInstance().begin(), xrpl::TxFormats::getInstance().end(), [&](auto const& pair) { + EXPECT_TRUE(types.find(util::toLower(pair.getName())) != types.end()); + }); } diff --git a/tests/unit/web/AdminVerificationTests.cpp b/tests/unit/web/AdminVerificationTests.cpp index 05c8314f3..c11952c94 100644 --- a/tests/unit/web/AdminVerificationTests.cpp +++ b/tests/unit/web/AdminVerificationTests.cpp @@ -83,7 +83,7 @@ TEST_F(PasswordAdminVerificationStrategyTest, IsAdminReturnsTrueOnlyForValidPass EXPECT_FALSE(strat_.isAdmin(makeRequest("a"), "127.0.0.1")); // Wrong header - EXPECT_FALSE(strat_.isAdmin(makeRequest(passwordHash_, http::field::authentication_info), "")); + EXPECT_FALSE(strat_.isAdmin(makeRequest(passwordHash_, http::field::accept), "")); } struct MakeAdminVerificationStrategyTestParams { diff --git a/tests/unit/web/RPCServerHandlerTests.cpp b/tests/unit/web/RPCServerHandlerTests.cpp index ee233e5fd..368cad974 100644 --- a/tests/unit/web/RPCServerHandlerTests.cpp +++ b/tests/unit/web/RPCServerHandlerTests.cpp @@ -478,7 +478,7 @@ TEST_F(WebRPCServerHandlerTest, HTTPErrorPath) EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) .WillOnce( - testing::Return(rpc::Result{rpc::Status{rpc::RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"}}) + testing::Return(rpc::Result{rpc::Status{rpc::RippledError::RpcInvalidParams, "ledgerIndexMalformed"}}) ); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); @@ -527,7 +527,7 @@ TEST_F(WebRPCServerHandlerTest, WsErrorPath) EXPECT_CALL(*rpcEngine, buildResponse(testing::_)) .WillOnce( - testing::Return(rpc::Result{rpc::Status{rpc::RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"}}) + testing::Return(rpc::Result{rpc::Status{rpc::RippledError::RpcInvalidParams, "ledgerIndexMalformed"}}) ); EXPECT_CALL(*etl, lastCloseAgeSeconds()).WillOnce(testing::Return(45)); diff --git a/tests/unit/web/ServerTests.cpp b/tests/unit/web/ServerTests.cpp index 75a44ec55..fcbe93706 100644 --- a/tests/unit/web/ServerTests.cpp +++ b/tests/unit/web/ServerTests.cpp @@ -642,7 +642,7 @@ INSTANTIATE_TEST_CASE_P( WebServerAdminTestParams{ .config = jsonServerConfigWithAdminPassword(tests::util::generateFreePort()), .headers = {WebHeader( - http::field::authentication_info, + http::field::accept, fmt::format("{}{}", PasswordAdminVerificationStrategy::kPASSWORD_PREFIX, kSECRET_SHA256) )}, .expectedResponse = "user" diff --git a/tests/unit/web/impl/ErrorHandlingTests.cpp b/tests/unit/web/impl/ErrorHandlingTests.cpp index 42bcaf222..069b1841c 100644 --- a/tests/unit/web/impl/ErrorHandlingTests.cpp +++ b/tests/unit/web/impl/ErrorHandlingTests.cpp @@ -64,7 +64,7 @@ TEST_P(ErrorHandlingComposeErrorTest, composeError) { connection_->upgraded = GetParam().connectionUpgraded; ErrorHelper const errorHelper{connection_, GetParam().request}; - auto const result = errorHelper.composeError(rpc::RippledError::rpcNOT_READY); + auto const result = errorHelper.composeError(rpc::RippledError::RpcNotReady); EXPECT_EQ(boost::json::serialize(result), boost::json::serialize(GetParam().expectedResult)); } @@ -150,7 +150,7 @@ INSTANTIATE_TEST_CASE_P( ErrorHandlingSendErrorTestBundle{ "UpgradedConnection", true, - rpc::Status{rpc::RippledError::rpcTOO_BUSY}, + rpc::Status{rpc::RippledError::RpcTooBusy}, R"JSON({"error":"tooBusy","error_code":9,"error_message":"The server is too busy to help you now.","status":"error","type":"response"})JSON", boost::beast::http::status::ok }, @@ -192,7 +192,7 @@ INSTANTIATE_TEST_CASE_P( ErrorHandlingSendErrorTestBundle{ "NotUpgradedConnection_RippledError", false, - rpc::Status{rpc::RippledError::rpcTOO_BUSY}, + rpc::Status{rpc::RippledError::RpcTooBusy}, R"JSON({"result":{"error":"tooBusy","error_code":9,"error_message":"The server is too busy to help you now.","status":"error","type":"response"}})JSON", boost::beast::http::status::bad_request }, diff --git a/tests/unit/web/ng/RPCServerHandlerTests.cpp b/tests/unit/web/ng/RPCServerHandlerTests.cpp index 3e1fbfb3c..8132c0f94 100644 --- a/tests/unit/web/ng/RPCServerHandlerTests.cpp +++ b/tests/unit/web/ng/RPCServerHandlerTests.cpp @@ -108,7 +108,7 @@ TEST_F(NgRpcServerHandlerTest, DosguardRejectedHttpRequest) EXPECT_EQ(responseHttp.result(), http::status::service_unavailable); auto const responseJson = boost::json::parse(responseHttp.body()).as_object(); - EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::rpcSLOW_DOWN); + EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::RpcSlowDown); }); } @@ -124,7 +124,7 @@ TEST_F(NgRpcServerHandlerTest, DosguardRejectedWsRequest) auto const responseWs = boost::beast::buffers_to_string(response.asWsResponse()); auto const responseJson = boost::json::parse(responseWs).as_object(); - EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::rpcSLOW_DOWN); + EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::RpcSlowDown); EXPECT_EQ(responseJson.at("request").as_string(), requestStr); }); } @@ -141,7 +141,7 @@ TEST_F(NgRpcServerHandlerTest, DosguardRejectedWsJsonRequest) auto const responseWs = boost::beast::buffers_to_string(response.asWsResponse()); auto const responseJson = boost::json::parse(responseWs).as_object(); - EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::rpcSLOW_DOWN); + EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::RpcSlowDown); EXPECT_EQ(responseJson.at("request").as_string(), requestStr); EXPECT_EQ(responseJson.at("id").as_string(), "some id"); }); @@ -227,7 +227,7 @@ TEST_F(NgRpcServerHandlerTest, DosguardRejectedParsedRequest) EXPECT_EQ(responseHttp.result(), http::status::service_unavailable); auto const responseJson = boost::json::parse(responseHttp.body()).as_object(); - EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::rpcSLOW_DOWN); + EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::RpcSlowDown); }); } @@ -250,7 +250,7 @@ TEST_F(NgRpcServerHandlerTest, DosguardAddsLoadWarning) EXPECT_EQ(responseHttp.result(), http::status::service_unavailable); auto const responseJson = boost::json::parse(responseHttp.body()).as_object(); - EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::rpcSLOW_DOWN); + EXPECT_EQ(responseJson.at("error_code").as_int64(), rpc::RippledError::RpcSlowDown); EXPECT_EQ(responseJson.at("warning").as_string(), "load"); EXPECT_EQ(responseJson.at("warnings").as_array().at(0).as_object().at("id").as_int64(), rpc::WarnRpcRateLimit); diff --git a/tests/unit/web/ng/impl/ErrorHandlingTests.cpp b/tests/unit/web/ng/impl/ErrorHandlingTests.cpp index 081d29ff0..5f71e191c 100644 --- a/tests/unit/web/ng/impl/ErrorHandlingTests.cpp +++ b/tests/unit/web/ng/impl/ErrorHandlingTests.cpp @@ -90,7 +90,7 @@ INSTANTIATE_TEST_CASE_P( NgErrorHandlingMakeErrorTestBundle{ "WsRequest", false, - rpc::Status{rpc::RippledError::rpcTOO_BUSY}, + rpc::Status{rpc::RippledError::RpcTooBusy}, R"JSON({"error":"tooBusy","error_code":9,"error_message":"The server is too busy to help you now.","status":"error","type":"response"})JSON", boost::beast::http::status::ok }, @@ -132,7 +132,7 @@ INSTANTIATE_TEST_CASE_P( NgErrorHandlingMakeErrorTestBundle{ "HttpRequest_RippledError", true, - rpc::Status{rpc::RippledError::rpcTOO_BUSY}, + rpc::Status{rpc::RippledError::RpcTooBusy}, R"JSON({"result":{"error":"tooBusy","error_code":9,"error_message":"The server is too busy to help you now.","status":"error","type":"response"}})JSON", boost::beast::http::status::bad_request }, @@ -314,7 +314,7 @@ TEST_P(NgErrorHandlingComposeErrorTest, ComposeError) { auto const request = makeRequest(GetParam().isHttp); ErrorHelper const errorHelper{request, GetParam().request}; - auto const response = errorHelper.composeError(rpc::Status{rpc::RippledError::rpcINTERNAL}); + auto const response = errorHelper.composeError(rpc::Status{rpc::RippledError::RpcInternal}); EXPECT_EQ(boost::json::serialize(response), GetParam().expectedMessage); }