diff --git a/cmake/deps/Boost.cmake b/cmake/deps/Boost.cmake index f4dd99e68..80b5c8e07 100644 --- a/cmake/deps/Boost.cmake +++ b/cmake/deps/Boost.cmake @@ -6,5 +6,5 @@ find_package( 1.82 REQUIRED CONFIG - COMPONENTS program_options coroutine system log log_setup + COMPONENTS program_options system log log_setup ) diff --git a/cmake/deps/OpenSSL.cmake b/cmake/deps/OpenSSL.cmake index c1831611f..e58ea406a 100644 --- a/cmake/deps/OpenSSL.cmake +++ b/cmake/deps/OpenSSL.cmake @@ -1,4 +1,4 @@ -find_package(OpenSSL 1.1.1 REQUIRED CONFIG) +find_package(OpenSSL 3 REQUIRED CONFIG) set_target_properties( OpenSSL::SSL diff --git a/conan.lock b/conan.lock index 47cfe3533..319857dc7 100644 --- a/conan.lock +++ b/conan.lock @@ -1,61 +1,76 @@ { "version": "0.5", "requires": [ - "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809", + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1778091116.056", "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987", - "xrpl/3.1.3#eabc6838b4553671bdde4b3aa1f8e3e6%1778495466.414", - "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1765850149.926", + "xrpl/3.2.0#c3c124909c6461012758a4fab7c90cd5%1781569913.756", + "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1778091117.311", "spdlog/1.17.0#bcbaaf7147bda6ad24ffbd1ac3d7142c%1768312128.781", "soci/4.0.3#fe32b9ad5eb47e79ab9e45a68f363945%1774450067.231", - "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1765850148.103", + "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", + "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%1768312129.152", - "grpc/1.50.1#02291451d1e17200293a409410d1c4e1%1756234248.958", + "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.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.5#b885dc73ad67b40a55d45684d1c88ad1%1774363287.434", - "abseil/20230802.1#90ba607d4ee8fb5fb157c3db540671fc%1764175359.429" + "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196" ], "build_requires": [ - "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809", - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88%1764175361.456", + "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" + "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1774439233.447", + "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196" ], "python_requires": [], "overrides": { - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88": [ - null, - "protobuf/3.21.12" + "zlib/[>=1.2.11 <2]": [ + "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb" ], - "boost/1.83.0#91d8b1572534d2c334d6790e3c34d0c1": [ + "zlib/1.3.2": [ null, - "boost/1.83.0#91d8b1572534d2c334d6790e3c34d0c1" + "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" ], "boost/[>=1.83.0 <1.91.0]": [ - "boost/1.83.0" + "boost/1.91.0" ], "sqlite3/[>=3.44 <4]": [ - "sqlite3/3.49.1" + "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 1d716eb96..336653caa 100644 --- a/conanfile.py +++ b/conanfile.py @@ -15,13 +15,9 @@ class ClioConan(ConanFile): requires = [ "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.1.3", - "zlib/1.3.1", + "xrpl/3.2.0", ] default_options = { @@ -36,16 +32,28 @@ 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, } exports_sources = ("CMakeLists.txt", "cmake/*", "src/*") def requirements(self): - self.requires("boost/1.83.0", force=True) self.requires("gtest/1.17.0") self.requires("benchmark/1.9.5") + # 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/src/app/WebHandlers.cpp b/src/app/WebHandlers.cpp index ccc9490d4..dce06c412 100644 --- a/src/app/WebHandlers.cpp +++ b/src/app/WebHandlers.cpp @@ -105,7 +105,7 @@ MetricsHandler::operator()( if (!postSuccessful) { return web::ng::Response{ boost::beast::http::status::too_many_requests, - rpc::makeError(rpc::RippledError::rpcTOO_BUSY), + rpc::makeError(rpc::RippledError::RpcTooBusy), request }; } diff --git a/src/app/WebHandlers.hpp b/src/app/WebHandlers.hpp index 20ee9a018..aba547a69 100644 --- a/src/app/WebHandlers.hpp +++ b/src/app/WebHandlers.hpp @@ -241,7 +241,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 e3f94075c..a71d8d410 100644 --- a/src/data/AmendmentCenter.cpp +++ b/src/data/AmendmentCenter.cpp @@ -40,7 +40,7 @@ supportedAmendments() bool lookupAmendment( auto const& allAmendments, - std::vector const& ledgerAmendments, + std::vector const& ledgerAmendments, std::string_view name ) { @@ -80,7 +80,7 @@ operator std::string_view() const } AmendmentKey:: -operator ripple::uint256() const +operator xrpl::uint256() const { return Amendment::getAmendmentId(name); } @@ -92,14 +92,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::contains(supportedAmendments(), name), - .isRetired = support == ripple::AmendmentSupport::Retired + .isRetired = support == xrpl::AmendmentSupport::Retired }; }), std::back_inserter(all_) @@ -207,26 +207,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 d23665cc5..686bb7897 100644 --- a/src/data/AmendmentCenter.hpp +++ b/src/data/AmendmentCenter.hpp @@ -134,6 +134,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); @@ -158,8 +163,6 @@ struct Amendments { REGISTER(fix1512); REGISTER(fix1523); REGISTER(fix1528); - REGISTER(fixBatchInnerSigs); - REGISTER(fixCleanup3_1_3); // NOLINTEND(readability-identifier-naming) /** @endcond */ }; @@ -263,7 +266,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 fa6839ce2..c721307fa 100644 --- a/src/data/BackendInterface.cpp +++ b/src/data/BackendInterface.cpp @@ -45,7 +45,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)); } @@ -58,14 +58,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; } @@ -80,7 +80,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 @@ -93,14 +93,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) { @@ -126,25 +126,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 @@ -162,7 +162,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 @@ -171,9 +171,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(); }; @@ -195,17 +195,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"); // NOLINTBEGIN(bugprone-unchecked-optional-access) @@ -219,8 +219,8 @@ 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({.key = keys[i], .blob = objs[i]}); @@ -236,7 +236,7 @@ BackendInterface::fetchBookOffers( << ". 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; } @@ -295,7 +295,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, @@ -304,11 +304,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 : kFirstKey); @@ -331,10 +331,10 @@ BackendInterface::fetchLedgerPage( page.objects.push_back({.key = keys[i], .blob = std::move(objects[i])}); } else if (!outOfOrder) { LOG(log_.error()) << "Deleted or non-existent object in successor table. key = " - << ripple::strHex(keys[i]) << " - seq = " << ledgerSequence; + << 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(); @@ -348,12 +348,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) { @@ -361,17 +361,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(); @@ -387,9 +387,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 17cd08574..0038a3b14 100644 --- a/src/data/BackendInterface.hpp +++ b/src/data/BackendInterface.hpp @@ -178,9 +178,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; /** @@ -188,10 +188,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. @@ -218,9 +218,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, @@ -262,7 +262,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; /** @@ -273,7 +273,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. @@ -284,7 +284,7 @@ public: */ virtual std::vector fetchTransactions( - std::vector const& hashes, + std::vector const& hashes, boost::asio::yield_context yield ) const = 0; @@ -300,7 +300,7 @@ public: */ virtual TransactionsAndCursor fetchAccountTransactions( - ripple::AccountID const& account, + xrpl::AccountID const& account, std::uint32_t limit, bool forward, std::optional const& txnCursor, @@ -325,9 +325,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 @@ -343,7 +343,7 @@ public: */ virtual std::optional fetchNFT( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t ledgerSequence, boost::asio::yield_context yield ) const = 0; @@ -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, @@ -381,11 +381,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; @@ -401,9 +401,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; @@ -426,7 +426,7 @@ public: */ virtual TransactionsAndCursor fetchMPTokenIssuanceTransactions( - ripple::uint192 const& mptIssuanceID, + xrpl::uint192 const& mptIssuanceID, std::uint32_t limit, bool forward, std::optional const& cursorIn, @@ -454,8 +454,8 @@ public: */ virtual TransactionsAndCursor fetchAccountMPTokenIssuanceTransactions( - ripple::uint192 const& mptIssuanceID, - ripple::AccountID const& account, + xrpl::uint192 const& mptIssuanceID, + xrpl::AccountID const& account, std::uint32_t limit, bool forward, std::optional const& cursorIn, @@ -475,7 +475,7 @@ public: */ std::optional fetchLedgerObject( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const; @@ -492,7 +492,7 @@ public: */ std::optional fetchLedgerObjectSeq( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const; @@ -511,7 +511,7 @@ public: */ std::vector fetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t sequence, boost::asio::yield_context yield ) const; @@ -526,7 +526,7 @@ public: */ virtual std::optional doFetchLedgerObject( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const = 0; @@ -541,7 +541,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; @@ -556,7 +556,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; @@ -583,7 +583,7 @@ public: */ LedgerPage fetchLedgerPage( - std::optional const& cursor, + std::optional const& cursor, std::uint32_t ledgerSequence, std::uint32_t limit, bool outOfOrder, @@ -600,7 +600,7 @@ public: */ std::optional fetchSuccessorObject( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield ) const; @@ -617,9 +617,9 @@ public: * @param yield The coroutine context * @return The successor key on success; nullopt otherwise */ - std::optional + std::optional fetchSuccessorKey( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield ) const; @@ -632,9 +632,9 @@ public: * @param yield The coroutine context * @return The successor on success; nullopt otherwise */ - virtual std::optional + virtual std::optional doFetchSuccessorKey( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield ) const = 0; @@ -650,7 +650,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 @@ -717,7 +717,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 4c75ea4b0..9e3fc941b 100644 --- a/src/data/CassandraBackend.hpp +++ b/src/data/CassandraBackend.hpp @@ -101,11 +101,11 @@ public: [[nodiscard]] 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 { @@ -115,7 +115,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; } @@ -124,9 +124,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}); @@ -142,8 +141,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()) @@ -177,11 +176,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(); + if (auto const maybeUri = nftUris[i].template get(); maybeUri.has_value()) nft.uri = *maybeUri; ret.nfts.push_back(nft); @@ -190,7 +189,7 @@ public: return ret; } - [[nodiscard]] std::vector + [[nodiscard]] std::vector fetchAccountRoots( std::uint32_t number, std::uint32_t pageSize, @@ -198,8 +197,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 @@ -214,9 +213,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 181e4ea1c..1df2532d7 100644 --- a/src/data/DBHelpers.hpp +++ b/src/data/DBHelpers.hpp @@ -24,10 +24,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 @@ -35,7 +35,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()) @@ -52,10 +52,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 @@ -65,9 +65,9 @@ struct NFTTransactionsData { * @param txHash The transaction hash */ NFTTransactionsData( - ripple::uint256 const& tokenID, - ripple::TxMeta const& meta, - ripple::uint256 const& txHash + xrpl::uint256 const& tokenID, + xrpl::TxMeta const& meta, + xrpl::uint256 const& txHash ) : tokenID(tokenID) , ledgerSequence(meta.getLgrSeq()) @@ -91,11 +91,11 @@ struct NFTTransactionsData { * 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 @@ -113,10 +113,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()) @@ -137,9 +137,9 @@ struct NFTsData { * @param isBurned Whether the NFT is burned */ NFTsData( - ripple::uint256 const& tokenID, - ripple::AccountID const& owner, - ripple::TxMeta const& meta, + xrpl::uint256 const& tokenID, + xrpl::AccountID const& owner, + xrpl::TxMeta const& meta, bool isBurned ) : tokenID(tokenID) @@ -164,10 +164,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) { @@ -181,7 +181,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()) @@ -195,8 +195,8 @@ struct NFTsData { * @brief Represents an MPT and holder pair */ struct MPTHolderData { - ripple::uint192 mptID; - ripple::AccountID holder; + xrpl::uint192 mptID; + xrpl::AccountID holder; }; /** @@ -206,11 +206,11 @@ struct MPTHolderData { * mptoken_issuance_transactions and account_mptoken_issuance_transactions. */ struct MPTokenIssuanceTransactionsData { - ripple::uint192 mptIssuanceID; - boost::container::flat_set accounts; + xrpl::uint192 mptIssuanceID; + boost::container::flat_set accounts; std::uint32_t ledgerSequence{}; std::uint32_t transactionIndex{}; - ripple::uint256 txHash; + xrpl::uint256 txHash; }; /** @@ -246,25 +246,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 kEySize = 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 < kEySize; ++i) ret.data()[i] = key.data()[i]; @@ -272,15 +272,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 07fe364c6..bde01a933 100644 --- a/src/data/KeyspaceBackend.hpp +++ b/src/data/KeyspaceBackend.hpp @@ -104,23 +104,23 @@ public: [[nodiscard]] 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)); + 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); @@ -129,7 +129,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); } @@ -141,7 +141,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); } } @@ -160,9 +160,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. */ - [[nodiscard]] std::vector + [[nodiscard]] std::vector fetchAccountRoots( [[maybe_unused]] std::uint32_t number, [[maybe_unused]] std::uint32_t pageSize, @@ -175,42 +175,42 @@ public: } private: - [[nodiscard]] std::vector + [[nodiscard]] 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; } - [[nodiscard]] std::vector + [[nodiscard]] 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)); + 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); @@ -219,7 +219,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); } @@ -231,7 +231,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); } } @@ -244,7 +244,7 @@ private: */ [[nodiscard]] 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 @@ -283,11 +283,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(); + 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 02678218d..fa40d0ba0 100644 --- a/src/data/LedgerCache.cpp +++ b/src/data/LedgerCache.cpp @@ -112,7 +112,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 {}; @@ -129,7 +129,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 {}; @@ -145,7 +145,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 {}; @@ -164,7 +164,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 0c4cae298..468834c6e 100644 --- a/src/data/LedgerCache.hpp +++ b/src/data/LedgerCache.hpp @@ -35,7 +35,7 @@ public: Blob blob; }; - using CacheMap = std::map; + using CacheMap = std::map; private: // counters for fetchLedgerObject(s) hit rate @@ -95,7 +95,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 @@ -105,16 +105,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 6e9126784..19b7d1acb 100644 --- a/src/data/LedgerCacheInterface.hpp +++ b/src/data/LedgerCacheInterface.hpp @@ -56,7 +56,7 @@ public: * @return If found in cache, will return the cached Blob; otherwise nullopt is returned */ [[nodiscard]] 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. @@ -66,7 +66,7 @@ public: * @return If found in deleted cache, will return the cached Blob; otherwise nullopt is returned */ [[nodiscard]] 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. @@ -78,7 +78,7 @@ public: * @return If found in cache, will return the cached successor; otherwise nullopt is returned */ [[nodiscard]] 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. @@ -90,7 +90,7 @@ public: * @return If found in cache, will return the cached predcessor; otherwise nullopt is returned */ [[nodiscard]] 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 65707a7f7..cb79ad9cd 100644 --- a/src/data/LedgerHeaderCache.hpp +++ b/src/data/LedgerHeaderCache.hpp @@ -11,7 +11,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), @@ -27,7 +27,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 c7ed6d2cd..d01a3c323 100644 --- a/src/data/Types.hpp +++ b/src/data/Types.hpp @@ -20,7 +20,7 @@ using Blob = std::vector; * @brief Represents an object in the ledger. */ struct LedgerObject { - ripple::uint256 key; + xrpl::uint256 key; Blob blob; bool @@ -32,7 +32,7 @@ struct LedgerObject { */ struct LedgerPage { std::vector objects; - std::optional cursor; + std::optional cursor; }; /** @@ -40,7 +40,7 @@ struct LedgerPage { */ struct BookOffersPage { std::vector offers; - std::optional cursor; + std::optional cursor; }; /** @@ -159,9 +159,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{}; @@ -176,9 +176,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} @@ -197,9 +197,9 @@ struct NFT { * @param owner The owner * @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, bool isBurned) : NFT(tokenID, ledgerSequence, owner, {}, isBurned) { @@ -226,7 +226,7 @@ struct NFT { */ struct NFTsAndCursor { std::vector nfts; - std::optional cursor; + std::optional cursor; }; /** @@ -234,7 +234,7 @@ struct NFTsAndCursor { */ struct MPTHoldersAndCursor { std::vector mptokens; - std::optional cursor; + std::optional cursor; }; /** @@ -253,7 +253,7 @@ struct LedgerRange { */ struct Amendment { std::string name; - ripple::uint256 feature; + xrpl::uint256 feature; bool isSupportedByXRPL = false; bool isSupportedByClio = false; bool isRetired = false; @@ -264,7 +264,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); /** @@ -301,7 +301,7 @@ struct AmendmentKey { operator std::string_view() const; /** @brief Conversion to uint256 */ - operator ripple::uint256() const; + operator xrpl::uint256() const; /** * @brief Comparison operators @@ -312,14 +312,12 @@ struct AmendmentKey { operator<=>(AmendmentKey const& other) const = default; }; -constexpr ripple::uint256 kFirstKey{ +constexpr xrpl::uint256 kFirstKey{ "0000000000000000000000000000000000000000000000000000000000000000" }; -constexpr ripple::uint256 kLastKey{ +constexpr xrpl::uint256 kLastKey{ "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" }; -constexpr ripple::uint256 kHi192{ - "0000000000000000000000000000000000000000000000001111111111111111" -}; +constexpr xrpl::uint256 kHi192{"0000000000000000000000000000000000000000000000001111111111111111"}; } // namespace data diff --git a/src/data/cassandra/CassandraBackendFamily.hpp b/src/data/cassandra/CassandraBackendFamily.hpp index c74b067cc..27385514b 100644 --- a/src/data/cassandra/CassandraBackendFamily.hpp +++ b/src/data/cassandra/CassandraBackendFamily.hpp @@ -141,7 +141,7 @@ public: TransactionsAndCursor fetchAccountTransactions( - ripple::AccountID const& account, + xrpl::AccountID const& account, std::uint32_t const limit, bool forward, std::optional const& txnCursor, @@ -162,7 +162,7 @@ public: auto cursor = txnCursor; if (cursor) { statement.bindAt(kTransactionCursorBindIndex, cursor->asTuple()); - LOG(log_.debug()) << "account = " << ripple::strHex(account) + LOG(log_.debug()) << "account = " << xrpl::strHex(account) << " tuple = " << cursor->ledgerSequence << cursor->transactionIndex; } else { auto const seq = forward ? rng->minSequence : rng->maxSequence; @@ -171,7 +171,7 @@ public: statement.bindAt( kTransactionCursorBindIndex, 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; } @@ -186,12 +186,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"; @@ -217,7 +216,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)); @@ -246,7 +245,7 @@ public: return std::nullopt; } - std::optional + std::optional fetchLedgerBySequence( std::uint32_t const sequence, boost::asio::yield_context yield @@ -260,7 +259,7 @@ public: 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 +276,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) { @@ -345,7 +344,7 @@ public: return fetchTransactions(hashes, yield); } - std::vector + std::vector fetchAllTransactionHashesInLedger( std::uint32_t const ledgerSequence, boost::asio::yield_context yield @@ -367,8 +366,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(); @@ -384,7 +383,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 @@ -393,8 +392,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); @@ -411,7 +409,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; } @@ -424,7 +422,7 @@ public: TransactionsAndCursor fetchNFTTransactions( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t const limit, bool const forward, std::optional const& cursorIn, @@ -445,7 +443,7 @@ public: auto cursor = cursorIn; if (cursor) { statement.bindAt(kTransactionCursorBindIndex, cursor->asTuple()); - LOG(log_.debug()) << "token_id = " << ripple::strHex(tokenID) + LOG(log_.debug()) << "token_id = " << xrpl::strHex(tokenID) << " tuple = " << cursor->ledgerSequence << cursor->transactionIndex; } else { auto const seq = forward ? rng->minSequence : rng->maxSequence; @@ -454,7 +452,7 @@ public: statement.bindAt( kTransactionCursorBindIndex, 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; } @@ -467,12 +465,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"; @@ -498,7 +495,7 @@ public: TransactionsAndCursor fetchMPTokenIssuanceTransactions( - ripple::uint192 const& mptIssuanceID, + xrpl::uint192 const& mptIssuanceID, std::uint32_t const limit, bool const forward, std::optional const& cursorIn, @@ -524,8 +521,8 @@ public: TransactionsAndCursor fetchAccountMPTokenIssuanceTransactions( - ripple::uint192 const& mptIssuanceID, - ripple::AccountID const& account, + xrpl::uint192 const& mptIssuanceID, + xrpl::AccountID const& account, std::uint32_t const limit, bool const forward, std::optional const& cursorIn, @@ -551,9 +548,9 @@ 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 @@ -562,7 +559,7 @@ public: yield, schema_->selectMPTHolders, mptID, - cursorIn.value_or(ripple::AccountID(0)), + cursorIn.value_or(xrpl::AccountID(0)), Limit{limit} ); @@ -572,10 +569,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; } @@ -596,13 +593,13 @@ 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); + << ", 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()) @@ -619,13 +616,13 @@ 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); + << ", 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; @@ -640,7 +637,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(); @@ -657,16 +654,16 @@ 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 == kLastKey) return std::nullopt; return result; @@ -682,7 +679,7 @@ public: std::vector fetchTransactions( - std::vector const& hashes, + std::vector const& hashes, boost::asio::yield_context yield ) const override { @@ -728,7 +725,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 @@ -777,7 +774,7 @@ public: ) const override { auto const [keys, timeDiff] = - util::timed([this, &ledgerSequence, yield]() -> std::vector { + 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() @@ -792,8 +789,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; @@ -1031,8 +1028,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(schema_->insertNFTURI.bind( @@ -1181,11 +1178,11 @@ protected: return {}; } - std::vector hashes = {}; + std::vector hashes = {}; auto numRows = results.numRows(); for (auto const& [hash, data] : - extract>(results)) { + extract>(results)) { hashes.push_back(hash); if (--numRows == 0) { diff --git a/src/data/cassandra/impl/Collection.hpp b/src/data/cassandra/impl/Collection.hpp index 20db6bcd7..8847936c4 100644 --- a/src/data/cassandra/impl/Collection.hpp +++ b/src/data/cassandra/impl/Collection.hpp @@ -58,14 +58,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 4e422bc3d..75a1b61a8 100644 --- a/src/data/cassandra/impl/Result.hpp +++ b/src/data/cassandra/impl/Result.hpp @@ -43,18 +43,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 271d82d04..99fd6ab04 100644 --- a/src/data/cassandra/impl/Statement.hpp +++ b/src/data/cassandra/impl/Statement.hpp @@ -93,18 +93,17 @@ 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 + 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::base_uint"); + } 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"); @@ -122,7 +121,7 @@ public: 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)}); diff --git a/src/data/cassandra/impl/Tuple.hpp b/src/data/cassandra/impl/Tuple.hpp index 5c8f48c5f..bee2399e2 100644 --- a/src/data/cassandra/impl/Tuple.hpp +++ b/src/data/cassandra/impl/Tuple.hpp @@ -62,14 +62,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 a3e9905a8..bb6b28760 100644 --- a/src/data/impl/InputFile.cpp +++ b/src/data/impl/InputFile.cpp @@ -29,7 +29,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 d35e3d093..d4b9e6ec4 100644 --- a/src/data/impl/InputFile.hpp +++ b/src/data/impl/InputFile.hpp @@ -32,7 +32,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 52bc370bd..a44c1b83d 100644 --- a/src/data/impl/LedgerCacheFile.cpp +++ b/src/data/impl/LedgerCacheFile.cpp @@ -17,17 +17,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)); } @@ -81,7 +81,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()); @@ -89,14 +89,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); // flush internal buffer explicitly before renaming if (auto const expectedSuccess = file.close(); not expectedSuccess.has_value()) { @@ -185,9 +185,9 @@ LedgerCacheFile::read(uint32_t minLatestSequence) } auto const dataHash = file.hash(); - ripple::uint256 hashFromFile{}; + xrpl::uint256 hashFromFile{}; if (not file.readRaw( - reinterpret_cast(hashFromFile.data()), decltype(hashFromFile)::bytes + 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 2ae06911e..9ab50b1f3 100644 --- a/src/data/impl/OutputFile.cpp +++ b/src/data/impl/OutputFile.cpp @@ -34,7 +34,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 25d4dd130..99ad8f3bb 100644 --- a/src/data/impl/OutputFile.hpp +++ b/src/data/impl/OutputFile.hpp @@ -39,7 +39,7 @@ public: void writeRaw(char const* data, size_t size); - ripple::uint256 + xrpl::uint256 hash() const; std::expected diff --git a/src/etl/ETLHelpers.cpp b/src/etl/ETLHelpers.cpp index 43781b673..d1743c7c4 100644 --- a/src/etl/ETLHelpers.cpp +++ b/src/etl/ETLHelpers.cpp @@ -8,16 +8,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 a70d70266..0b660638c 100644 --- a/src/etl/ETLHelpers.hpp +++ b/src/etl/ETLHelpers.hpp @@ -130,7 +130,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 721c4fe33..cecc4a334 100644 --- a/src/etl/ETLService.cpp +++ b/src/etl/ETLService.cpp @@ -298,7 +298,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_); diff --git a/src/etl/LoaderInterface.hpp b/src/etl/LoaderInterface.hpp index e10e2d1c3..bcbb047ea 100644 --- a/src/etl/LoaderInterface.hpp +++ b/src/etl/LoaderInterface.hpp @@ -36,7 +36,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 1ed6aef95..3aa3de6f9 100644 --- a/src/etl/MPTHelpers.cpp +++ b/src/etl/MPTHelpers.cpp @@ -1,16 +1,16 @@ #include "data/DBHelpers.hpp" #include "util/Assert.hpp" -#include -#include -#include #include #include #include +#include #include #include +#include #include #include +#include #include #include @@ -19,23 +19,23 @@ namespace etl { std::vector -getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const&) +getMPTHolderFromTx(xrpl::TxMeta const& txMeta, xrpl::STTx const&) { - if (txMeta.getResultTER() != ripple::tesSUCCESS) + if (txMeta.getResultTER() != xrpl::tesSUCCESS) return {}; std::vector holders; - 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(); holders.push_back( MPTHolderData{ - .mptID = newMPT[ripple::sfMPTokenIssuanceID], - .holder = newMPT.getAccountID(ripple::sfAccount) + .mptID = newMPT[xrpl::sfMPTokenIssuanceID], + .holder = newMPT.getAccountID(xrpl::sfAccount) } ); } @@ -49,19 +49,19 @@ 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(), + 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 e4b2d3878..0335cdb62 100644 --- a/src/etl/MPTHelpers.hpp +++ b/src/etl/MPTHelpers.hpp @@ -3,8 +3,8 @@ #include "data/DBHelpers.hpp" -#include -#include +#include +#include #include #include @@ -21,7 +21,7 @@ namespace etl { * failed or created no MPToken. */ std::vector -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 9d07d4275..6df7f5932 100644 --- a/src/etl/Models.hpp +++ b/src/etl/Models.hpp @@ -28,7 +28,7 @@ namespace etl::model { * incoming transactions by 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 kSpecTag = true; @@ -40,7 +40,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) || ...); } @@ -54,13 +54,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 @@ -94,9 +94,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; @@ -127,7 +127,7 @@ struct LedgerData { std::optional> successors; std::optional> edgeKeys; - ripple::LedgerHeader header; + xrpl::LedgerHeader header; std::string rawHeader; uint32_t seq; @@ -140,8 +140,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 cd14ef4a6..6b885efe5 100644 --- a/src/etl/NFTHelpers.cpp +++ b/src/etl/NFTHelpers.cpp @@ -30,50 +30,50 @@ 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() + sttx.getFieldH256(xrpl::sfNFTokenID), txMeta, sttx.getTransactionID() )}, - NFTsData(tokenID, txMeta, sttx.getFieldVL(ripple::sfURI)) + 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 @@ -88,27 +88,27 @@ 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); } ); } } @@ -130,14 +130,14 @@ getNFTokenMintData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) return { {NFTTransactionsData(*finalMismatch, txMeta, sttx.getTransactionID())}, - NFTsData(*finalMismatch, *owner, sttx.getFieldVL(ripple::sfURI), txMeta) + NFTsData(*finalMismatch, *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()) }; @@ -145,9 +145,9 @@ getNFTokenBurnData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) // 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 @@ -158,25 +158,25 @@ 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; + prevNFTs->begin(), prevNFTs->end(), [&tokenID](xrpl::STObject const& candidate) { + return candidate.getFieldH256(xrpl::sfNFTokenID) == tokenID; } ); if (nft != prevNFTs->end()) { @@ -184,7 +184,7 @@ getNFTokenBurnData(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) txs, NFTsData( tokenID, - ripple::AccountID::fromVoid(node.getFieldH256(ripple::sfLedgerIndex).data()), + xrpl::AccountID::fromVoid(node.getFieldH256(xrpl::sfLedgerIndex).data()), txMeta, true ) @@ -198,18 +198,18 @@ 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); + [&sttx](xrpl::STObject const& node) { + return node.getFieldH256(xrpl::sfLedgerIndex) == + sttx.getFieldH256(xrpl::sfNFTokenBuyOffer); } ); if (affectedBuyOffer == txMeta.getNodes().end()) { @@ -218,13 +218,13 @@ 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) @@ -233,9 +233,9 @@ 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); + 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()) { @@ -244,37 +244,37 @@ 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 { @@ -294,16 +294,16 @@ 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,39 +322,39 @@ 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() + 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: @@ -367,23 +367,23 @@ getNFTDataFromObj(std::uint32_t const seq, std::string const& key, std::string c { // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0020-non-fungible-tokens#tokenpage-id-format ASSERT( - key.size() == ripple::uint256::size(), + 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()) + auto const sle = 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)) { + for (xrpl::STObject const& node : sle.getFieldArray(xrpl::sfNFTokens)) { nfts.emplace_back( - node.getFieldH256(ripple::sfNFTokenID), seq, owner, node.getFieldVL(ripple::sfURI) + node.getFieldH256(xrpl::sfNFTokenID), seq, owner, node.getFieldVL(xrpl::sfURI) ); } diff --git a/src/etl/NFTHelpers.hpp b/src/etl/NFTHelpers.hpp index c06ee2af5..85da5b56d 100644 --- a/src/etl/NFTHelpers.hpp +++ b/src/etl/NFTHelpers.hpp @@ -22,7 +22,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 @@ -32,7 +32,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 @@ -42,7 +42,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 @@ -52,7 +52,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 @@ -62,7 +62,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 @@ -72,7 +72,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. @@ -82,7 +82,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 4c740d355..3cf4c9712 100644 --- a/src/etl/RegistryInterface.hpp +++ b/src/etl/RegistryInterface.hpp @@ -40,11 +40,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 839044d65..83d204728 100644 --- a/src/etl/impl/AsyncGrpcCall.cpp +++ b/src/etl/impl/AsyncGrpcCall.cpp @@ -26,22 +26,22 @@ namespace etl::impl { AsyncGrpcCall::AsyncGrpcCall( uint32_t seq, - ripple::uint256 const& marker, - std::optional const& nextMarker + 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, @@ -142,7 +142,7 @@ std::string AsyncGrpcCall::getMarkerPrefix() { return next_->marker().empty() ? std::string{} - : ripple::strHex(std::string{next_->marker().data()[0]}); + : 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 47d942455..85a891d3b 100644 --- a/src/etl/impl/AsyncGrpcCall.hpp +++ b/src/etl/impl/AsyncGrpcCall.hpp @@ -42,8 +42,8 @@ private: public: AsyncGrpcCall( uint32_t seq, - ripple::uint256 const& marker, - std::optional const& nextMarker + xrpl::uint256 const& marker, + std::optional const& nextMarker ); static std::vector diff --git a/src/etl/impl/BaseCursorProvider.hpp b/src/etl/impl/BaseCursorProvider.hpp index 4edb467e5..6b07887cb 100644 --- a/src/etl/impl/BaseCursorProvider.hpp +++ b/src/etl/impl/BaseCursorProvider.hpp @@ -7,8 +7,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 2641cdf0a..a361a6818 100644 --- a/src/etl/impl/CacheLoader.hpp +++ b/src/etl/impl/CacheLoader.hpp @@ -105,7 +105,7 @@ private: } auto [start, end] = *cursor; - 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 = diff --git a/src/etl/impl/CursorFromAccountProvider.hpp b/src/etl/impl/CursorFromAccountProvider.hpp index 303d1a975..6fbe46777 100644 --- a/src/etl/impl/CursorFromAccountProvider.hpp +++ b/src/etl/impl/CursorFromAccountProvider.hpp @@ -43,7 +43,7 @@ public: }(); rg::sort(accountRoots); - std::vector cursors{data::kFirstKey}; + std::vector cursors{data::kFirstKey}; rg::copy(accountRoots.begin(), accountRoots.end(), std::back_inserter(cursors)); rg::sort(cursors); cursors.push_back(data::kLastKey); diff --git a/src/etl/impl/CursorFromDiffProvider.hpp b/src/etl/impl/CursorFromDiffProvider.hpp index c1b6ef766..a6cabdf8a 100644 --- a/src/etl/impl/CursorFromDiffProvider.hpp +++ b/src/etl/impl/CursorFromDiffProvider.hpp @@ -43,8 +43,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; // NOLINTNEXTLINE(bugprone-unchecked-optional-access) while (liveCursors.size() < numCursors_ and seq - i >= range->minSequence) { @@ -67,7 +67,7 @@ public: ); } - std::vector cursors{data::kFirstKey}; + std::vector cursors{data::kFirstKey}; rg::copy( liveCursors | vs::take(std::min(liveCursors.size(), numCursors_)), std::back_inserter(cursors) diff --git a/src/etl/impl/CursorFromFixDiffNumProvider.hpp b/src/etl/impl/CursorFromFixDiffNumProvider.hpp index b74ea7502..fdf2ed24b 100644 --- a/src/etl/impl/CursorFromFixDiffNumProvider.hpp +++ b/src/etl/impl/CursorFromFixDiffNumProvider.hpp @@ -57,7 +57,7 @@ public: rg::unique(diffs, [](auto const& a, auto const& b) { return a.key == b.key; }); diffs.erase(removalCursor, last); - std::vector cursors{data::kFirstKey}; + std::vector cursors{data::kFirstKey}; 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 6a46493ea..73177c67c 100644 --- a/src/etl/impl/Extraction.cpp +++ b/src/etl/impl/Extraction.cpp @@ -10,6 +10,7 @@ #include "util/Profiler.hpp" #include "util/log/Logger.hpp" +#include #include #include #include @@ -55,9 +56,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), @@ -90,7 +92,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"); if (!key) return {}; @@ -162,7 +164,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 = extractTxs( diff --git a/src/etl/impl/LedgerPublisher.hpp b/src/etl/impl/LedgerPublisher.hpp index a75c6ae11..4e191c6cf 100644 --- a/src/etl/impl/LedgerPublisher.hpp +++ b/src/etl/impl/LedgerPublisher.hpp @@ -65,7 +65,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( @@ -157,7 +157,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); @@ -169,7 +169,7 @@ public: // and don't publish static constexpr std::uint32_t kMaxLedgerAgeSeconds = 600; if (age < kMaxLedgerAgeSeconds) { - std::optional fees = + std::optional fees = data::synchronousAndRetryOnTimeout([&](auto yield) { return backend_->fetchFees(lgrInfo.seq, yield); }); @@ -188,12 +188,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) @@ -275,7 +275,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 4daef36b7..f319a64f8 100644 --- a/src/etl/impl/Loading.cpp +++ b/src/etl/impl/Loading.cpp @@ -120,7 +120,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 3870165a9..0096b9225 100644 --- a/src/etl/impl/Loading.hpp +++ b/src/etl/impl/Loading.hpp @@ -67,7 +67,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 87c7e333a..552ee71d8 100644 --- a/src/etl/impl/ext/MPT.cpp +++ b/src/etl/impl/ext/MPT.cpp @@ -31,7 +31,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 f084b85be..3a5481250 100644 --- a/src/etl/impl/ext/Successor.cpp +++ b/src/etl/impl/ext/Successor.cpp @@ -133,7 +133,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); // NOLINT(bugprone-unchecked-optional-access) } else { @@ -161,7 +161,7 @@ void SuccessorExt::updateBookSuccessor( std::optional const& maybeSuccessor, auto seq, - ripple::uint256 const& bookBase + xrpl::uint256 const& bookBase ) const { if (maybeSuccessor.has_value()) { @@ -176,7 +176,7 @@ SuccessorExt::updateBookSuccessor( void SuccessorExt::writeSuccessors(uint32_t seq) const { - ripple::uint256 prev = data::kFirstKey; + xrpl::uint256 prev = data::kFirstKey; while (auto cur = cache_.get().getSuccessor(prev, seq)) { if (prev == data::kFirstKey) backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(cur->key)); @@ -187,9 +187,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) // NOLINT(bugprone-unchecked-optional-access) backend_->writeSuccessor(uint256ToString(base), seq, uint256ToString(cur->key)); @@ -207,7 +205,7 @@ SuccessorExt::writeEdgeKeys(std::uint32_t seq, auto const& edgeKeys) const { for (auto const& key : edgeKeys) { // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - 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 7cc317af9..dbac88587 100644 --- a/src/etl/impl/ext/Successor.hpp +++ b/src/etl/impl/ext/Successor.hpp @@ -54,7 +54,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 d7893bb07..eeeba9f51 100644 --- a/src/feed/SubscriptionManager.cpp +++ b/src/feed/SubscriptionManager.cpp @@ -29,7 +29,7 @@ SubscriptionManager::unsubBookChanges(SubscriberSharedPtr const& subscriber) void SubscriptionManager::pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) { @@ -55,7 +55,7 @@ SubscriptionManager::unsubProposedTransactions(SubscriberSharedPtr const& subscr void SubscriptionManager::subProposedAccount( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) { @@ -68,7 +68,7 @@ SubscriptionManager::subProposedAccount( void SubscriptionManager::unsubProposedAccount( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) { @@ -99,8 +99,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 ) @@ -158,7 +158,7 @@ SubscriptionManager::unsubTransactions(SubscriberSharedPtr const& subscriber) void SubscriptionManager::subAccount( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) { @@ -167,7 +167,7 @@ SubscriptionManager::subAccount( void SubscriptionManager::unsubAccount( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) { @@ -175,13 +175,13 @@ SubscriptionManager::unsubAccount( } 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); } @@ -189,7 +189,7 @@ SubscriptionManager::unsubBook(ripple::Book const& book, SubscriberSharedPtr con void SubscriptionManager::pubTransaction( data::TransactionAndMetadata const& txMeta, - ripple::LedgerHeader const& lgrInfo + xrpl::LedgerHeader const& lgrInfo ) { transactionFeed_.pub(txMeta, lgrInfo, backend_, amendmentCenter_, networkID_); diff --git a/src/feed/SubscriptionManager.hpp b/src/feed/SubscriptionManager.hpp index 5b4cdb79b..f7db99606 100644 --- a/src/feed/SubscriptionManager.hpp +++ b/src/feed/SubscriptionManager.hpp @@ -143,7 +143,7 @@ public: */ void pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) final; @@ -168,10 +168,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. @@ -180,7 +177,7 @@ public: */ void unsubProposedAccount( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) final; @@ -216,8 +213,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; @@ -285,7 +282,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. @@ -293,7 +290,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 @@ -302,7 +299,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. @@ -310,7 +307,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. @@ -320,7 +317,7 @@ public: void pubTransaction( data::TransactionAndMetadata const& txMeta, - ripple::LedgerHeader const& lgrInfo + xrpl::LedgerHeader const& lgrInfo ) final; /** diff --git a/src/feed/SubscriptionManagerInterface.hpp b/src/feed/SubscriptionManagerInterface.hpp index 2d07586e2..422f63946 100644 --- a/src/feed/SubscriptionManagerInterface.hpp +++ b/src/feed/SubscriptionManagerInterface.hpp @@ -53,7 +53,7 @@ public: */ virtual void pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) = 0; @@ -78,7 +78,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. @@ -86,10 +86,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. @@ -124,8 +121,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; @@ -193,7 +190,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. @@ -201,7 +198,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 @@ -210,7 +207,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. @@ -218,7 +215,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. @@ -228,7 +225,7 @@ public: virtual void pubTransaction( data::TransactionAndMetadata const& txMeta, - ripple::LedgerHeader const& lgrInfo + xrpl::LedgerHeader const& lgrInfo ) = 0; /** diff --git a/src/feed/impl/BookChangesFeed.hpp b/src/feed/impl/BookChangesFeed.hpp index 87f0cc239..bff965f72 100644 --- a/src/feed/impl/BookChangesFeed.hpp +++ b/src/feed/impl/BookChangesFeed.hpp @@ -31,7 +31,7 @@ struct BookChangesFeed : public SingleFeedBase { * @param transactions The transactions that were included in the ledger. */ void - pub(ripple::LedgerHeader const& lgrInfo, + 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 3454f66b4..3fe0172f4 100644 --- a/src/feed/impl/LedgerFeed.cpp +++ b/src/feed/impl/LedgerFeed.cpp @@ -22,8 +22,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 @@ -80,8 +80,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 9aa97bc3b..d66e72164 100644 --- a/src/feed/impl/LedgerFeed.hpp +++ b/src/feed/impl/LedgerFeed.hpp @@ -59,8 +59,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); @@ -68,8 +68,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 1b2d65412..db1194822 100644 --- a/src/feed/impl/ProposedTransactionFeed.cpp +++ b/src/feed/impl/ProposedTransactionFeed.cpp @@ -52,10 +52,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 added = accountSignal_.connectTrackableSlot( subscriber, account, ProposedTransactionSlot(*this, subscriber) @@ -78,7 +75,7 @@ ProposedTransactionFeed::unsub(SubscriberSharedPtr const& subscriber) void ProposedTransactionFeed::unsub( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) { @@ -114,8 +111,7 @@ ProposedTransactionFeed::pub(boost::json::object const& receivedTxJson) auto const transaction = receivedTxJson.at(JS(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, allVersionMsgs, affectedAccounts = std::move(affectedAccounts)]() { @@ -154,7 +150,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 517b0cdb8..d2b989529 100644 --- a/src/feed/impl/ProposedTransactionFeed.hpp +++ b/src/feed/impl/ProposedTransactionFeed.hpp @@ -62,7 +62,7 @@ class ProposedTransactionFeed { std::reference_wrapper subAllCount_; std::reference_wrapper subAccountCount_; - TrackableSignalMap accountSignal_; + TrackableSignalMap accountSignal_; TrackableSignal signal_; public: @@ -98,7 +98,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. @@ -113,7 +113,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. @@ -139,6 +139,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 563450d9a..f8e60ed94 100644 --- a/src/feed/impl/TransactionFeed.cpp +++ b/src/feed/impl/TransactionFeed.cpp @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -68,7 +69,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) @@ -95,10 +96,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) @@ -111,7 +109,7 @@ TransactionFeed::subProposed( } 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)); @@ -131,7 +129,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()); } @@ -144,7 +142,7 @@ TransactionFeed::unsubProposed(SubscriberSharedPtr const& subscriber) void TransactionFeed::unsubProposed( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) { @@ -152,7 +150,7 @@ TransactionFeed::unsubProposed( } 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 +176,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 +184,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( @@ -215,8 +213,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(); @@ -240,10 +238,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)]; @@ -255,7 +253,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; @@ -270,36 +268,36 @@ TransactionFeed::pub( ); auto const affectedAccountsFlat = meta->getAffectedAccounts(); - auto affectedAccounts = std::unordered_set( + auto affectedAccounts = 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); @@ -345,7 +343,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; @@ -360,13 +358,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 d55bc0d01..e1740ca56 100644 --- a/src/feed/impl/TransactionFeed.hpp +++ b/src/feed/impl/TransactionFeed.hpp @@ -54,14 +54,14 @@ class TransactionFeed { std::reference_wrapper subAccountCount_; std::reference_wrapper subBookCount_; - TrackableSignalMap const&> + TrackableSignalMap const&> accountSignal_; - TrackableSignalMap const&> + TrackableSignalMap const&> bookSignal_; TrackableSignal const&> signal_; // Signals for proposed tx subscribers - TrackableSignalMap const&> + TrackableSignalMap const&> accountProposedSignal_; TrackableSignal const&> txProposedSignal_; @@ -100,7 +100,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 @@ -109,7 +109,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. @@ -125,7 +125,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. @@ -140,7 +140,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. @@ -155,7 +155,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. @@ -163,7 +163,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. @@ -174,7 +174,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); @@ -202,15 +202,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 e95c29c80..47904a7da 100644 --- a/src/migration/cassandra/impl/ObjectsAdapter.cpp +++ b/src/migration/cassandra/impl/ObjectsAdapter.cpp @@ -17,7 +17,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 8039c474a..e8938128b 100644 --- a/src/migration/cassandra/impl/ObjectsAdapter.hpp +++ b/src/migration/cassandra/impl/ObjectsAdapter.hpp @@ -22,7 +22,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* kPartitionKey = "key"; static constexpr char const* kTableName = "objects"; }; @@ -33,7 +33,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 7e2da4d82..b1c69c1f9 100644 --- a/src/migration/cassandra/impl/TransactionsAdapter.cpp +++ b/src/migration/cassandra/impl/TransactionsAdapter.cpp @@ -11,9 +11,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 0e784414d..bbb0b5a54 100644 --- a/src/migration/cassandra/impl/TransactionsAdapter.hpp +++ b/src/migration/cassandra/impl/TransactionsAdapter.hpp @@ -22,8 +22,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* kPartitionKey = "hash"; static constexpr char const* kTableName = "transactions"; }; @@ -34,7 +33,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 2bffede1c..3dc6fcb58 100644 --- a/src/rpc/AMMHelpers.cpp +++ b/src/rpc/AMMHelpers.cpp @@ -10,21 +10,20 @@ #include #include #include -#include #include #include 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 ) @@ -52,39 +51,39 @@ 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 11857200c..02d6f8077 100644 --- a/src/rpc/AMMHelpers.hpp +++ b/src/rpc/AMMHelpers.hpp @@ -28,14 +28,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 ); @@ -45,21 +45,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 ); @@ -73,12 +73,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 bc496a775..3eb1afeb4 100644 --- a/src/rpc/BookChangesHelper.hpp +++ b/src/rpc/BookChangesHelper.hpp @@ -37,13 +37,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; }; /** @@ -90,59 +90,59 @@ 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(); + node.peekAtField(xrpl::sfFinalFields).downcast(); auto const& previousFields = - node.peekAtField(ripple::sfPreviousFields).downcast(); + 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); - auto const deltaPays = finalFields.getFieldAmount(ripple::sfTakerPays) - - previousFields.getFieldAmount(ripple::sfTakerPays); + auto const deltaGets = finalFields.getFieldAmount(xrpl::sfTakerGets) - + previousFields.getFieldAmount(xrpl::sfTakerGets); + auto const deltaPays = 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)) @@ -154,15 +154,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); @@ -197,24 +197,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; @@ -232,12 +232,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 = { @@ -252,7 +252,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); } /** @@ -264,7 +264,7 @@ tag_invoke(boost::json::value_from_tag, boost::json::value& jv, BookChange const */ [[nodiscard]] boost::json::object computeBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ); diff --git a/src/rpc/CredentialHelpers.cpp b/src/rpc/CredentialHelpers.cpp index ca1cce187..2601cb03e 100644 --- a/src/rpc/CredentialHelpers.cpp +++ b/src/rpc/CredentialHelpers.cpp @@ -34,36 +34,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( + auto const issuer = xrpl::parseBase58( static_cast(jo.at(JS(issuer)).as_string()) ); ASSERT( @@ -77,18 +77,18 @@ parseAuthorizeCredentials(boost::json::array const& jv) "AuthorizeCredentialValidator" ); auto const credentialType = - ripple::strUnHex(static_cast(jo.at(JS(credential_type)).as_string())); + 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); + auto credential = xrpl::STObject::makeInnerObject(xrpl::sfCredential); // NOLINTBEGIN(bugprone-unchecked-optional-access) - credential.setAccountID(ripple::sfIssuer, *issuer); - credential.setFieldVL(ripple::sfCredentialType, *credentialType); + credential.setAccountID(xrpl::sfIssuer, *issuer); + credential.setFieldVL(xrpl::sfCredentialType, *credentialType); // NOLINTEND(bugprone-unchecked-optional-access) arr.push_back(std::move(credential)); @@ -97,16 +97,16 @@ parseAuthorizeCredentials(boost::json::array const& jv) 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) { // NOLINT(bugprone-unchecked-optional-access) ASSERT( @@ -114,41 +114,39 @@ fetchCredentialArray( ); 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) { + if (sleCred.getAccountID(xrpl::sfSubject) != srcAcc) { return Error{Status{ - RippledError::rpcBAD_CREDENTIALS, "credentials don't belong to the root account" + 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 2091181de..1cf27e652 100644 --- a/src/rpc/CredentialHelpers.hpp +++ b/src/rpc/CredentialHelpers.hpp @@ -28,7 +28,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 @@ -37,8 +37,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 @@ -46,7 +46,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); /** @@ -59,12 +59,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 5d7da425f..f8ec37cfa 100644 --- a/src/rpc/Errors.cpp +++ b/src/rpc/Errors.cpp @@ -34,7 +34,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) { @@ -164,11 +164,11 @@ makeError( ) { 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"; @@ -204,7 +204,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"} }; diff --git a/src/rpc/Errors.hpp b/src/rpc/Errors.hpp index 5da04323e..89af5d40d 100644 --- a/src/rpc/Errors.hpp +++ b/src/rpc/Errors.hpp @@ -24,7 +24,7 @@ enum class ClioError { RpcFieldNotFoundTransaction = 5006, RpcMalformedOracleDocumentId = 5007, RpcMalformedAuthorizedCredentials = 5008, - // NOTE: RpcEntryNotFound is replaced with RippledError::rpcENTRY_NOT_FOUND + // NOTE: RpcEntryNotFound is replaced with RippledError::RpcEntryNotFound // RpcEntryNotFound = 5009, // special system errors start with 6000 @@ -51,7 +51,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. @@ -63,7 +63,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; @@ -94,7 +94,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)) { } @@ -131,7 +131,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 2dbc78cba..6badd0147 100644 --- a/src/rpc/Factories.cpp +++ b/src/rpc/Factories.cpp @@ -83,7 +83,7 @@ makeHttpContext( if (command == "subscribe" || command == "unsubscribe") { return Error{ - {RippledError::rpcBAD_SYNTAX, + {RippledError::RpcBadSyntax, "Subscribe and unsubscribe are only allowed for websocket."} }; } diff --git a/src/rpc/JS.hpp b/src/rpc/JS.hpp index ceb733d18..2147b4557 100644 --- a/src/rpc/JS.hpp +++ b/src/rpc/JS.hpp @@ -2,11 +2,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 a3e970d30..bb9ee6779 100644 --- a/src/rpc/RPCEngine.hpp +++ b/src/rpc/RPCEngine.hpp @@ -135,7 +135,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); } @@ -148,13 +148,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 { @@ -182,12 +182,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}}; } } @@ -333,13 +333,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 { @@ -365,12 +365,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 d447e5d4a..22e411a25 100644 --- a/src/rpc/RPCHelpers.cpp +++ b/src/rpc/RPCHelpers.cpp @@ -88,7 +88,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) @@ -116,17 +116,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. @@ -138,7 +138,7 @@ getDeliveredAmount( static constexpr std::uint32_t kFirstLedgerWithDeliveredAmount = 4594095; static constexpr std::uint32_t kDeliveredAmountLiveDate = 446000000; if (ledgerSequence >= kFirstLedgerWithDeliveredAmount || date > kDeliveredAmountLiveDate) { - return txn->getFieldAmount(ripple::sfAmount); + return txn->getFieldAmount(xrpl::sfAmount); } } return {}; @@ -146,55 +146,54 @@ getDeliveredAmount( bool canHaveDeliveredAmount( - std::shared_ptr const& txn, - std::shared_ptr const& meta + 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); + 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) { @@ -210,22 +209,22 @@ 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::parse(obj.getJson(xrpl::JsonOptions::Values::None).toStyledString()); return value.as_object(); } @@ -239,15 +238,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()) { @@ -286,15 +285,15 @@ 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)); + toBoostJson(amt->getJson(xrpl::JsonOptions::Values::IncludeDate)); } else { metaJson["delivered_amount"] = "unavailable"; } @@ -309,18 +308,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 {}; @@ -335,22 +334,22 @@ getMPTIssuanceID(std::shared_ptr const& meta) */ static bool canHaveMPTIssuanceID( - std::shared_ptr const& txn, - std::shared_ptr const& meta + 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)) @@ -365,9 +364,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; @@ -385,16 +384,16 @@ 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::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()); @@ -402,13 +401,13 @@ 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::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"] = @@ -419,23 +418,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); @@ -460,7 +459,7 @@ parseStringAsUInt(std::string const& value) return index; } -std::expected +std::expected ledgerHeaderFromRequest( std::shared_ptr const& backend, web::Context const& ctx @@ -470,16 +469,16 @@ ledgerHeaderFromRequest( 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; } @@ -503,18 +502,18 @@ ledgerHeaderFromRequest( } 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, @@ -523,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; @@ -548,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); @@ -566,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 @@ -589,80 +588,80 @@ 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); if (!page) break; - 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; + startHint == std::numeric_limits::max() and hexCursor != beast::kZero; auto const isNftMarkerZero = - startHint == std::numeric_limits::max() and hexCursor == beast::zero; + 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 @@ -686,18 +685,18 @@ 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), + xrpl::keylet::ownerDir(accountID), hexCursor, startHint, sequence, @@ -710,23 +709,23 @@ traverseOwnedNodes( 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. @@ -737,19 +736,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; @@ -759,14 +758,14 @@ traverseOwnedNodes( if (!ownerDir) { return std::unexpected{ - Status(ripple::rpcINVALID_PARAMS, "Owner directory not found.") + 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; @@ -784,11 +783,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 { @@ -798,10 +797,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) @@ -813,11 +812,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; } } @@ -837,35 +836,35 @@ 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 @@ -874,29 +873,28 @@ 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 kSeedSize = 18; static constexpr std::array kSeedPrefix = {0xE1, 0x4B}; if (result.size() == kSeedSize && static_cast(result[0]) == kSeedPrefix[0] && static_cast(result[1]) == kSeedPrefix[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( + auto const account = util::parseBase58Wrapper( boost::json::value_to(value) ); if (account) { @@ -912,30 +910,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 ) @@ -945,8 +943,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); }); } @@ -955,27 +953,27 @@ 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 + 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 ); } @@ -984,26 +982,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 ); } @@ -1011,9 +1005,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 ) { @@ -1021,33 +1015,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; @@ -1056,13 +1050,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 ) { @@ -1075,79 +1069,79 @@ accountFunds( amendmentCenter, sequence, id, - amount.getCurrency(), + 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; } @@ -1163,35 +1157,35 @@ accountHolds( yield, data::Amendments::fixFrozenLPTokenTransfer, sequence )) { auto const issuerBlob = - backend.fetchLedgerObject(ripple::keylet::account(issuer).key, sequence, yield); + 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 ); } @@ -1201,50 +1195,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, @@ -1253,26 +1247,27 @@ 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; @@ -1293,34 +1288,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) { @@ -1329,19 +1324,19 @@ postProcessOrderBook( } else { saTakerGetsFunded = saOwnerFundsLimit; offerJson["taker_gets_funded"] = - toBoostJson(saTakerGetsFunded.getJson(ripple::JsonOptions::none)); + toBoostJson(saTakerGetsFunded.getJson(xrpl::JsonOptions::Values::None)); offerJson["taker_pays_funded"] = toBoostJson( std::min( saTakerPays, - ripple::multiply(saTakerGetsFunded, dirRate, saTakerPays.issue()) + xrpl::multiply(saTakerGetsFunded, dirRate, saTakerPays.get()) ) - .getJson(ripple::JsonOptions::none) + .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; @@ -1360,234 +1355,230 @@ 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, + RippledError::RpcSrcIsrMalformed, "Unneeded field 'taker_pays.issuer' for XRP currency specification." }}; } if (!isXRP(pays) && isXRP(payIssuer)) { return std::unexpected{Status{ - RippledError::rpcSRC_ISR_MALFORMED, + 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, + 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, + 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'"} + Status{RippledError::RpcInvalidParams, "Missing field 'taker_pays'"} }; } if (!request.contains("taker_gets")) { return std::unexpected{ - Status{RippledError::rpcINVALID_PARAMS, "Missing field 'taker_gets'"} + 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"} + 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"} + 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( + xrpl::Currency payCurrency; + if (!xrpl::toCurrency( payCurrency, boost::json::value_to(takerPays.at("currency")) )) - return std::unexpected{Status{RippledError::rpcSRC_CUR_MALFORMED}}; + 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"} + 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, + RippledError::RpcSrcIsrMalformed, "Unneeded field 'taker_pays.issuer' for XRP currency specification." }}; } if (!isXRP(payCurrency) && isXRP(payIssuer)) { return std::unexpected{Status{ - RippledError::rpcSRC_ISR_MALFORMED, + 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"} + Status{RippledError::RpcInvalidParams, "taker_gets.issuer should be string"} }; } - if (!ripple::to_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." + 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, + 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, + 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, + 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 @@ -1608,8 +1599,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 @@ -1630,18 +1621,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; } @@ -1651,8 +1642,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 6cac45430..25cd7af74 100644 --- a/src/rpc/RPCHelpers.hpp +++ b/src/rpc/RPCHelpers.hpp @@ -69,12 +69,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); /** @@ -85,7 +85,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 @@ -95,7 +95,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 @@ -113,7 +113,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 @@ -124,7 +124,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); /** @@ -175,8 +175,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 ); @@ -195,9 +195,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 ); /** @@ -207,7 +207,7 @@ insertMPTIssuanceID( * @return The JSON object */ boost::json::object -toJson(ripple::STBase const& obj); +toJson(xrpl::STBase const& obj); /** * @brief Convert SLE to JSON @@ -216,7 +216,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. @@ -227,7 +227,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. @@ -236,9 +236,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 @@ -260,8 +260,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 ); @@ -273,7 +273,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 @@ -289,7 +289,7 @@ ledgerHeaderFromRequest( * @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, @@ -314,13 +314,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 ); /** @@ -341,12 +341,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 ); @@ -359,11 +359,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 ); @@ -373,7 +373,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); /** @@ -384,7 +384,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 @@ -399,7 +399,7 @@ bool isGlobalFrozen( BackendInterface const& backend, std::uint32_t seq, - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, boost::asio::yield_context yield ); @@ -418,9 +418,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 ); @@ -438,7 +438,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 ); @@ -461,9 +461,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 ); @@ -482,9 +482,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 ); @@ -499,13 +499,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 ); @@ -522,14 +522,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 ); @@ -546,13 +546,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 ); @@ -566,11 +566,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 ); @@ -583,11 +583,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 ); @@ -606,8 +606,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, @@ -624,12 +624,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 ); @@ -639,7 +639,7 @@ parseBook( * @param request The request * @return The book or an error status */ -std::expected +std::expected parseBook(boost::json::object const& request); /** @@ -648,17 +648,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); /** @@ -685,7 +685,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); /** @@ -786,7 +786,7 @@ logDuration( * @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); /** @@ -805,11 +805,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 ); /** @@ -830,8 +830,8 @@ parseStringAsUInt(std::string const& value); // TODO: move to string utils or s */ bool canHaveDeliveredAmount( - std::shared_ptr const& txn, - std::shared_ptr const& meta + std::shared_ptr const& txn, + std::shared_ptr const& meta ); /** @@ -843,10 +843,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 d4a3aa94f..a5ab8cc7c 100644 --- a/src/rpc/common/MetaProcessors.cpp +++ b/src/rpc/common/MetaProcessors.cpp @@ -36,11 +36,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 739cd726a..0b621220b 100644 --- a/src/rpc/common/Modifiers.hpp +++ b/src/rpc/common/Modifiers.hpp @@ -110,12 +110,12 @@ struct ToNumber final { auto const strInt = boost::json::value_to(value.as_object().at(key)); if (strInt.contains('.')) - 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 159f19c6b..d2798c1e9 100644 --- a/src/rpc/common/Types.hpp +++ b/src/rpc/common/Types.hpp @@ -149,7 +149,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{}; /** @@ -160,7 +160,7 @@ struct AccountCursor { [[nodiscard]] 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 ec9ab077e..600d57de7 100644 --- a/src/rpc/common/Validators.cpp +++ b/src/rpc/common/Validators.cpp @@ -33,7 +33,7 @@ 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" + RippledError::RpcInvalidParams, "Required field '" + std::string{key} + "' missing" }}; } @@ -49,12 +49,12 @@ 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 {}; } @@ -79,22 +79,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; @@ -110,15 +110,15 @@ 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) + RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', not string.", key) }}; } auto const type = util::LedgerTypes::getLedgerEntryTypeFromStr(boost::json::value_to(value)); - if (type == ripple::ltANY) { + if (type == xrpl::ltANY) { return Error{ - Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}'.", key)} + Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}'.", key)} }; } @@ -128,12 +128,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{}; }}; @@ -141,10 +141,10 @@ 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)); + util::parseBase58Wrapper(boost::json::value_to(value)); if (!account || account->isZero()) return Error{Status{ClioError::RpcMalformedAddress}}; @@ -154,13 +154,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{}; @@ -170,16 +170,16 @@ 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) + RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', not string.", key) }}; } auto const type = util::LedgerTypes::getAccountOwnedLedgerTypeFromStr( boost::json::value_to(value) ); - if (type == ripple::ltANY) { + if (type == xrpl::ltANY) { return Error{ - Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}'.", key)} + Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}'.", key)} }; } @@ -189,14 +189,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{}; @@ -205,20 +205,20 @@ 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))) { + if (!xrpl::toIssuer(issuer, boost::json::value_to(value))) { return Error{Status{ - RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}', bad issuer.", key) + RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', bad issuer.", key) }}; } - if (issuer == ripple::noAccount()) { + if (issuer == xrpl::noAccount()) { return Error{Status{ - RippledError::rpcINVALID_PARAMS, + RippledError::RpcInvalidParams, fmt::format("Invalid field '{}', bad issuer account one.", key) }}; } @@ -229,7 +229,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 kValidStreams = { "ledger", @@ -245,13 +245,13 @@ CustomValidator CustomValidators::subscribeStreamValidator = }; 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 (kNotSupportStreams.contains(boost::json::value_to(v))) - return Error{Status{RippledError::rpcNOT_SUPPORTED}}; + return Error{Status{RippledError::RpcNotSupported}}; if (not kValidStreams.contains(boost::json::value_to(v))) - return Error{Status{RippledError::rpcSTREAM_MALFORMED}}; + return Error{Status{RippledError::RpcStreamMalformed}}; } return MaybeError{}; @@ -260,10 +260,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(); @@ -281,7 +281,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()); @@ -300,7 +300,7 @@ CustomValidator CustomValidators::credentialTypeValidator = }}; } - 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" @@ -313,7 +313,7 @@ CustomValidator CustomValidators::credentialTypeValidator = }; } - if (credTypeHex->size() > ripple::maxCredentialTypeLength) { + if (credTypeHex->size() > xrpl::kMaxCredentialTypeLength) { return Error{Status{ ClioError::RpcMalformedAuthorizedCredentials, std::string(key) + " greater than max length" @@ -336,12 +336,12 @@ 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 + xrpl::kMaxCredentialsArraySize ) }}; } diff --git a/src/rpc/common/Validators.hpp b/src/rpc/common/Validators.hpp index c4e053d88..5c5cccbc3 100644 --- a/src/rpc/common/Validators.hpp +++ b/src/rpc/common/Validators.hpp @@ -69,7 +69,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 @@ -79,7 +79,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) }}; } @@ -99,7 +99,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 field is found; otherwise no error is + * @return `RippledError::RpcNotSupported` if the field is found; otherwise no error is * returned */ [[nodiscard]] static MaybeError @@ -107,7 +107,7 @@ public: { if (value.is_object() and value.as_object().contains(key)) { return Error{Status{ - RippledError::rpcNOT_SUPPORTED, "Not supported field '" + std::string{key} + '\'' + RippledError::RpcNotSupported, "Not supported field '" + std::string{key} + '\'' }}; } @@ -133,7 +133,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] MaybeError @@ -146,7 +146,7 @@ struct Type final { auto const convertible = (checkTypeAndClamp(res) || ...); if (not convertible) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; return {}; } @@ -176,7 +176,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] MaybeError @@ -192,7 +192,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 {}; } @@ -220,7 +220,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] MaybeError @@ -234,7 +234,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 {}; } @@ -262,7 +262,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] MaybeError @@ -276,7 +276,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 {}; } @@ -303,7 +303,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] MaybeError @@ -332,7 +332,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] MaybeError @@ -345,7 +345,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 {}; } @@ -389,7 +389,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] MaybeError @@ -403,7 +403,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)} + Status{RippledError::RpcInvalidParams, fmt::format("Invalid field '{}'.", key)} }; } @@ -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{}; } @@ -574,7 +574,7 @@ struct CustomValidators final { static CustomValidator subscribeAccountsValidator; /** - * @brief Validates an asset (ripple::Issue). + * @brief Validates an asset (xrpl::Issue). * * Used by amm_info. */ @@ -605,7 +605,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 + * @return `RippledError::RpcInvalidParams` if validation failed; otherwise no error is * returned */ [[nodiscard]] static MaybeError @@ -618,10 +618,10 @@ 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."} + Status{RippledError::RpcInvalidParams, "Item is not a valid uint256 type."} }; } } diff --git a/src/rpc/handlers/AMMInfo.cpp b/src/rpc/handlers/AMMInfo.cpp index ddd989f02..3eb8f3002 100644 --- a/src/rpc/handlers/AMMInfo.cpp +++ b/src/rpc/handlers/AMMInfo.cpp @@ -43,7 +43,7 @@ namespace { std::string -toIso8601(ripple::NetClock::time_point tp) +toIso8601(xrpl::NetClock::time_point tp) { using namespace std::chrono; static constexpr auto kRippleEpochOffset = seconds{kRippleEpochStart}; @@ -63,19 +63,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"); @@ -96,23 +96,23 @@ 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()}, + 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; @@ -122,7 +122,7 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) 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); @@ -130,12 +130,12 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) 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(); } @@ -156,10 +156,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); @@ -181,8 +181,9 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) 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)] = @@ -234,14 +235,14 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) [](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"} + 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{}; @@ -254,34 +255,34 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) {JS(asset), meta::WithCustomError{ validation::Type{}, - Status(RippledError::rpcISSUE_MALFORMED) + Status(RippledError::RpcIssueMalformed) }, meta::IfType{kStringIssueValidator}, meta::IfType{ meta::WithCustomError{ validation::CustomValidators::currencyIssueValidator, - Status(RippledError::rpcISSUE_MALFORMED) + Status(RippledError::RpcIssueMalformed) }, }}, {JS(asset2), meta::WithCustomError{ validation::Type{}, - Status(RippledError::rpcISSUE_MALFORMED) + Status(RippledError::RpcIssueMalformed) }, meta::IfType{kStringIssueValidator}, meta::IfType{ meta::WithCustomError{ validation::CustomValidators::currencyIssueValidator, - Status(RippledError::rpcISSUE_MALFORMED) + Status(RippledError::RpcIssueMalformed) }, }}, {JS(amm_account), meta::WithCustomError{ - validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED) + validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed) }}, {JS(account), meta::WithCustomError{ - validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED) + validation::CustomValidators::accountValidator, Status(RippledError::RpcActMalformed) }}, }; diff --git a/src/rpc/handlers/AMMInfo.hpp b/src/rpc/handlers/AMMInfo.hpp index ce3d3d733..abcfea87c 100644 --- a/src/rpc/handlers/AMMInfo.hpp +++ b/src/rpc/handlers/AMMInfo.hpp @@ -51,10 +51,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 5fe65856e..c977be248 100644 --- a/src/rpc/handlers/AccountChannels.cpp +++ b/src/rpc/handlers/AccountChannels.cpp @@ -34,33 +34,33 @@ namespace rpc { void AccountChannelsHandler::addChannel( std::vector& jsonChannels, - ripple::SLE const& channelSle + 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); @@ -89,23 +89,22 @@ AccountChannelsHandler::process( auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; auto const destAccountID = input.destinationAccount ? accountFromStringStrict(*input.destinationAccount) - : 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); } @@ -127,7 +126,7 @@ AccountChannelsHandler::process( 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; diff --git a/src/rpc/handlers/AccountChannels.hpp b/src/rpc/handlers/AccountChannels.hpp index c16f5ed7f..f3b72d2c3 100644 --- a/src/rpc/handlers/AccountChannels.hpp +++ b/src/rpc/handlers/AccountChannels.hpp @@ -132,7 +132,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 fa5ae30a0..beceda730 100644 --- a/src/rpc/handlers/AccountCurrencies.cpp +++ b/src/rpc/handlers/AccountCurrencies.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -48,19 +49,19 @@ AccountCurrenciesHandler::process( auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; 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; @@ -68,11 +69,17 @@ AccountCurrenciesHandler::process( if (!viewLowest) balance.negate(); - if (balance < lineLimit) - response.receiveCurrencies.insert(ripple::to_string(balance.getCurrency())); + if (balance < lineLimit) { + response.receiveCurrencies.insert( + xrpl::to_string(balance.get().currency) + ); + } - if ((-balance) < lineLimitPeer) - response.sendCurrencies.insert(ripple::to_string(balance.getCurrency())); + if ((-balance) < lineLimitPeer) { + response.sendCurrencies.insert( + xrpl::to_string(balance.get().currency) + ); + } } return true; @@ -89,7 +96,7 @@ AccountCurrenciesHandler::process( 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 ad2470dbc..c3d8b8cb6 100644 --- a/src/rpc/handlers/AccountInfo.cpp +++ b/src/rpc/handlers/AccountInfo.cpp @@ -15,7 +15,7 @@ #include #include #include -#include +#include #include #include #include @@ -40,7 +40,7 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons if (!input.account && !input.ident) { return Error{ - Status{RippledError::rpcINVALID_PARAMS, ripple::RPC::missing_field_message(JS(account))} + Status{RippledError::RpcInvalidParams, xrpl::RPC::missingFieldMessage(JS(account))} }; } @@ -61,20 +61,20 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons auto const accountStr = input.account.value_or(input.ident.value_or("")); auto const accountID = accountFromStringStrict(accountStr); auto const accountKeylet = - ripple::keylet::account(*accountID); // NOLINT(bugprone-unchecked-optional-access) + xrpl::keylet::account(*accountID); // NOLINT(bugprone-unchecked-optional-access) 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()}, + 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); @@ -86,7 +86,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, @@ -100,21 +100,21 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons // 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); // NOLINT(bugprone-unchecked-optional-access) + xrpl::keylet::signers(*accountID); // NOLINT(bugprone-unchecked-optional-access) // 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); } @@ -137,34 +137,34 @@ tag_invoke( {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 + std::vector> const disallowIncomingFlags = { - {"disallowIncomingNFTokenOffer", ripple::lsfDisallowIncomingNFTokenOffer}, - {"disallowIncomingCheck", ripple::lsfDisallowIncomingCheck}, - {"disallowIncomingPayChan", ripple::lsfDisallowIncomingPayChan}, - {"disallowIncomingTrustline", ripple::lsfDisallowIncomingTrustline}, + {"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) @@ -172,7 +172,7 @@ tag_invoke( jv.as_object()[JS(account_flags)] = std::move(acctFlags); - auto const pseudoFields = ripple::getPseudoAccountFields(); + auto const pseudoFields = xrpl::getPseudoAccountFields(); for (auto const& pseudoField : pseudoFields) { if (output.accountData.isFieldPresent(*pseudoField)) { std::string_view name = pseudoField->fieldName; diff --git a/src/rpc/handlers/AccountInfo.hpp b/src/rpc/handlers/AccountInfo.hpp index f2ef292e2..091859b0e 100644 --- a/src/rpc/handlers/AccountInfo.hpp +++ b/src/rpc/handlers/AccountInfo.hpp @@ -39,12 +39,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 352c84158..8d0bacee6 100644 --- a/src/rpc/handlers/AccountLines.cpp +++ b/src/rpc/handlers/AccountLines.cpp @@ -33,21 +33,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; @@ -62,30 +62,29 @@ AccountLinesHandler::addLine( if (not viewLowest) balance.negate(); - bool const lineAuth = (flags & (viewLowest ? ripple::lsfLowAuth : ripple::lsfHighAuth)) != 0u; + bool const lineAuth = (flags & (viewLowest ? xrpl::lsfLowAuth : xrpl::lsfHighAuth)) != 0u; bool const lineAuthPeer = - (flags & (not viewLowest ? ripple::lsfLowAuth : ripple::lsfHighAuth)) != 0u; + (flags & (not viewLowest ? xrpl::lsfLowAuth : xrpl::lsfHighAuth)) != 0u; bool const lineNoRipple = - (flags & (viewLowest ? ripple::lsfLowNoRipple : ripple::lsfHighNoRipple)) != 0u; + (flags & (viewLowest ? xrpl::lsfLowNoRipple : xrpl::lsfHighNoRipple)) != 0u; bool const lineNoRipplePeer = - (flags & (not viewLowest ? ripple::lsfLowNoRipple : ripple::lsfHighNoRipple)) != 0u; - bool const lineFreeze = - (flags & (viewLowest ? ripple::lsfLowFreeze : ripple::lsfHighFreeze)) != 0u; + (flags & (not viewLowest ? xrpl::lsfLowNoRipple : xrpl::lsfHighNoRipple)) != 0u; + bool const lineFreeze = (flags & (viewLowest ? xrpl::lsfLowFreeze : xrpl::lsfHighFreeze)) != 0u; bool const lineFreezePeer = - (flags & (not viewLowest ? ripple::lsfLowFreeze : ripple::lsfHighFreeze)) != 0u; + (flags & (not viewLowest ? xrpl::lsfLowFreeze : xrpl::lsfHighFreeze)) != 0u; bool const lineDeepFreeze = - (flags & (viewLowest ? ripple::lsfLowDeepFreeze : ripple::lsfHighDeepFreeze)) != 0u; + (flags & (viewLowest ? xrpl::lsfLowDeepFreeze : xrpl::lsfHighDeepFreeze)) != 0u; bool const lineDeepFreezePeer = - (flags & (not viewLowest ? ripple::lsfLowDeepFreeze : ripple::lsfHighDeepFreeze)) != 0u; + (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; @@ -138,28 +137,28 @@ AccountLinesHandler::process(AccountLinesHandler::Input const& input, Context co auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (not accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; auto const peerAccountID = - input.peer ? accountFromStringStrict(*(input.peer)) : std::optional{}; + 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); } } @@ -186,7 +185,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 4a6d00fae..5bfd3cc12 100644 --- a/src/rpc/handlers/AccountLines.hpp +++ b/src/rpc/handlers/AccountLines.hpp @@ -114,12 +114,12 @@ public: validation::Required{}, meta::WithCustomError{ validation::CustomValidators::accountValidator, - Status(RippledError::rpcACT_MALFORMED) + Status(RippledError::RpcActMalformed) }}, {JS(peer), meta::WithCustomError{ validation::CustomValidators::accountValidator, - Status(RippledError::rpcACT_MALFORMED) + Status(RippledError::RpcActMalformed) }}, {JS(ignore_default), validation::Type{}}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, @@ -150,9 +150,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 edb1e06ac..27d5c8e0b 100644 --- a/src/rpc/handlers/AccountMPTokenIssuances.cpp +++ b/src/rpc/handlers/AccountMPTokenIssuances.cpp @@ -31,68 +31,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); } @@ -120,19 +120,19 @@ AccountMPTokenIssuancesHandler::process( auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + 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); } }; @@ -155,7 +155,7 @@ AccountMPTokenIssuancesHandler::process( 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 33cf16d89..1ba32f7e4 100644 --- a/src/rpc/handlers/AccountMPTokenIssuances.hpp +++ b/src/rpc/handlers/AccountMPTokenIssuances.hpp @@ -123,7 +123,7 @@ public: validation::Required{}, meta::WithCustomError{ validation::CustomValidators::accountValidator, - Status(RippledError::rpcACT_MALFORMED) + Status(RippledError::RpcActMalformed) }}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(limit), @@ -152,8 +152,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 9356b10ca..d46cf565c 100644 --- a/src/rpc/handlers/AccountMPTokens.cpp +++ b/src/rpc/handlers/AccountMPTokens.cpp @@ -30,26 +30,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); } @@ -77,19 +77,19 @@ AccountMPTokensHandler::process( auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + 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); } }; @@ -112,7 +112,7 @@ AccountMPTokensHandler::process( 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 8513ebcad..c7d3a5246 100644 --- a/src/rpc/handlers/AccountMPTokens.hpp +++ b/src/rpc/handlers/AccountMPTokens.hpp @@ -101,7 +101,7 @@ public: validation::Required{}, meta::WithCustomError{ validation::CustomValidators::accountValidator, - Status(RippledError::rpcACT_MALFORMED) + Status(RippledError::RpcActMalformed) }}, {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator}, {JS(limit), @@ -128,7 +128,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 2ad1ab842..362423f6b 100644 --- a/src/rpc/handlers/AccountNFTs.cpp +++ b/src/rpc/handlers/AccountNFTs.cpp @@ -50,69 +50,69 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; 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()} + auto const pageKey = input.marker ? xrpl::uint256{input.marker->c_str()} // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - : ripple::keylet::nftpage_max(*accountID).key; + : 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" + 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) { + if (page->getType() != xrpl::ltNFTOKEN_PAGE) { return Error{ - Status{RippledError::rpcINVALID_PARAMS, "Marker matches Page ID from another Account"} + 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; @@ -122,7 +122,7 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons sharedPtrBackend_->fetchLedgerObject(nextKey.key, lgrInfo.seq, ctx.yield); page.emplace( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::SLE{ripple::SerialIter{nextBlob->data(), nextBlob->size()}, nextKey.key} + 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 ed0dcae85..183ebd4e1 100644 --- a/src/rpc/handlers/AccountObjects.cpp +++ b/src/rpc/handlers/AccountObjects.cpp @@ -51,15 +51,15 @@ AccountObjectsHandler::process(AccountObjectsHandler::Input const& input, Contex auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; - auto typeFilter = std::optional>{}; + auto typeFilter = std::optional>{}; if (input.deletionBlockersOnly) { typeFilter.emplace(); @@ -73,12 +73,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), std::end(*typeFilter), sle.getType()) != std::end(*typeFilter)) { @@ -101,7 +101,7 @@ AccountObjectsHandler::process(AccountObjectsHandler::Input const& input, Contex if (not 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 46b855812..da51a4391 100644 --- a/src/rpc/handlers/AccountObjects.hpp +++ b/src/rpc/handlers/AccountObjects.hpp @@ -47,7 +47,7 @@ public: uint32_t ledgerIndex{}; std::optional marker; uint32_t limit{}; - std::vector accountObjects; + std::vector accountObjects; bool validated = true; }; @@ -60,7 +60,7 @@ public: std::optional ledgerIndex; uint32_t limit = kLimitDefault; // [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 a5531d810..09abb815d 100644 --- a/src/rpc/handlers/AccountOffers.cpp +++ b/src/rpc/handlers/AccountOffers.cpp @@ -29,20 +29,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); }; @@ -67,21 +67,21 @@ AccountOffersHandler::process(AccountOffersHandler::Input const& input, Context auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; Output response; - response.account = ripple::to_string(*accountID); // NOLINT(bugprone-unchecked-optional-access) - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.account = xrpl::to_string(*accountID); // NOLINT(bugprone-unchecked-optional-access) + 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; @@ -145,13 +145,13 @@ tag_invoke( 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 07506846b..990f02b0f 100644 --- a/src/rpc/handlers/AccountOffers.hpp +++ b/src/rpc/handlers/AccountOffers.hpp @@ -41,8 +41,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; }; @@ -120,7 +120,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 de28825c1..720529438 100644 --- a/src/rpc/handlers/AccountTx.cpp +++ b/src/rpc/handlers/AccountTx.cpp @@ -46,7 +46,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c range->maxSequence || // NOLINT(bugprone-unchecked-optional-access) input.ledgerIndexMin < range->minSequence)) { // NOLINT(bugprone-unchecked-optional-access) - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMinOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMinOutOfRange"}}; } if (static_cast(*input.ledgerIndexMin) > minIndex) @@ -59,7 +59,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c range->maxSequence || // NOLINT(bugprone-unchecked-optional-access) input.ledgerIndexMax < range->minSequence)) { // NOLINT(bugprone-unchecked-optional-access) - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMaxOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMaxOutOfRange"}}; } if (static_cast(*input.ledgerIndexMax) < maxIndex) @@ -68,16 +68,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) { @@ -188,8 +186,8 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c 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; @@ -205,7 +203,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c } response.limit = input.limit; - response.account = ripple::to_string(*accountID); // NOLINT(bugprone-unchecked-optional-access) + response.account = xrpl::to_string(*accountID); // NOLINT(bugprone-unchecked-optional-access) response.ledgerIndexMin = minIndex; response.ledgerIndexMax = maxIndex; diff --git a/src/rpc/handlers/AccountTx.hpp b/src/rpc/handlers/AccountTx.hpp index bfb579469..d21cf5814 100644 --- a/src/rpc/handlers/AccountTx.hpp +++ b/src/rpc/handlers/AccountTx.hpp @@ -127,7 +127,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 d9012f6cf..70d561543 100644 --- a/src/rpc/handlers/BookChanges.cpp +++ b/src/rpc/handlers/BookChanges.cpp @@ -45,7 +45,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(); @@ -91,7 +91,7 @@ tag_invoke(boost::json::value_to_tag, boost::json::va [[nodiscard]] boost::json::object computeBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) { diff --git a/src/rpc/handlers/BookOffers.cpp b/src/rpc/handlers/BookOffers.cpp index 3522ac5e9..af8b72f94 100644 --- a/src/rpc/handlers/BookOffers.cpp +++ b/src/rpc/handlers/BookOffers.cpp @@ -56,12 +56,12 @@ BookOffersHandler::process(Input const& input, Context const& ctx) const 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, @@ -91,24 +91,24 @@ 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 597ae77d5..8d0937279 100644 --- a/src/rpc/handlers/BookOffers.hpp +++ b/src/rpc/handlers/BookOffers.hpp @@ -61,12 +61,12 @@ public: std::optional ledgerHash; std::optional ledgerIndex; uint32_t limit = kLimitDefault; - 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; }; @@ -104,12 +104,12 @@ public: validation::Required{}, meta::WithCustomError{ validation::CustomValidators::currencyValidator, - Status(RippledError::rpcDST_AMT_MALFORMED) + Status(RippledError::RpcDstAmtMalformed) }}, {JS(issuer), meta::WithCustomError{ validation::CustomValidators::issuerValidator, - Status(RippledError::rpcDST_ISR_MALFORMED) + Status(RippledError::RpcDstIsrMalformed) }} }}, {JS(taker_pays), @@ -120,28 +120,28 @@ public: validation::Required{}, meta::WithCustomError{ validation::CustomValidators::currencyValidator, - Status(RippledError::rpcSRC_CUR_MALFORMED) + Status(RippledError::RpcSrcCurMalformed) }}, {JS(issuer), meta::WithCustomError{ validation::CustomValidators::issuerValidator, - Status(RippledError::rpcSRC_ISR_MALFORMED) + 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.") + 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 c29354cbf..e07fb503d 100644 --- a/src/rpc/handlers/DepositAuthorized.cpp +++ b/src/rpc/handlers/DepositAuthorized.cpp @@ -55,40 +55,40 @@ DepositAuthorizedHandler::process( auto const srcAccountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*sourceAccountID).key, + 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"}}; // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - 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}; + auto it = xrpl::SerialIter{dstAccountLedgerObject->data(), dstAccountLedgerObject->size()}; + auto const sleDest = xrpl::SLE{it, dstKeylet}; bool const reqAuth = - sleDest.isFlag(ripple::lsfDepositAuth) && (sourceAccountID != destinationAccountID); + 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->empty()) { return Error{ - Status{RippledError::rpcINVALID_PARAMS, "credential array has no elements."} + Status{RippledError::RpcInvalidParams, "credential array has no elements."} }; } - if (creds->size() > ripple::maxCredentialsArraySize) { - return Error{Status{RippledError::rpcINVALID_PARAMS, "credential array too long."}}; + if (creds->size() > xrpl::kMaxCredentialsArraySize) { + return Error{Status{RippledError::RpcInvalidParams, "credential array too long."}}; } auto const credArray = credentials::fetchCredentialArray( input.credentials, @@ -107,7 +107,7 @@ DepositAuthorizedHandler::process( bool depositAuthorized = true; if (reqAuth) { - ripple::uint256 hashKey; + xrpl::uint256 hashKey; if (credentialsPresent) { auto const sortedAuthCreds = credentials::createAuthCredentials(authCreds); ASSERT( @@ -116,10 +116,10 @@ DepositAuthorizedHandler::process( ); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - hashKey = ripple::keylet::depositPreauth(*destinationAccountID, sortedAuthCreds).key; + hashKey = xrpl::keylet::depositPreauth(*destinationAccountID, sortedAuthCreds).key; } else { // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - hashKey = ripple::keylet::depositPreauth(*destinationAccountID, *sourceAccountID).key; + hashKey = xrpl::keylet::depositPreauth(*destinationAccountID, *sourceAccountID).key; } depositAuthorized = @@ -128,7 +128,7 @@ DepositAuthorizedHandler::process( 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 6031dbbf8..f9821e5e9 100644 --- a/src/rpc/handlers/Feature.cpp +++ b/src/rpc/handlers/Feature.cpp @@ -56,7 +56,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 or feature.name == *search; + return xrpl::to_string(feature.feature) == *search or feature.name == *search; } return true; }; @@ -66,14 +66,14 @@ FeatureHandler::process(FeatureHandler::Input const& input, Context const& ctx) 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 and feature.isSupportedByXRPL, }; } ); 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) { @@ -93,7 +93,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() }; @@ -108,7 +108,7 @@ FeatureHandler::spec([[maybe_unused]] uint32_t apiVersion) meta::WithCustomError{ validation::NotSupported{}, Status( - RippledError::rpcNO_PERMISSION, + RippledError::RpcNoPermission, "The admin portion of feature API is not available through Clio." ) }}, diff --git a/src/rpc/handlers/GatewayBalances.cpp b/src/rpc/handlers/GatewayBalances.cpp index 6509382ad..e9585d2be 100644 --- a/src/rpc/handlers/GatewayBalances.cpp +++ b/src/rpc/handlers/GatewayBalances.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include #include @@ -62,21 +63,21 @@ GatewayBalancesHandler::process( auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*accountID).key, + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; 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 { @@ -87,28 +88,28 @@ GatewayBalancesHandler::process( // 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(); @@ -133,16 +134,18 @@ GatewayBalancesHandler::process( 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 ); } } @@ -167,7 +170,7 @@ GatewayBalancesHandler::process( 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,31 +187,30 @@ tag_invoke( 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) { - boost::json::object balancesObj; + auto const toJson = [](std::map> const& balances) { + boost::json::object balancesObj; - if (not balances.empty()) { - for (auto const& [accId, accBalances] : balances) { - boost::json::array arr; - for (auto const& balance : accBalances) { - boost::json::object entry; - entry[JS(currency)] = ripple::to_string(balance.issue().currency); - entry[JS(value)] = balance.getText(); - arr.push_back(std::move(entry)); - } - - balancesObj[ripple::to_string(accId)] = std::move(arr); + if (not balances.empty()) { + for (auto const& [accId, accBalances] : balances) { + boost::json::array arr; + for (auto const& balance : accBalances) { + boost::json::object entry; + entry[JS(currency)] = xrpl::to_string(balance.get().currency); + entry[JS(value)] = balance.getText(); + arr.push_back(std::move(entry)); } - } - return balancesObj; - }; + balancesObj[xrpl::to_string(accId)] = std::move(arr); + } + } + + return balancesObj; + }; if (auto balances = toJson(output.hotBalances); !balances.empty()) obj[JS(balances)] = balances; @@ -224,7 +226,7 @@ tag_invoke( 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 0c8707891..65b6e4405 100644 --- a/src/rpc/handlers/GatewayBalances.hpp +++ b/src/rpc/handlers/GatewayBalances.hpp @@ -50,11 +50,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; }; @@ -64,7 +64,7 @@ public: */ struct Input { std::string account; - std::set hotWallets; + std::set hotWallets; std::optional ledgerHash; std::optional ledgerIndex; }; @@ -99,18 +99,17 @@ 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, + 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( + return util::parseBase58Wrapper( boost::json::value_to(j) ); } @@ -135,11 +134,10 @@ public: }; static auto const kSpecV1 = RpcSpec{ - kSpecCommon, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_HOTWALLET)}} - }; - static auto const kSpecV2 = RpcSpec{ - kSpecCommon, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_PARAMS)}} + kSpecCommon, {{JS(hotwallet), getHotWalletValidator(xrpl::RpcInvalidHotwallet)}} }; + static auto const kSpecV2 = + RpcSpec{kSpecCommon, {{JS(hotwallet), getHotWalletValidator(xrpl::RpcInvalidParams)}}}; return apiVersion == 1 ? kSpecV1 : kSpecV2; } diff --git a/src/rpc/handlers/GetAggregatePrice.cpp b/src/rpc/handlers/GetAggregatePrice.cpp index 2f2261856..0b8cc519a 100644 --- a/src/rpc/handlers/GetAggregatePrice.cpp +++ b/src/rpc/handlers/GetAggregatePrice.cpp @@ -64,47 +64,46 @@ GetAggregatePriceHandler::process( // 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() == + [&](xrpl::STObject const& o) -> bool { + return o.getFieldCurrency(xrpl::sfBaseAsset).getText() == input.baseAsset and - o.getFieldCurrency(ripple::sfQuoteAsset).getText() == - input.quoteAsset and - o.isFieldPresent(ripple::sfAssetPrice); + 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)) + auto const scale = 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; @@ -114,14 +113,14 @@ GetAggregatePriceHandler::process( } 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 = "" }; @@ -141,15 +140,15 @@ GetAggregatePriceHandler::process( 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) { + avg = std::accumulate(begin, end, avg, [&](xrpl::STAmount const& acc, auto const& it) { return acc + it.first; }); - avg = divide(avg, ripple::STAmount{ripple::noIssue(), size, 0}, ripple::noIssue()); + 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)); @@ -178,11 +177,11 @@ GetAggregatePriceHandler::process( 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; }(); @@ -194,14 +193,14 @@ GetAggregatePriceHandler::process( 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 kHistoryMax = 3; - std::optional optOracleObject = oracleObject; - std::optional optCurrentObject = optOracleObject; + std::optional optOracleObject = oracleObject; + std::optional optCurrentObject = optOracleObject; bool isNew = false; bool noOracleFound = false; @@ -219,7 +218,7 @@ GetAggregatePriceHandler::tracebackOracleObject( if (++history > kHistoryMax) 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) @@ -228,13 +227,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 @@ -243,8 +242,8 @@ GetAggregatePriceHandler::tracebackOracleObject( return; optOracleObject = isNew - ? dynamic_cast(node.peekAtField(ripple::sfNewFields)) - : dynamic_cast(node.peekAtField(ripple::sfFinalFields)); + ? dynamic_cast(node.peekAtField(xrpl::sfNewFields)) + : dynamic_cast(node.peekAtField(xrpl::sfFinalFields)); break; } @@ -273,7 +272,7 @@ tag_invoke(boost::json::value_to_tag, boost::js oracle.as_object().at(JS(oracle_document_id)) ), // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - .account = *util::parseBase58Wrapper( + .account = *util::parseBase58Wrapper( boost::json::value_to(oracle.as_object().at(JS(account))) ) } @@ -306,7 +305,7 @@ tag_invoke( {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} @@ -315,7 +314,7 @@ tag_invoke( 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 65cf676aa..682e2ca56 100644 --- a/src/rpc/handlers/GetAggregatePrice.hpp +++ b/src/rpc/handlers/GetAggregatePrice.hpp @@ -39,9 +39,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}; }; @@ -63,7 +63,7 @@ public: */ struct Oracle { std::uint32_t documentId{0}; - ripple::AccountID account; + xrpl::AccountID account; }; /** @@ -106,13 +106,13 @@ public: [](boost::json::value& value, std::string_view) -> MaybeError { if (!value.is_array() or value.as_array().empty() or value.as_array().size() > kOraclesMax) - 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) @@ -128,7 +128,7 @@ public: oracle.as_object(), JS(account) ); if (!maybeError) - return Error{Status{RippledError::rpcINVALID_PARAMS}}; + return Error{Status{RippledError::RpcInvalidParams}}; }; return MaybeError{}; @@ -147,13 +147,13 @@ public: validation::Required{}, meta::WithCustomError{ validation::CustomValidators::currencyValidator, - Status(RippledError::rpcINVALID_PARAMS) + Status(RippledError::RpcInvalidParams) }}, {JS(quote_asset), validation::Required{}, meta::WithCustomError{ validation::CustomValidators::currencyValidator, - Status(RippledError::rpcINVALID_PARAMS) + Status(RippledError::RpcInvalidParams) }}, {JS(oracles), validation::Required{}, kOraclesValidator}, // note: Unlike `rippled`, Clio only supports UInt as input, no string, no `null`, etc. @@ -187,8 +187,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 7e3f0d2ff..9c3eee428 100644 --- a/src/rpc/handlers/Ledger.cpp +++ b/src/rpc/handlers/Ledger.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include #include @@ -67,7 +68,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); @@ -82,7 +83,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)); @@ -109,10 +110,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 @@ -122,7 +123,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 @@ -141,7 +142,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)); } ); } } @@ -154,13 +155,13 @@ 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 { @@ -171,7 +172,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 8753b936b..9a05caa40 100644 --- a/src/rpc/handlers/LedgerData.cpp +++ b/src/rpc/handlers/LedgerData.cpp @@ -38,10 +38,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"); @@ -67,10 +67,10 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const } 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(); @@ -79,7 +79,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()) @@ -109,7 +109,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; // NOLINT(bugprone-unchecked-optional-access) } @@ -123,14 +123,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)); @@ -198,9 +198,8 @@ 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 80881fbca..f6f434b7f 100644 --- a/src/rpc/handlers/LedgerData.hpp +++ b/src/rpc/handlers/LedgerData.hpp @@ -65,10 +65,10 @@ public: std::optional ledgerIndex; bool binary = false; uint32_t limit = LedgerDataHandler::kLimitJson; // 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 66ecde42e..775dca345 100644 --- a/src/rpc/handlers/LedgerEntry.cpp +++ b/src/rpc/handlers/LedgerEntry.cpp @@ -42,21 +42,21 @@ 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( + key = xrpl::keylet::account( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *util::parseBase58Wrapper(*(input.accountRoot)) + *util::parseBase58Wrapper(*(input.accountRoot)) ) .key; } else if (input.did) { // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - 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()) @@ -64,41 +64,40 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons key = expectedkey.value(); // std::expected, not optional } else if (input.offer) { - auto const id = util::parseBase58Wrapper( + auto const id = util::parseBase58Wrapper( boost::json::value_to(input.offer->at(JS(account))) ); // NOLINTBEGIN(bugprone-unchecked-optional-access) - key = ripple::keylet::offer( - *id, boost::json::value_to(input.offer->at(JS(seq))) - ) - .key; + key = + xrpl::keylet::offer(*id, boost::json::value_to(input.offer->at(JS(seq)))) + .key; // NOLINTEND(bugprone-unchecked-optional-access) } else if (input.rippleStateAccount) { auto const id1 = - util::parseBase58Wrapper(boost::json::value_to( + util::parseBase58Wrapper(boost::json::value_to( input.rippleStateAccount->at(JS(accounts)).as_array().at(0) )); auto const id2 = - util::parseBase58Wrapper(boost::json::value_to( + util::parseBase58Wrapper(boost::json::value_to( input.rippleStateAccount->at(JS(accounts)).as_array().at(1) )); - auto const currency = ripple::to_currency( + auto const currency = xrpl::toCurrency( boost::json::value_to(input.rippleStateAccount->at(JS(currency))) ); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - 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( + auto const id = util::parseBase58Wrapper( boost::json::value_to(input.escrow->at(JS(owner))) ); key = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::escrow(*id, util::integralValueAs(input.escrow->at(JS(seq)))) + 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,11 +110,11 @@ 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))) ); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - 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() @@ -129,14 +128,14 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons } // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - key = ripple::keylet::depositPreauth(*owner, authCreds).key; + key = xrpl::keylet::depositPreauth(*owner, 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( + key = xrpl::getTicketIndex( *id, // NOLINT(bugprone-unchecked-optional-access) util::integralValueAs(input.ticket->at(JS(ticket_seq))) ); @@ -144,17 +143,17 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons 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(); + xrpl::toCurrency(boost::json::value_to(assetJson.at(JS(currency)))); + if (xrpl::isXRP(currency)) { + return xrpl::xrpIssue(); } - auto const issuer = util::parseBase58Wrapper( + auto const issuer = util::parseBase58Wrapper( boost::json::value_to(assetJson.at(JS(issuer))) ); - return ripple::Issue{currency, *issuer}; + return xrpl::Issue{currency, *issuer}; }; - key = ripple::keylet::amm( + key = xrpl::keylet::amm( getIssuerFromJson(input.amm->at(JS(asset))), getIssuerFromJson(input.amm->at(JS(asset2))) ) @@ -165,18 +164,18 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons if (input.bridgeAccount) { auto const bridgeAccount = - util::parseBase58Wrapper(*(input.bridgeAccount)); + util::parseBase58Wrapper(*(input.bridgeAccount)); auto const chainType = - ripple::STXChainBridge::srcChain(bridgeAccount == input.bridge->lockingChainDoor()); + 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).key; + key = xrpl::keylet::xChainClaimID(input.bridge->value(), *input.chainClaimId).key; } else { - key = ripple::keylet::xChainCreateAccountClaimID( + key = xrpl::keylet::xChainCreateAccountClaimID( input.bridge->value(), *input.createAccountClaimId ) .key; @@ -186,58 +185,58 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons } else if (input.credential) { key = *input.credential; } 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( + auto const holder = xrpl::parseBase58( boost::json::value_to(input.mptoken->at(JS(account))) ); - auto const mptIssuanceID = ripple::uint192{std::string_view( + auto const mptIssuanceID = xrpl::uint192{std::string_view( boost::json::value_to(input.mptoken->at(JS(mpt_issuance_id))) )}; // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - key = ripple::keylet::mptoken(mptIssuanceID, *holder).key; + 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))); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - key = ripple::keylet::permissionedDomain(*account, seq).key; + key = xrpl::keylet::permissionedDomain(*account, seq).key; } else if (input.vault) { - auto const account = ripple::parseBase58( + auto const account = xrpl::parseBase58( boost::json::value_to(input.vault->at(JS(owner))) ); auto const seq = util::integralValueAs(input.vault->at(JS(seq))); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - key = ripple::keylet::vault(*account, seq).key; + key = xrpl::keylet::vault(*account, seq).key; } else if (input.loanBroker) { - auto const account = ripple::parseBase58( + auto const account = xrpl::parseBase58( boost::json::value_to(input.loanBroker->at(JS(owner))) ); auto const seq = util::integralValueAs(input.loanBroker->at(JS(seq))); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - key = ripple::keylet::loanbroker(*account, seq).key; + key = xrpl::keylet::loanbroker(*account, seq).key; } else if (input.loan) { - auto const id = ripple::uint256{ + auto const id = xrpl::uint256{ boost::json::value_to(input.loan->at(JS(loan_broker_id))).data() }; auto const seq = util::integralValueAs(input.loan->at(JS(loan_seq))); - key = ripple::keylet::loan(id, seq).key; + key = xrpl::keylet::loan(id, seq).key; } else if (input.delegate) { - auto const account = ripple::parseBase58( + auto const account = xrpl::parseBase58( boost::json::value_to(input.delegate->at(JS(account))) ); - auto const authorize = ripple::parseBase58( + auto const authorize = xrpl::parseBase58( boost::json::value_to(input.delegate->at(JS(authorize))) ); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - key = ripple::keylet::delegate(*account, *authorize).key; + 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 @@ -260,30 +259,30 @@ 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 - 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); } @@ -291,36 +290,36 @@ 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"} + 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{ + xrpl::uint256 const uDirRoot{ boost::json::value_to(directory.at(JS(dir_root))).data() }; - return ripple::keylet::page(uDirRoot, subIndex).key; + return xrpl::keylet::page(uDirRoot, subIndex).key; } - auto const ownerID = util::parseBase58Wrapper( + auto const ownerID = util::parseBase58Wrapper( boost::json::value_to(directory.at(JS(owner))) ); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - return ripple::keylet::page(ripple::keylet::ownerDir(*ownerID), subIndex).key; + return xrpl::keylet::page(xrpl::keylet::ownerDir(*ownerID), subIndex).key; } void @@ -368,75 +367,73 @@ 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 kIndexFieldTypeMap = 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(loan_broker), ripple::ltLOAN_BROKER}, - {JS(loan), ripple::ltLOAN}, - {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 kIndexFieldTypeMap = 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(loan_broker), xrpl::ltLOAN_BROKER}, + {JS(loan), xrpl::ltLOAN}, + {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()) + *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()) + *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( + auto const 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( + auto const subject = util::parseBase58Wrapper( boost::json::value_to(json.at(JS(subject))) ); - auto const issuer = util::parseBase58Wrapper( + 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)))); + xrpl::strUnHex(boost::json::value_to(json.at(JS(credential_type)))); - return ripple::keylet::credential( - *subject, *issuer, ripple::Slice(credType->data(), credType->size()) + return xrpl::keylet::credential( + *subject, *issuer, xrpl::Slice(credType->data(), credType->size()) ) .key; }; diff --git a/src/rpc/handlers/LedgerEntry.hpp b/src/rpc/handlers/LedgerEntry.hpp index b6e4df945..8eaa33da0 100644 --- a/src/rpc/handlers/LedgerEntry.hpp +++ b/src/rpc/handlers/LedgerEntry.hpp @@ -69,7 +69,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 @@ -89,12 +89,12 @@ public: std::optional vault; std::optional loanBroker; std::optional loan; - 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; }; @@ -128,13 +128,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( + auto const id1 = util::parseBase58Wrapper( boost::json::value_to(value.as_array()[0]) ); - auto const id2 = util::parseBase58Wrapper( + auto const id2 = util::parseBase58Wrapper( boost::json::value_to(value.as_array()[1]) ); @@ -156,16 +156,16 @@ public: static auto const kBridgeJsonValidator = 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}, }}, @@ -566,7 +566,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 794395b27..0315b242b 100644 --- a/src/rpc/handlers/LedgerIndex.cpp +++ b/src/rpc/handlers/LedgerIndex.cpp @@ -32,8 +32,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) }; }; @@ -57,7 +57,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 57a61f837..041ba9f47 100644 --- a/src/rpc/handlers/MPTHolders.cpp +++ b/src/rpc/handlers/MPTHolders.cpp @@ -11,20 +11,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 { @@ -46,17 +46,17 @@ MPTHoldersHandler::process(MPTHoldersHandler::Input const& input, Context const& auto const& lgrInfo = *expectedLgrInfo; auto const limit = input.limit.value_or(MPTHoldersHandler::kLimitDefault); - 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 + 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); @@ -67,20 +67,20 @@ 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 + xrpl::STUInt64{xrpl::sfMPTAmount, sle[xrpl::sfMPTAmount]}.getJson( + JsonOptions::Values::None ) ); mptJson["mptoken_index"] = - ripple::to_string(ripple::keylet::mptoken(mptID, sle[ripple::sfAccount]).key); + 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 404525878..481c26da0 100644 --- a/src/rpc/handlers/NFTBuyOffers.cpp +++ b/src/rpc/handlers/NFTBuyOffers.cpp @@ -5,7 +5,7 @@ #include #include -using namespace ripple; +using namespace xrpl; namespace rpc { @@ -13,7 +13,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 86dc883cd..51a1f1791 100644 --- a/src/rpc/handlers/NFTHistory.cpp +++ b/src/rpc/handlers/NFTHistory.cpp @@ -42,7 +42,7 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& if (input.ledgerIndexMin) { // NOLINTBEGIN(bugprone-unchecked-optional-access) if (range->maxSequence < input.ledgerIndexMin || range->minSequence > input.ledgerIndexMin) - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMinOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMinOutOfRange"}}; // NOLINTEND(bugprone-unchecked-optional-access) minIndex = *input.ledgerIndexMin; @@ -51,21 +51,19 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& if (input.ledgerIndexMax) { // NOLINTBEGIN(bugprone-unchecked-optional-access) if (range->maxSequence < input.ledgerIndexMax || range->minSequence > input.ledgerIndexMax) - return Error{Status{RippledError::rpcLGR_IDX_MALFORMED, "ledgerSeqMaxOutOfRange"}}; + return Error{Status{RippledError::RpcLgrIdxMalformed, "ledgerSeqMaxOutOfRange"}}; // NOLINTEND(bugprone-unchecked-optional-access) 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( @@ -96,7 +94,7 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& } auto const limit = input.limit.value_or(kLimitDefault); - 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( @@ -143,8 +141,8 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& 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 { @@ -158,7 +156,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 2fca709ef..a4eba808d 100644 --- a/src/rpc/handlers/NFTHistory.hpp +++ b/src/rpc/handlers/NFTHistory.hpp @@ -118,7 +118,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/NFTInfo.cpp b/src/rpc/handlers/NFTInfo.cpp index 6b09c8887..d2f84c4b9 100644 --- a/src/rpc/handlers/NFTInfo.cpp +++ b/src/rpc/handlers/NFTInfo.cpp @@ -20,14 +20,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"); @@ -46,7 +46,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 43fff643a..d4aa09e3f 100644 --- a/src/rpc/handlers/NFTOffersCommon.cpp +++ b/src/rpc/handlers/NFTOffersCommon.cpp @@ -32,16 +32,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())}, @@ -59,15 +59,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 { @@ -89,10 +89,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}; @@ -112,12 +112,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 { @@ -133,8 +133,8 @@ NFTOffersHandlerBase::iterateOfferDirectory( lgrInfo.seq, reserve, yield, - [&offers](ripple::SLE&& offer) { - if (offer.getType() == ripple::ltNFTOKEN_OFFER) { + [&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 993195737..d933febbc 100644 --- a/src/rpc/handlers/NFTOffersCommon.hpp +++ b/src/rpc/handlers/NFTOffersCommon.hpp @@ -39,7 +39,7 @@ public: */ struct Output { std::string nftID; - std::vector offers; + std::vector offers; // validated should be sent via framework bool validated = true; @@ -108,8 +108,8 @@ protected: [[nodiscard]] 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 df2762600..0d46330e8 100644 --- a/src/rpc/handlers/NFTSellOffers.cpp +++ b/src/rpc/handlers/NFTSellOffers.cpp @@ -5,7 +5,7 @@ #include #include -using namespace ripple; +using namespace xrpl; namespace rpc { @@ -13,7 +13,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 f797ba7bf..38535be42 100644 --- a/src/rpc/handlers/NFTsByIssuer.cpp +++ b/src/rpc/handlers/NFTsByIssuer.cpp @@ -23,7 +23,7 @@ #include #include -using namespace ripple; +using namespace xrpl; namespace rpc { @@ -50,13 +50,13 @@ NFTsByIssuerHandler::process(NFTsByIssuerHandler::Input const& input, Context co auto const issuer = accountFromStringStrict(input.issuer); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::account(*issuer).key, + xrpl::keylet::account(*issuer).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; std::optional cursor; if (input.marker) diff --git a/src/rpc/handlers/NoRippleCheck.cpp b/src/rpc/handlers/NoRippleCheck.cpp index acf6c9e55..10d3dd091 100644 --- a/src/rpc/handlers/NoRippleCheck.cpp +++ b/src/rpc/handlers/NoRippleCheck.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -56,16 +57,16 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context auto const& lgrInfo = *expectedLgrInfo; auto const accountID = accountFromStringStrict(input.account); auto const keylet = - ripple::keylet::account(*accountID).key; // NOLINT(bugprone-unchecked-optional-access) + xrpl::keylet::account(*accountID).key; // NOLINT(bugprone-unchecked-optional-access) auto const accountObj = sharedPtrBackend_->fetchLedgerObject(keylet, lgrInfo.seq, ctx.yield); if (!accountObj) - return Error{Status{RippledError::rpcACT_NOT_FOUND}}; + return Error{Status{RippledError::RpcActNotFound}}; - 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; @@ -74,10 +75,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; @@ -96,7 +97,7 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context auto tx = getBaseTx(*accountID, accountSeq++); // NOLINT(bugprone-unchecked-optional-access) tx[JS(TransactionType)] = "AccountSet"; - tx[JS(SetFlag)] = ripple::asfDefaultRipple; + tx[JS(SetFlag)] = xrpl::asfDefaultRipple; output.transactions->push_back(tx); } } @@ -110,15 +111,15 @@ 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) { + if (limit != 0 && ownedItem.getType() == xrpl::ltRIPPLE_STATE) { bool const bLow = - accountID == ownedItem.getFieldAmount(ripple::sfLowLimit).getIssuer(); + accountID == ownedItem.getFieldAmount(xrpl::sfLowLimit).getIssuer(); bool const bNoRipple = - (ownedItem.getFieldU32(ripple::sfFlags) & - (bLow ? ripple::lsfLowNoRipple : ripple::lsfHighNoRipple)) != 0u; + (ownedItem.getFieldU32(xrpl::sfFlags) & + (bLow ? xrpl::lsfLowNoRipple : xrpl::lsfHighNoRipple)) != 0u; std::string problem; bool needFix = false; @@ -132,31 +133,33 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context if (needFix) { --limit; - ripple::AccountID const peer = - ownedItem.getFieldAmount(bLow ? ripple::sfHighLimit : ripple::sfLowLimit) + xrpl::AccountID const peer = + ownedItem.getFieldAmount(bLow ? xrpl::sfHighLimit : xrpl::sfLowLimit) .getIssuer(); - ripple::STAmount const peerLimit = - ownedItem.getFieldAmount(bLow ? ripple::sfHighLimit : ripple::sfLowLimit); + xrpl::STAmount const peerLimit = + ownedItem.getFieldAmount(bLow ? xrpl::sfHighLimit : xrpl::sfLowLimit); problem += fmt::format( "{} line to {}", - to_string(peerLimit.getCurrency()), + 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 - )); - limitAmount.setIssuer(peer); + xrpl::STAmount limitAmount( + ownedItem.getFieldAmount(bLow ? xrpl::sfLowLimit : xrpl::sfHighLimit) + ); + 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; + toBoostJson(limitAmount.getJson(xrpl::JsonOptions::Values::None)); + tx[JS(Flags)] = bNoRipple ? xrpl::tfClearNoRipple : xrpl::tfSetNoRipple; output.transactions->push_back(tx); } @@ -168,7 +171,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 5d2af934d..53e5bed92 100644 --- a/src/rpc/handlers/NoRippleCheck.hpp +++ b/src/rpc/handlers/NoRippleCheck.hpp @@ -91,7 +91,7 @@ public: validation::Required{}, meta::WithCustomError{ validation::OneOf{"gateway", "user"}, - Status{RippledError::rpcINVALID_PARAMS, "role field is invalid"} + 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 b35400208..f1046ee5a 100644 --- a/src/rpc/handlers/Random.cpp +++ b/src/rpc/handlers/Random.cpp @@ -16,10 +16,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 8262d89d9..00303cc51 100644 --- a/src/rpc/handlers/ServerInfo.hpp +++ b/src/rpc/handlers/ServerInfo.hpp @@ -77,8 +77,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; }; /** @@ -88,7 +88,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; }; @@ -103,7 +103,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 = {}; @@ -182,11 +182,11 @@ public: 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 = @@ -222,7 +222,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(); @@ -254,7 +254,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 534ba274b..078215457 100644 --- a/src/rpc/handlers/Subscribe.cpp +++ b/src/rpc/handlers/Subscribe.cpp @@ -52,30 +52,28 @@ SubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) static auto const kBooksValidator = 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"} + 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) @@ -213,7 +211,7 @@ SubscribeHandler::subscribeToBooks( // https://github.com/XRPLF/xrpl-dev-portal/issues/1818 auto const takerID = internalBook.taker ? accountFromStringStrict(*(internalBook.taker)) - : beast::zero; + : beast::kZero; auto const orderBook = postProcessOrderBook( offers, @@ -233,7 +231,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(); @@ -244,7 +242,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 5e8d43642..dc002e121 100644 --- a/src/rpc/handlers/Subscribe.hpp +++ b/src/rpc/handlers/Subscribe.hpp @@ -60,7 +60,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 d4b4c2c52..9d2146756 100644 --- a/src/rpc/handlers/TransactionEntry.cpp +++ b/src/rpc/handlers/TransactionEntry.cpp @@ -45,7 +45,7 @@ TransactionEntryHandler::process( output.ledgerHeader = *expectedLgrInfo; auto const dbRet = - sharedPtrBackend_->fetchTransaction(ripple::uint256{input.txHash.c_str()}, ctx.yield); + 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 @@ -57,7 +57,7 @@ TransactionEntryHandler::process( // 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."} + Status{RippledError::RpcTxnNotFound, "transactionNotFound", "Transaction not found."} }; } @@ -84,13 +84,13 @@ tag_invoke( {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)}, }; // NOLINTEND(bugprone-unchecked-optional-access) if (output.apiVersion > 1u) { // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - 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 98fd1e9d7..12d94e890 100644 --- a/src/rpc/handlers/TransactionEntry.hpp +++ b/src/rpc/handlers/TransactionEntry.hpp @@ -35,7 +35,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 3bedf60f9..b4bdf2cf2 100644 --- a/src/rpc/handlers/Tx.hpp +++ b/src/rpc/handlers/Tx.hpp @@ -61,7 +61,7 @@ public: 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; @@ -128,20 +128,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 kMaxLedgerRange = 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 > kMaxLedgerRange) - return Error{Status{RippledError::rpcEXCESSIVE_LGR_RANGE}}; + return Error{Status{RippledError::RpcExcessiveLgrRange}}; } std::optional currentNetId = std::nullopt; @@ -153,13 +153,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: {}", @@ -171,7 +171,7 @@ public: dbResponse = fetchTxViaCtid(lgrSeq, txnIdx, ctx.yield); } else { dbResponse = sharedPtrBackend_->fetchTransaction( - ripple::uint256{input.transaction->c_str()}, ctx.yield + xrpl::uint256{input.transaction->c_str()}, ctx.yield ); } @@ -191,10 +191,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] = @@ -204,8 +204,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))) @@ -299,8 +299,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 ba58983c8..d0923cd4e 100644 --- a/src/rpc/handlers/Unsubscribe.cpp +++ b/src/rpc/handlers/Unsubscribe.cpp @@ -38,20 +38,18 @@ UnsubscribeHandler::spec([[maybe_unused]] uint32_t apiVersion) static auto const kBooksValidator = 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"} + 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()) @@ -153,7 +151,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 b41d9e7d0..42962a712 100644 --- a/src/rpc/handlers/Unsubscribe.hpp +++ b/src/rpc/handlers/Unsubscribe.hpp @@ -36,7 +36,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 990cf3782..84cc3a2bc 100644 --- a/src/rpc/handlers/VaultInfo.cpp +++ b/src/rpc/handlers/VaultInfo.cpp @@ -81,28 +81,28 @@ 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); if (!accountLedgerObject) - return std::unexpected{Status{RippledError::rpcENTRY_NOT_FOUND}}; + return std::unexpected{Status{RippledError::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{RippledError::rpcENTRY_NOT_FOUND}}; + return std::unexpected{Status{RippledError::RpcEntryNotFound}}; }(); if (not vaultKeylet.has_value()) @@ -113,30 +113,30 @@ VaultInfoHandler::process(VaultInfoHandler::Input const& input, Context const& c sharedPtrBackend_->fetchLedgerObject(vaultKeylet->key, lgrInfo.seq, ctx.yield); if (not vaultLedgerObject) - return Error{Status{RippledError::rpcENTRY_NOT_FOUND, "vault object not found."}}; + return Error{Status{RippledError::RpcEntryNotFound, "vault object not found."}}; - ripple::STLedgerEntry const vaultSle{ - ripple::SerialIter{vaultLedgerObject->data(), vaultLedgerObject->size()}, vaultKeylet->key + xrpl::STLedgerEntry const vaultSle{ + xrpl::SerialIter{vaultLedgerObject->data(), vaultLedgerObject->size()}, vaultKeylet->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{RippledError::rpcENTRY_NOT_FOUND, "issuance object not found."}}; + return Error{Status{RippledError::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 = toBoostJson(vaultSle.getJson(xrpl::JsonOptions::Values::None)); response.vault.as_object()[JS(shares)] = - toBoostJson(issuanceSle.getJson(ripple::JsonOptions::none)); + 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 397a2190d..395507fe0 100644 --- a/src/util/AccountUtils.hpp +++ b/src/util/AccountUtils.hpp @@ -28,7 +28,7 @@ parseBase58Wrapper(std::string const& str) })) return std::nullopt; - return ripple::parseBase58(str); + return xrpl::parseBase58(str); } /** @@ -43,14 +43,14 @@ 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 2344d328a..424eab94b 100644 --- a/src/util/CMakeLists.txt +++ b/src/util/CMakeLists.txt @@ -54,7 +54,6 @@ target_link_libraries( 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 3f3058c90..ae87a3597 100644 --- a/src/util/LedgerUtils.cpp +++ b/src/util/LedgerUtils.cpp @@ -12,16 +12,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); result.has_value() && @@ -29,7 +29,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 ae9ec7e01..037116d7a 100644 --- a/src/util/LedgerUtils.hpp +++ b/src/util/LedgerUtils.hpp @@ -32,7 +32,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; @@ -40,7 +40,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} @@ -49,19 +49,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); } @@ -82,80 +82,80 @@ class LedgerTypes { LedgerTypeAttribute::accountOwnedLedgerType( JS(AccountRoot), JS(account), - ripple::ltACCOUNT_ROOT + xrpl::ltACCOUNT_ROOT ), - LedgerTypeAttribute::chainLedgerType(JS(Amendments), JS(amendments), ripple::ltAMENDMENTS), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(Check), JS(check), ripple::ltCHECK), + LedgerTypeAttribute::chainLedgerType(JS(Amendments), JS(amendments), xrpl::ltAMENDMENTS), + LedgerTypeAttribute::deletionBlockerLedgerType(JS(Check), JS(check), xrpl::ltCHECK), LedgerTypeAttribute::accountOwnedLedgerType( JS(DepositPreauth), JS(deposit_preauth), - ripple::ltDEPOSIT_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::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), - ripple::ltPAYCHAN + xrpl::ltPAYCHAN ), LedgerTypeAttribute::accountOwnedLedgerType( JS(SignerList), JS(signer_list), - ripple::ltSIGNER_LIST + xrpl::ltSIGNER_LIST ), LedgerTypeAttribute::deletionBlockerLedgerType( JS(RippleState), JS(state), - ripple::ltRIPPLE_STATE + xrpl::ltRIPPLE_STATE ), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Ticket), JS(ticket), ripple::ltTICKET), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Ticket), JS(ticket), xrpl::ltTICKET), LedgerTypeAttribute::accountOwnedLedgerType( JS(NFTokenOffer), JS(nft_offer), - ripple::ltNFTOKEN_OFFER + xrpl::ltNFTOKEN_OFFER ), LedgerTypeAttribute::deletionBlockerLedgerType( JS(NFTokenPage), JS(nft_page), - ripple::ltNFTOKEN_PAGE + xrpl::ltNFTOKEN_PAGE ), - LedgerTypeAttribute::accountOwnedLedgerType(JS(AMM), JS(amm), ripple::ltAMM), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(Bridge), JS(bridge), ripple::ltBRIDGE), + 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(DID), JS(did), xrpl::ltDID), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Oracle), JS(oracle), xrpl::ltORACLE), LedgerTypeAttribute::accountOwnedLedgerType( JS(Credential), JS(credential), - ripple::ltCREDENTIAL + xrpl::ltCREDENTIAL ), - LedgerTypeAttribute::accountOwnedLedgerType(JS(Vault), JS(vault), ripple::ltVAULT), - LedgerTypeAttribute::chainLedgerType(JS(NegativeUNL), JS(nunl), ripple::ltNEGATIVE_UNL), + LedgerTypeAttribute::accountOwnedLedgerType(JS(Vault), JS(vault), xrpl::ltVAULT), + LedgerTypeAttribute::chainLedgerType(JS(NegativeUNL), JS(nunl), xrpl::ltNEGATIVE_UNL), LedgerTypeAttribute::deletionBlockerLedgerType( JS(MPTokenIssuance), JS(mpt_issuance), - ripple::ltMPTOKEN_ISSUANCE + xrpl::ltMPTOKEN_ISSUANCE ), - LedgerTypeAttribute::deletionBlockerLedgerType(JS(MPToken), JS(mptoken), ripple::ltMPTOKEN), + 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: @@ -187,7 +187,7 @@ public: constexpr auto kDeletionBlockersCount = std::count_if(std::begin(kLedgerTypes), std::end(kLedgerTypes), kFilter); - std::array res{}; + std::array res{}; auto it = std::begin(res); std::ranges::for_each(kLedgerTypes, [&](auto const& item) { if (kFilter(item)) { @@ -199,23 +199,23 @@ 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: @@ -224,32 +224,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 01f4576ee..d4e8510b3 100644 --- a/src/util/Shasum.cpp +++ b/src/util/Shasum.cpp @@ -9,13 +9,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; } @@ -23,7 +23,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 @@ -32,13 +32,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 65492a1e1..0f4664afa 100644 --- a/src/util/Shasum.hpp +++ b/src/util/Shasum.hpp @@ -12,9 +12,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); /** @@ -33,7 +33,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: /** @@ -58,11 +58,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 de8243bc8..7642eecab 100644 --- a/src/util/TimeUtils.cpp +++ b/src/util/TimeUtils.cpp @@ -30,11 +30,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 4f708b23e..d21a346a0 100644 --- a/src/util/TimeUtils.hpp +++ b/src/util/TimeUtils.hpp @@ -33,6 +33,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 e424d70a4..1ebccc8f2 100644 --- a/src/util/TxUtils.cpp +++ b/src/util/TxUtils.cpp @@ -20,8 +20,8 @@ getTxTypesInLowercase() static std::unordered_set const kTypesKeysInLowercase = []() { 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 df7b09962..fc11fee0e 100644 --- a/src/web/ProxyIpResolver.hpp +++ b/src/web/ProxyIpResolver.hpp @@ -24,8 +24,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 ad08ddea1..2f631b448 100644 --- a/src/web/impl/ErrorHandling.hpp +++ b/src/web/impl/ErrorHandling.hpp @@ -102,7 +102,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 ); } @@ -111,7 +111,7 @@ public: sendNotReadyError() const { connection_->send( - boost::json::serialize(composeError(rpc::RippledError::rpcNOT_READY)), + boost::json::serialize(composeError(rpc::RippledError::RpcNotReady)), boost::beast::http::status::ok ); } @@ -121,12 +121,12 @@ public: { if (connection_->upgraded) { connection_->send( - boost::json::serialize(rpc::makeError(rpc::RippledError::rpcTOO_BUSY)), + 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 ); } @@ -137,7 +137,7 @@ public: { if (connection_->upgraded) { connection_->send( - boost::json::serialize(rpc::makeError(rpc::RippledError::rpcBAD_SYNTAX)) + boost::json::serialize(rpc::makeError(rpc::RippledError::RpcBadSyntax)) ); } else { connection_->send( diff --git a/src/web/impl/HttpBase.hpp b/src/web/impl/HttpBase.hpp index 09f7a509b..0ed4d3f00 100644 --- a/src/web/impl/HttpBase.hpp +++ b/src/web/impl/HttpBase.hpp @@ -293,7 +293,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)) )); } } @@ -304,7 +304,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 c2ff0aac4..0e61c199c 100644 --- a/src/web/impl/WsBase.hpp +++ b/src/web/impl/WsBase.hpp @@ -151,7 +151,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 0eeb3ea32..64db667e5 100644 --- a/src/web/ng/RPCServerHandler.hpp +++ b/src/web/ng/RPCServerHandler.hpp @@ -340,7 +340,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 4b46ccb2a..c86ce259a 100644 --- a/src/web/ng/impl/ErrorHandling.cpp +++ b/src/web/ng/impl/ErrorHandling.cpp @@ -111,7 +111,7 @@ ErrorHelper::makeInternalError() const { return Response{ http::status::internal_server_error, - composeError(rpc::RippledError::rpcINTERNAL), + composeError(rpc::RippledError::RpcInternal), rawRequest_ }; } @@ -119,7 +119,7 @@ ErrorHelper::makeInternalError() const 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 @@ -128,14 +128,14 @@ ErrorHelper::makeTooBusyError() const if (not rawRequest_.get().isHttp()) { return Response{ http::status::too_many_requests, - rpc::makeError(rpc::RippledError::rpcTOO_BUSY), + rpc::makeError(rpc::RippledError::RpcTooBusy), rawRequest_ }; } return Response{ http::status::service_unavailable, - rpc::makeError(rpc::RippledError::rpcTOO_BUSY), + rpc::makeError(rpc::RippledError::RpcTooBusy), rawRequest_ }; } @@ -145,7 +145,7 @@ ErrorHelper::makeJsonParsingError() const { if (not rawRequest_.get().isHttp()) { return Response{ - http::status::bad_request, rpc::makeError(rpc::RippledError::rpcBAD_SYNTAX), rawRequest_ + http::status::bad_request, rpc::makeError(rpc::RippledError::RpcBadSyntax), rawRequest_ }; } diff --git a/tests/common/etl/FakeDiffProvider.hpp b/tests/common/etl/FakeDiffProvider.hpp index eeb6fc408..47c35db09 100644 --- a/tests/common/etl/FakeDiffProvider.hpp +++ b/tests/common/etl/FakeDiffProvider.hpp @@ -17,7 +17,7 @@ struct DiffProvider { std::vector getLatestDiff() // NOLINT(readability-convert-member-functions-to-static) { - using namespace ripple; + using namespace xrpl; return { {.key = uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, @@ -45,7 +45,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 @@ -61,7 +61,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 20ecc9ada..2b6a61dbd 100644 --- a/tests/common/util/BinaryTestObject.cpp +++ b/tests/common/util/BinaryTestObject.cpp @@ -43,20 +43,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 { @@ -64,7 +64,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 }; @@ -92,8 +92,8 @@ createObject(etl::model::Object::ModType modType, std::string key) .key = binaryStringToUint256(hexStringToBinaryString(key)), .keyRaw = hexStringToBinaryString(key), .data = modType == etl::model::Object::ModType::Deleted - ? ripple::Blob{} - : *ripple::strUnHex(kObjBlob), // NOLINT(bugprone-unchecked-optional-access) + ? xrpl::Blob{} + : *xrpl::strUnHex(kObjBlob), // NOLINT(bugprone-unchecked-optional-access) .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" : hexStringToBinaryString(kObjBlob), @@ -122,8 +122,8 @@ createObjectWithBookBase(etl::model::Object::ModType modType, std::string key) .key = binaryStringToUint256(hexStringToBinaryString(key)), .keyRaw = hexStringToBinaryString(key), .data = modType == etl::model::Object::ModType::Deleted - ? ripple::Blob{} - : *ripple::strUnHex(kObjBlob), // NOLINT(bugprone-unchecked-optional-access) + ? xrpl::Blob{} + : *xrpl::strUnHex(kObjBlob), // NOLINT(bugprone-unchecked-optional-access) .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" : hexStringToBinaryString(kObjBlob), @@ -138,8 +138,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 kNftId = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000"; @@ -175,13 +175,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 kSpaceKey = 0x007F; - auto const keySha512Half = ripple::sha512Half(kSpaceKey, mptID, account); + auto const keySha512Half = xrpl::sha512Half(kSpaceKey, mptID, account); return { .key = {}, @@ -202,10 +202,10 @@ createSuccessor() { return { .firstBook = uint256ToString( - ripple::uint256{"A000000000000000000000000000000000000000000000000000000000000000"} + xrpl::uint256{"A000000000000000000000000000000000000000000000000000000000000000"} ), .bookBase = uint256ToString( - ripple::uint256{"A000000000000000000000000000000000000000000000000000000000000001"} + xrpl::uint256{"A000000000000000000000000000000000000000000000000000000000000001"} ), }; } diff --git a/tests/common/util/BinaryTestObject.hpp b/tests/common/util/BinaryTestObject.hpp index 266243f9a..1fb52bfd1 100644 --- a/tests/common/util/BinaryTestObject.hpp +++ b/tests/common/util/BinaryTestObject.hpp @@ -129,7 +129,7 @@ static constexpr auto kDefaultObjKey = [[maybe_unused, nodiscard]] std::pair createTxAndMetaBlobs(std::string metaStr = kDefaultTxnMeta, std::string txnStr = kDefaultTxnHex); -[[maybe_unused, nodiscard]] std::pair +[[maybe_unused, nodiscard]] std::pair createTxAndMeta( std::string hashStr = kDefaultHash, std::string metaStr = kDefaultTxnMeta, @@ -138,7 +138,7 @@ createTxAndMeta( [[maybe_unused, nodiscard]] etl::model::Transaction createTransaction( - ripple::TxType type, + xrpl::TxType type, std::string hashStr = kDefaultHash, std::string metaStr = kDefaultTxnMeta, std::string txnStr = kDefaultTxnHex diff --git a/tests/common/util/MockBackend.hpp b/tests/common/util/MockBackend.hpp index cb8d622be..f2385c087 100644 --- a/tests/common/util/MockBackend.hpp +++ b/tests/common/util/MockBackend.hpp @@ -26,16 +26,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) ); @@ -49,21 +49,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&, @@ -79,7 +79,7 @@ struct MockBackend : public BackendInterface { ); MOCK_METHOD( - std::vector, + std::vector, fetchAllTransactionHashesInLedger, (std::uint32_t const, boost::asio::yield_context), (const, override) @@ -88,14 +88,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&, @@ -106,7 +106,7 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( data::TransactionsAndCursor, fetchMPTokenIssuanceTransactions, - (ripple::uint192 const&, + (xrpl::uint192 const&, std::uint32_t, bool, std::optional const&, @@ -117,8 +117,8 @@ struct MockBackend : public BackendInterface { MOCK_METHOD( data::TransactionsAndCursor, fetchAccountMPTokenIssuanceTransactions, - (ripple::uint192 const&, - ripple::AccountID const&, + (xrpl::uint192 const&, + xrpl::AccountID const&, std::uint32_t, bool, std::optional const&, @@ -129,11 +129,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) ); @@ -141,12 +141,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) @@ -155,14 +155,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) ); @@ -174,9 +174,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) ); @@ -203,7 +203,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, @@ -277,9 +277,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 c8c062e8f..6219822c1 100644 --- a/tests/common/util/MockLedgerCache.hpp +++ b/tests/common/util/MockLedgerCache.hpp @@ -30,7 +30,7 @@ struct MockLedgerCache : data::LedgerCacheInterface { MOCK_METHOD( std::optional, get, - (ripple::uint256 const& a, uint32_t b), + (xrpl::uint256 const& a, uint32_t b), (const, override) ); @@ -39,21 +39,21 @@ struct MockLedgerCache : data::LedgerCacheInterface { MOCK_METHOD( std::optional, getDeleted, - (ripple::uint256 const&, uint32_t), + (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 f53fef1b6..13a56dba5 100644 --- a/tests/common/util/MockLedgerPublisher.hpp +++ b/tests/common/util/MockLedgerPublisher.hpp @@ -16,7 +16,7 @@ struct MockLedgerPublisher : public etl::LedgerPublisherInterface { (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, diff --git a/tests/common/util/MockSubscriptionManager.hpp b/tests/common/util/MockSubscriptionManager.hpp index 9860f8d40..f0ae17736 100644 --- a/tests/common/util/MockSubscriptionManager.hpp +++ b/tests/common/util/MockSubscriptionManager.hpp @@ -29,14 +29,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) ); @@ -49,32 +49,27 @@ struct MockSubscriptionManager : feed::SubscriptionManagerInterface { MOCK_METHOD( void, pubTransaction, - (data::TransactionAndMetadata const&, ripple::LedgerHeader const&), + (data::TransactionAndMetadata const&, xrpl::LedgerHeader const&), (override) ); MOCK_METHOD( void, subAccount, - (ripple::AccountID const&, feed::SubscriberSharedPtr const&), + (xrpl::AccountID const&, feed::SubscriberSharedPtr const&), (override) ); MOCK_METHOD( void, unsubAccount, - (ripple::AccountID const&, feed::SubscriberSharedPtr const&), + (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)); @@ -97,14 +92,14 @@ struct MockSubscriptionManager : feed::SubscriptionManagerInterface { MOCK_METHOD( void, subProposedAccount, - (ripple::AccountID const&, feed::SubscriberSharedPtr const&), + (xrpl::AccountID const&, feed::SubscriberSharedPtr const&), (override) ); MOCK_METHOD( void, unsubProposedAccount, - (ripple::AccountID const&, feed::SubscriberSharedPtr const&), + (xrpl::AccountID const&, feed::SubscriberSharedPtr const&), (override) ); diff --git a/tests/common/util/StringUtils.cpp b/tests/common/util/StringUtils.cpp index c639e011d..6fe3948bd 100644 --- a/tests/common/util/StringUtils.cpp +++ b/tests/common/util/StringUtils.cpp @@ -11,7 +11,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) // NOLINT(bugprone-unchecked-optional-access) @@ -20,14 +20,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 7a4e9250b..cc6ff5e40 100644 --- a/tests/common/util/StringUtils.hpp +++ b/tests/common/util/StringUtils.hpp @@ -9,8 +9,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 f1df417f3..3e6be2b27 100644 --- a/tests/common/util/TestObject.cpp +++ b/tests/common/util/TestObject.cpp @@ -41,39 +41,35 @@ 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) { // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - return *util::parseBase58Wrapper(std::string(id)); + return *util::parseBase58Wrapper(std::string(id)); } -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) { @@ -81,32 +77,32 @@ createLedgerHeader( // precision is seconds 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}).count() - kRippleEpochStart; - ledgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + ledgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; } return ledgerHeader; } -ripple::LedgerHeader +xrpl::LedgerHeader createLedgerHeaderWithUnixTime( std::string_view ledgerHash, - ripple::LedgerIndex seq, + 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{kRippleEpochStart}.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, @@ -115,34 +111,34 @@ 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 +xrpl::STObject createFeeSettingLedgerObject( - ripple::STAmount base, - ripple::STAmount reserveInc, - ripple::STAmount reserveBase, + 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, @@ -155,11 +151,11 @@ createLegacyFeeSettingBlob( return lo.getSerializer().peekData(); } -ripple::Blob +xrpl::Blob createFeeSettingBlob( - ripple::STAmount base, - ripple::STAmount reserveInc, - ripple::STAmount reserveBase, + xrpl::STAmount base, + xrpl::STAmount reserveInc, + xrpl::STAmount reserveBase, uint32_t flag ) { @@ -167,7 +163,7 @@ createFeeSettingBlob( return lo.getSerializer().peekData(); } -ripple::STObject +xrpl::STObject createPaymentTransactionObject( std::string_view accountId1, std::string_view accountId2, @@ -176,21 +172,21 @@ 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); // NOLINT(bugprone-unchecked-optional-access) - obj.setFieldAmount(ripple::sfAmount, ripple::STAmount(amount, false)); - obj.setFieldAmount(ripple::sfFee, ripple::STAmount(fee, false)); - auto account2 = util::parseBase58Wrapper(std::string(accountId2)); + xrpl::STObject obj(xrpl::sfTransaction); + obj.setFieldU16(xrpl::sfTransactionType, xrpl::ttPAYMENT); + auto account = util::parseBase58Wrapper(std::string(accountId1)); + obj.setAccountID(xrpl::sfAccount, *account); // NOLINT(bugprone-unchecked-optional-access) + obj.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(amount, false)); + obj.setFieldAmount(xrpl::sfFee, xrpl::STAmount(fee, false)); + auto account2 = util::parseBase58Wrapper(std::string(accountId2)); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - obj.setAccountID(ripple::sfDestination, *account2); - obj.setFieldU32(ripple::sfSequence, seq); - obj.setFieldVL(ripple::sfSigningPubKey, kSlice); + obj.setAccountID(xrpl::sfDestination, *account2); + 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, @@ -199,31 +195,31 @@ 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, @@ -231,23 +227,23 @@ createDidObject( 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, @@ -257,27 +253,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, @@ -289,52 +285,52 @@ 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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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}, + xrpl::Issue const issue1( + xrpl::Currency{currency}, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *util::parseBase58Wrapper(std::string(issuer)) + *util::parseBase58Wrapper(std::string(issuer)) ); 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)), + return xrpl::Issue( + xrpl::toCurrency(std::string(currency)), // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *util::parseBase58Wrapper(std::string(issuerId)) + *util::parseBase58Wrapper(std::string(issuerId)) ); } - return ripple::Issue( - ripple::Currency{currency}, + return xrpl::Issue( + xrpl::Currency{currency}, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *util::parseBase58Wrapper(std::string(issuerId)) + *util::parseBase58Wrapper(std::string(issuerId)) ); } -ripple::STObject +xrpl::STObject createMetaDataForBookChange( std::string_view currency, std::string_view issueId, @@ -346,29 +342,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, @@ -378,28 +374,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, @@ -408,34 +404,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, @@ -446,25 +442,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, @@ -478,22 +474,22 @@ 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)); + 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( - ripple::sfHighLimit, ripple::STAmount(getIssue(currency, highNodeAccountId), highLimit) + xrpl::sfHighLimit, xrpl::STAmount(getIssue(currency, highNodeAccountId), highLimit) ); line.setFieldAmount( - ripple::sfLowLimit, ripple::STAmount(getIssue(currency, lowNodeAccountId), lowLimit) + xrpl::sfLowLimit, xrpl::STAmount(getIssue(currency, lowNodeAccountId), lowLimit) ); - line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{previousTxnId}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxnSeq); + 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, @@ -506,106 +502,106 @@ 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; } @@ -613,91 +609,91 @@ data::NFT createNft( std::string_view tokenID, std::string_view account, - ripple::LedgerIndex seq, - ripple::Blob uri, + 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; } @@ -711,50 +707,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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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(); @@ -774,52 +770,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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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(); @@ -828,56 +824,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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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(); @@ -889,40 +885,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(); @@ -934,36 +930,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(); @@ -981,35 +977,35 @@ 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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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 // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - finalFields.setAccountID(ripple::sfOwner, *account); + finalFields.setAccountID(xrpl::sfOwner, *account); - 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(); @@ -1029,80 +1025,80 @@ 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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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 // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - finalFields.setAccountID(ripple::sfOwner, *account); + finalFields.setAccountID(xrpl::sfOwner, *account); - node.emplace_back(finalFields); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{offerId}); + node.set(xrpl::STObject{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(); @@ -1120,40 +1116,40 @@ 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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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()}; + return xrpl::uint256{nftId.c_str()}; }); - tx.setFieldV256(ripple::sfNFTokenOffers, offers); - tx.setFieldVL(ripple::sfSigningPubKey, kSlice); + 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(); @@ -1172,31 +1168,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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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(); @@ -1211,43 +1207,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); // NOLINT(bugprone-unchecked-optional-access) - 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); // NOLINT(bugprone-unchecked-optional-access) + 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(); @@ -1255,28 +1251,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, @@ -1289,30 +1285,28 @@ 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); + 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( - ripple::sfAsset, ripple::STIssue{ripple::sfAsset, getIssue(assetCurrency, assetIssuer)} + xrpl::sfAsset, xrpl::STIssue{xrpl::sfAsset, getIssue(assetCurrency, assetIssuer)} ); amm.setFieldIssue( - ripple::sfAsset2, ripple::STIssue{ripple::sfAsset2, getIssue(asset2Currency, asset2Issuer)} + xrpl::sfAsset2, xrpl::STIssue{xrpl::sfAsset2, getIssue(asset2Currency, asset2Issuer)} ); - ripple::Issue const issue1( - ripple::Currency{lpTokenBalanceIssueCurrency}, + xrpl::Issue const issue1( + xrpl::Currency{lpTokenBalanceIssueCurrency}, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *util::parseBase58Wrapper(std::string(accountId)) + *util::parseBase58Wrapper(std::string(accountId)) ); - 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, @@ -1321,34 +1315,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, @@ -1358,36 +1352,36 @@ 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.setFieldU32(xrpl::sfFlags, 0); chainOwnedClaimID.setAccountID( - ripple::sfOtherChainSource, getAccountIdWithString(otherChainSource) + xrpl::sfOtherChainSource, getAccountIdWithString(otherChainSource) ); - chainOwnedClaimID.setFieldArray(ripple::sfXChainClaimAttestations, ripple::STArray{}); + chainOwnedClaimID.setFieldArray(xrpl::sfXChainClaimAttestations, xrpl::STArray{}); return chainOwnedClaimID; } -ripple::STObject +xrpl::STObject createChainOwnedCreateAccountClaimId( std::string_view accountId, std::string_view lockingDoor, @@ -1396,100 +1390,98 @@ createChainOwnedCreateAccountClaimId( std::string_view issuingIssuer ) { - auto chainOwnedCreateAccountClaimID = ripple::STObject(ripple::sfLedgerEntry); + auto chainOwnedCreateAccountClaimID = xrpl::STObject(xrpl::sfLedgerEntry); chainOwnedCreateAccountClaimID.setFieldU16( - ripple::sfLedgerEntryType, ripple::ltXCHAIN_OWNED_CLAIM_ID + xrpl::sfLedgerEntryType, xrpl::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; + 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.setFieldU32(xrpl::sfFlags, 0); chainOwnedCreateAccountClaimID.setFieldArray( - ripple::sfXChainCreateAccountAttestations, ripple::STArray{} + xrpl::sfXChainCreateAccountAttestations, xrpl::STArray{} ); return chainOwnedCreateAccountClaimID; } void ammAddVoteSlot( - ripple::STObject& amm, - ripple::AccountID const& accountId, + 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)) + 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, @@ -1504,105 +1496,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(); @@ -1610,28 +1602,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; } @@ -1639,30 +1631,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(); @@ -1670,113 +1662,113 @@ 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); + auto priceData = xrpl::STObject(xrpl::sfPriceData); + priceData.setFieldU64(xrpl::sfAssetPrice, assetPrice); priceData.setFieldCurrency( - ripple::sfBaseAsset, ripple::STCurrency{ripple::sfBaseAsset, baseAssetCurrency} + xrpl::sfBaseAsset, xrpl::STCurrency{xrpl::sfBaseAsset, baseAssetCurrency} ); priceData.setFieldCurrency( - ripple::sfQuoteAsset, ripple::STCurrency{ripple::sfQuoteAsset, quoteAssetCurrency} + xrpl::sfQuoteAsset, xrpl::STCurrency{xrpl::sfQuoteAsset, quoteAssetCurrency} ); - priceData.setFieldU8(ripple::sfScale, scale); + 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, @@ -1785,147 +1777,145 @@ 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); + credObj.setFieldU32(xrpl::sfExpiration, *expiration); 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])); + auto credential = xrpl::STObject::makeInnerObject(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, getAccountIdWithString(issuer[i])); credential.setFieldVL( - ripple::sfCredentialType, + xrpl::sfCredentialType, // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::strUnHex(std::string(credType[i])) + *xrpl::strUnHex(std::string(credType[i])) ); 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)} + xrpl::sfAsset, xrpl::STIssue{xrpl::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[xrpl::sfShareMPTID] = shareMPTID; + vault.setFieldNumber(xrpl::sfAssetsTotal, xrpl::STNumber{xrpl::sfAssetsTotal, 300}); + vault.setFieldNumber(xrpl::sfAssetsAvailable, xrpl::STNumber{xrpl::sfAssetsAvailable, 300}); + vault.setFieldNumber(xrpl::sfLossUnrealized, xrpl::STNumber{xrpl::sfLossUnrealized, 1}); + 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; } -ripple::STObject +xrpl::STObject createLoanBroker( std::string_view owner, std::string_view account, - ripple::LedgerIndex seq, - ripple::uint256 vaultID, + xrpl::LedgerIndex seq, + xrpl::uint256 vaultID, uint32_t loanSequence, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ) { - auto loanBroker = ripple::STObject(ripple::sfLedgerEntry); - loanBroker.setAccountID(ripple::sfOwner, getAccountIdWithString(owner)); - loanBroker.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - loanBroker.setFieldU32(ripple::sfSequence, seq); - loanBroker.setFieldU64(ripple::sfOwnerNode, 0); - loanBroker.setFieldU64(ripple::sfVaultNode, 0); - loanBroker.setFieldH256(ripple::sfVaultID, vaultID); - loanBroker.setFieldH256(ripple::sfPreviousTxnID, previousTxId); - loanBroker.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxSeq); - loanBroker.setFieldU32(ripple::sfLoanSequence, loanSequence); + auto loanBroker = xrpl::STObject(xrpl::sfLedgerEntry); + loanBroker.setAccountID(xrpl::sfOwner, getAccountIdWithString(owner)); + loanBroker.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + loanBroker.setFieldU32(xrpl::sfSequence, seq); + loanBroker.setFieldU64(xrpl::sfOwnerNode, 0); + loanBroker.setFieldU64(xrpl::sfVaultNode, 0); + loanBroker.setFieldH256(xrpl::sfVaultID, vaultID); + loanBroker.setFieldH256(xrpl::sfPreviousTxnID, previousTxId); + loanBroker.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxSeq); + loanBroker.setFieldU32(xrpl::sfLoanSequence, loanSequence); // Optional/default fields - not setting them as they will use default values - loanBroker.setFieldU32(ripple::sfFlags, 0); - loanBroker.setFieldU16(ripple::sfLedgerEntryType, ripple::ltLOAN_BROKER); + loanBroker.setFieldU32(xrpl::sfFlags, 0); + loanBroker.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltLOAN_BROKER); return loanBroker; } -ripple::STObject +xrpl::STObject createLoan( std::string_view borrower, - ripple::uint256 loanBrokerID, + xrpl::uint256 loanBrokerID, uint32_t loanSequence, uint32_t startDate, uint32_t paymentInterval, int64_t periodicPaymentValue, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ) { - auto loan = ripple::STObject(ripple::sfLedgerEntry); - loan.setAccountID(ripple::sfBorrower, getAccountIdWithString(borrower)); - loan.setFieldH256(ripple::sfLoanBrokerID, loanBrokerID); - loan.setFieldU32(ripple::sfLoanSequence, loanSequence); - loan.setFieldU64(ripple::sfOwnerNode, 0); - loan.setFieldU64(ripple::sfLoanBrokerNode, 0); - loan.setFieldH256(ripple::sfPreviousTxnID, previousTxId); - loan.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxSeq); + auto loan = xrpl::STObject(xrpl::sfLedgerEntry); + loan.setAccountID(xrpl::sfBorrower, getAccountIdWithString(borrower)); + loan.setFieldH256(xrpl::sfLoanBrokerID, loanBrokerID); + loan.setFieldU32(xrpl::sfLoanSequence, loanSequence); + loan.setFieldU64(xrpl::sfOwnerNode, 0); + loan.setFieldU64(xrpl::sfLoanBrokerNode, 0); + loan.setFieldH256(xrpl::sfPreviousTxnID, previousTxId); + loan.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxSeq); - loan.setFieldU32(ripple::sfStartDate, startDate); - loan.setFieldU32(ripple::sfPaymentInterval, paymentInterval); + loan.setFieldU32(xrpl::sfStartDate, startDate); + loan.setFieldU32(xrpl::sfPaymentInterval, paymentInterval); loan.setFieldNumber( - ripple::sfPeriodicPayment, ripple::STNumber{ripple::sfPeriodicPayment, periodicPaymentValue} + xrpl::sfPeriodicPayment, xrpl::STNumber{xrpl::sfPeriodicPayment, periodicPaymentValue} ); // Optional/default fields - not setting them as they will use default values - loan.setFieldU32(ripple::sfFlags, 0); - loan.setFieldU16(ripple::sfLedgerEntryType, ripple::ltLOAN); + loan.setFieldU32(xrpl::sfFlags, 0); + loan.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltLOAN); return loan; } diff --git a/tests/common/util/TestObject.hpp b/tests/common/util/TestObject.hpp index d22b1d7b1..aa0b8b88f 100644 --- a/tests/common/util/TestObject.hpp +++ b/tests/common/util/TestObject.hpp @@ -26,45 +26,45 @@ /* * 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 +[[nodiscard]] xrpl::LedgerHeader createLedgerHeader( std::string_view ledgerHash, - ripple::LedgerIndex seq, + xrpl::LedgerIndex seq, std::optional age = std::nullopt ); /* * Create a simple ledgerHeader object with hash, seq and unix timestamp */ -[[nodiscard]] ripple::LedgerHeader +[[nodiscard]] xrpl::LedgerHeader createLedgerHeaderWithUnixTime( std::string_view ledgerHash, - ripple::LedgerIndex seq, + 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, @@ -76,18 +76,18 @@ createLegacyFeeSettingLedgerObject( /* * Create a FeeSetting ledger object */ -ripple::STObject +xrpl::STObject createFeeSettingLedgerObject( - ripple::STAmount base, - ripple::STAmount reserveInc, - ripple::STAmount reserveBase, + 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, @@ -99,18 +99,18 @@ createLegacyFeeSettingBlob( /* * Create a FeeSetting ledger object and return its blob */ -ripple::Blob +xrpl::Blob createFeeSettingBlob( - ripple::STAmount base, - ripple::STAmount reserveInc, - ripple::STAmount reserveBase, + 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, @@ -119,7 +119,7 @@ createPaymentTransactionObject( uint32_t seq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createPaymentTransactionMetaObject( std::string_view accountId1, std::string_view accountId2, @@ -131,7 +131,7 @@ createPaymentTransactionMetaObject( /* * Create an account root ledger object */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createAccountRootObject( std::string_view accountId, uint32_t flag, @@ -141,7 +141,7 @@ createAccountRootObject( std::string_view previousTxnID, uint32_t previousTxnSeq, uint32_t transferRate = 0, - std::optional ammID = std::nullopt + std::optional ammID = std::nullopt ); /* @@ -149,7 +149,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, @@ -164,13 +164,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, @@ -187,7 +187,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, @@ -200,7 +200,7 @@ createMetaDataForCreateOffer( /* * Meta data for removing a offer object */ -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createMetaDataForCancelOffer( std::string_view currency, std::string_view issueId, @@ -212,13 +212,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, @@ -229,7 +229,7 @@ createPaymentChannelLedgerObject( uint32_t previousTxnSeq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createRippleStateLedgerObject( std::string_view currency, std::string_view issuerId, @@ -243,7 +243,7 @@ createRippleStateLedgerObject( uint32_t flag = 0 ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createOfferLedgerObject( std::string_view account, int takerGets, @@ -256,19 +256,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, @@ -279,24 +279,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 ); /** @@ -326,7 +326,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 @@ -378,13 +378,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, @@ -397,7 +397,7 @@ createAmmObject( uint64_t ownerNode = 0u ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createBridgeObject( std::string_view accountId, std::string_view lockingDoor, @@ -406,7 +406,7 @@ createBridgeObject( std::string_view issuingIssuer ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createChainOwnedClaimIdObject( std::string_view accountId, std::string_view lockingDoor, @@ -416,7 +416,7 @@ createChainOwnedClaimIdObject( std::string_view otherChainSource ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createChainOwnedCreateAccountClaimId( std::string_view accountId, std::string_view lockingDoor, @@ -427,23 +427,23 @@ createChainOwnedCreateAccountClaimId( void ammAddVoteSlot( - ripple::STObject& amm, - ripple::AccountID const& accountId, + 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, @@ -451,10 +451,10 @@ createDidObject( 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, @@ -469,26 +469,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, @@ -499,53 +499,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 @@ -555,13 +555,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, @@ -570,44 +570,44 @@ 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 ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createLoanBroker( std::string_view owner, std::string_view account, - ripple::LedgerIndex seq, - ripple::uint256 vaultID, + xrpl::LedgerIndex seq, + xrpl::uint256 vaultID, uint32_t loanSequence, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ); -[[nodiscard]] ripple::STObject +[[nodiscard]] xrpl::STObject createLoan( std::string_view borrower, - ripple::uint256 loanBrokerID, + xrpl::uint256 loanBrokerID, uint32_t loanSequence, uint32_t startDate, uint32_t paymentInterval, int64_t periodicPaymentValue, - 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 50ddb2412..3a925e714 100644 --- a/tests/integration/data/cassandra/BackendTests.cpp +++ b/tests/integration/data/cassandra/BackendTests.cpp @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -150,8 +151,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( @@ -389,7 +389,7 @@ TEST_F(BackendCassandraTest, Basic) std::string const nftTxnHashHex = "6C7F69A6D25A13AC4A2E9145999F45D4674F939900017A96885FDC2757" "E9284E"; - ripple::uint256 nftID; + xrpl::uint256 nftID; EXPECT_TRUE(nftID.parseHex( "000800006203F49C21D5D6E022CB16DE3538F248662" "FC73CEF7FF5C60000002C" @@ -400,7 +400,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); @@ -412,9 +412,11 @@ 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); @@ -422,11 +424,15 @@ 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; @@ -482,7 +488,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); @@ -497,7 +503,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); @@ -542,7 +548,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); @@ -593,7 +599,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); @@ -611,13 +617,13 @@ 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() + reinterpret_cast(key.data()), xrpl::uint256::size() }; blob.first = keyStr; blob.second = std::to_string(ledgerSequence) + keyStr; @@ -632,12 +638,12 @@ 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() + 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; @@ -646,8 +652,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; @@ -788,7 +794,7 @@ TEST_F(BackendCassandraTest, Basic) ); } } - std::vector keys; + std::vector keys; for (auto [key, obj] : objs) { auto retObj = backend_->fetchLedgerObject(binaryStringToUint256(key), seq, yield); if (obj.size()) { @@ -833,9 +839,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)) @@ -846,8 +852,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); @@ -856,7 +862,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() ); } } @@ -887,7 +893,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() ); } } @@ -927,7 +933,7 @@ TEST_F(BackendCassandraTest, Basic) auto flattenAccountTx = [&](uint32_t max) { std::unordered_map< - ripple::AccountID, + xrpl::AccountID, std::vector>> accountTx; for (auto const& [seq, map] : allAccountTx) { @@ -978,8 +984,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)); @@ -1059,7 +1064,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) 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 ); @@ -1080,7 +1085,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); @@ -1108,7 +1113,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 ); @@ -1126,7 +1131,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); @@ -1158,7 +1163,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{} @@ -1177,7 +1182,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); @@ -1195,13 +1200,13 @@ 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() + reinterpret_cast(key.data()), xrpl::uint256::size() }; blob.first = keyStr; blob.second = std::to_string(ledgerSequence) + keyStr; @@ -1230,7 +1235,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); @@ -1284,7 +1289,7 @@ TEST_F(BackendCassandraTest, CacheIntegration) << "; 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()) { @@ -1327,9 +1332,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)) @@ -1338,7 +1343,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); @@ -1422,8 +1427,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; @@ -1464,22 +1468,22 @@ TEST_F(CacheBackendCassandraTest, CacheFetchLedgerBySeq) } struct BackendCassandraMPTokenIssuanceTest : BackendCassandraTest { - static ripple::uint192 + static xrpl::uint192 makeMptIssuanceId() { - return ripple::makeMptID(1, makeAccount(0x01)); + return xrpl::makeMptID(1, makeAccount(0x01)); } - static ripple::AccountID + static xrpl::AccountID makeAccount(std::uint8_t seed) { - return ripple::AccountID{seed}; + return xrpl::AccountID{seed}; } - static ripple::uint256 + static xrpl::uint256 makeHash(std::uint8_t seed) { - return ripple::uint256{seed}; + return xrpl::uint256{seed}; } // Writes a single ledger so that fetchLedgerRange() is populated, which the fetchers @@ -1488,7 +1492,7 @@ struct BackendCassandraMPTokenIssuanceTest : BackendCassandraTest { setupLedgerRange(std::uint32_t seq) { std::string rawHeaderBlob = hexStringToBinaryString(kRawheader); - ripple::LedgerHeader lgrInfo = util::deserializeHeader(ripple::makeSlice(rawHeaderBlob)); + xrpl::LedgerHeader lgrInfo = util::deserializeHeader(xrpl::makeSlice(rawHeaderBlob)); lgrInfo.seq = seq; backend_->writeLedger(lgrInfo, std::move(rawHeaderBlob)); backend_->writeSuccessor( @@ -1500,14 +1504,10 @@ struct BackendCassandraMPTokenIssuanceTest : BackendCassandraTest { } void - writeTxBlob(ripple::uint256 const& hash, std::uint32_t seq) + writeTxBlob(xrpl::uint256 const& hash, std::uint32_t seq) { backend_->writeTransaction( - uint256ToString(hash), - seq, - 0, - "tx_" + ripple::strHex(hash), - "meta_" + ripple::strHex(hash) + uint256ToString(hash), seq, 0, "tx_" + xrpl::strHex(hash), "meta_" + xrpl::strHex(hash) ); } }; @@ -1524,8 +1524,8 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, RoundTripIssuanceAndAccountIndexes) auto const hash = makeHash(0x01); writeTxBlob(hash, seq); - auto const expectedTxBlob = "tx_" + ripple::strHex(hash); - auto const expectedMetaBlob = "meta_" + ripple::strHex(hash); + auto const expectedTxBlob = "tx_" + xrpl::strHex(hash); + auto const expectedMetaBlob = "meta_" + xrpl::strHex(hash); auto expectFetchedSingle = [&](auto const& txns) { ASSERT_EQ(txns.size(), 1); @@ -1579,8 +1579,8 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, RoundTripIssuanceAndAccountIndexes) { auto const secondHash = makeHash(0x02); writeTxBlob(secondHash, seq); - auto const expectedSecondTxBlob = "tx_" + ripple::strHex(secondHash); - auto const expectedSecondMetaBlob = "meta_" + ripple::strHex(secondHash); + auto const expectedSecondTxBlob = "tx_" + xrpl::strHex(secondHash); + auto const expectedSecondMetaBlob = "meta_" + xrpl::strHex(secondHash); auto expectFetchedSecond = [&](auto const& txns) { ASSERT_EQ(txns.size(), 1); EXPECT_EQ( @@ -1629,7 +1629,7 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, DescendingOrderForwardAndReverse) // Three txns in three different ledgers, so ordering is checked across ledgers, // not just by transaction index within one ledger. - std::vector hashes; + std::vector hashes; std::vector seqs; for (std::uint8_t i = 1; i <= 3; ++i) { auto const seq = baseSeq + i; @@ -1652,7 +1652,7 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, DescendingOrderForwardAndReverse) auto txBlobToString = [](data::TransactionAndMetadata const& tx) { return std::string(tx.transaction.begin(), tx.transaction.end()); }; - auto expectedBlob = [&](std::uint8_t i) { return "tx_" + ripple::strHex(makeHash(i)); }; + auto expectedBlob = [&](std::uint8_t i) { return "tx_" + xrpl::strHex(makeHash(i)); }; // Reverse (forward=false): newest first -> rows 3, 2, 1. { @@ -1688,7 +1688,7 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, MarkerPaginationRoundTrip) auto txBlobToString = [](data::TransactionAndMetadata const& tx) { return std::string(tx.transaction.begin(), tx.transaction.end()); }; - auto expectedBlob = [&](std::uint8_t i) { return "tx_" + ripple::strHex(makeHash(i)); }; + auto expectedBlob = [&](std::uint8_t i) { return "tx_" + xrpl::strHex(makeHash(i)); }; auto expectSeenInOrder = [](std::vector const& seen, bool forward, std::set const& expected) { @@ -1703,7 +1703,7 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, MarkerPaginationRoundTrip) // Writes `total` rows, each in its own ledger and at a distinct transaction index, // so paging covers ordering across both. auto setup = - [&](ripple::uint192 const& issuanceId, std::uint8_t total, std::uint32_t firstSeq) { + [&](xrpl::uint192 const& issuanceId, std::uint8_t total, std::uint32_t firstSeq) { std::set expected; for (std::uint8_t i = 1; i <= total; ++i) { auto const seq = firstSeq + i - 1; @@ -1727,7 +1727,7 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, MarkerPaginationRoundTrip) // Page through every row; assert page order plus that the union of pages equals `expected` // exactly: every row seen exactly once (no duplicates from a repeated cursor row, no gaps // from a dropped row). Each full page (one that returns a cursor) must be exactly `limit`. - auto pageThrough = [&](ripple::uint192 const& issuanceId, + auto pageThrough = [&](xrpl::uint192 const& issuanceId, bool forward, std::uint32_t limit, std::set const& expected, @@ -1790,7 +1790,7 @@ TEST_F(BackendCassandraMPTokenIssuanceTest, MarkerPaginationRoundTrip) // and end the loop -- no infinite loop and no spurious trailing duplicate. { // Use a dedicated issuance id so rows from case A do not bleed in. - ripple::uint192 mptIssuanceIdB; + xrpl::uint192 mptIssuanceIdB; EXPECT_TRUE( mptIssuanceIdB.parseHex("00000002BE223A7216F1B07AE9C36F107879B6E9D3A3C1B0") ); diff --git a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp index e835a43c9..9aa8ad5f3 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp +++ b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp @@ -232,28 +232,28 @@ 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") + xrpl::uint256("CEECF7E516F8A53C5D32A357B737ED54D3186FDD510B1973D908AD8D93AD8E00") ); ASSERT_TRUE(txType.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) EXPECT_EQ(txType.value(), "OracleSet"); txType = getTxType( - ripple::uint256("35DBFB1A88DE17EBD2BCE37F6E1FD6D3B9887C92B7933ED2FCF2A84E9138B7CA") + xrpl::uint256("35DBFB1A88DE17EBD2BCE37F6E1FD6D3B9887C92B7933ED2FCF2A84E9138B7CA") ); ASSERT_TRUE(txType.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) EXPECT_EQ(txType.value(), "Payment"); txType = getTxType( - ripple::uint256("FCACE9D00625FA3BCC5316078324EA153EC8551243AC1701D496CC1CA2B8A474") + xrpl::uint256("FCACE9D00625FA3BCC5316078324EA153EC8551243AC1701D496CC1CA2B8A474") ); ASSERT_TRUE(txType.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) @@ -340,15 +340,15 @@ TEST_F(MigrationCassandraManagerLedgerTableTest, MigrateExampleLedgerMigrator) EXPECT_EQ( getAccountHash(5619393), - ripple::uint256("D1DE0F83A6858DF52811E31FE97B8449A4DD55A7D9E0023FE5DC2B335E4C49E8") + xrpl::uint256("D1DE0F83A6858DF52811E31FE97B8449A4DD55A7D9E0023FE5DC2B335E4C49E8") ); EXPECT_EQ( getAccountHash(5619394), - ripple::uint256("3FEF485204772F03842AA8757B4631E8F146E17AD9762E0552540A517DD38A24") + xrpl::uint256("3FEF485204772F03842AA8757B4631E8F146E17AD9762E0552540A517DD38A24") ); EXPECT_EQ( getAccountHash(5619395), - ripple::uint256("D0A61C158AD8941868666AD51C4662EEAAA2A141BF0F4435BC22B9BC6783AF65") + xrpl::uint256("D0A61C158AD8941868666AD51C4662EEAAA2A141BF0F4435BC22B9BC6783AF65") ); } diff --git a/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp b/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp index 507309e99..6f24334a7 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp +++ b/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp @@ -184,7 +184,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 kFetchAccountHash = [this]() { @@ -207,7 +207,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 ca459bce1..d568d75ce 100644 --- a/tests/integration/migration/cassandra/ExampleObjectsMigrator.cpp +++ b/tests/integration/migration/cassandra/ExampleObjectsMigrator.cpp @@ -27,15 +27,15 @@ ExampleObjectsMigrator::runMigration( 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) { + 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 dd280516b..7401ae5ee 100644 --- a/tests/integration/migration/cassandra/ExampleTransactionsMigrator.cpp +++ b/tests/integration/migration/cassandra/ExampleTransactionsMigrator.cpp @@ -35,9 +35,9 @@ ExampleTransactionsMigrator::runMigration( .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); + 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 34149cbad..6cfc87c1b 100644 --- a/tests/unit/app/WebHandlersTests.cpp +++ b/tests/unit/app/WebHandlersTests.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include #include #include @@ -212,7 +212,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 6acee000b..93faf11b6 100644 --- a/tests/unit/data/AmendmentCenterTests.cpp +++ b/tests/unit/data/AmendmentCenterTests.cpp @@ -32,14 +32,14 @@ struct AmendmentCenterTest : util::prometheus::WithPrometheus, // some Amendment that 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; } // We support at least all the amendments currently exposed by libXRPL - ASSERT_GE(amendmentCenter.getSupported().size(), ripple::allAmendments().size()); - ASSERT_GE(amendmentCenter.getAll().size(), ripple::allAmendments().size()); + ASSERT_GE(amendmentCenter.getSupported().size(), xrpl::allAmendments().size()); + ASSERT_GE(amendmentCenter.getAll().size(), xrpl::allAmendments().size()); } TEST_F(AmendmentCenterTest, Accessors) @@ -48,14 +48,14 @@ TEST_F(AmendmentCenterTest, Accessors) auto const am = amendmentCenter.getAmendment("DisallowIncoming"); EXPECT_EQ( am.feature, - ripple::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF") + xrpl::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF") ); } { auto const am = amendmentCenter["DisallowIncoming"]; EXPECT_EQ( am.feature, - ripple::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF") + xrpl::uint256("47C3002ABA31628447E8E9A8B315FAA935CE30183F9A9B86845E469CA2CDC3DF") ); } @@ -70,7 +70,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)); @@ -81,7 +81,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) { @@ -99,7 +99,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) { @@ -110,7 +110,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) { @@ -120,7 +120,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) { @@ -136,7 +136,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) { @@ -151,7 +151,7 @@ TEST_F(AmendmentCenterTest, IsEnabledReturnsVectorOfFalseWhenNoAmendments) TEST_F(AmendmentCenterTest, DeletedLibXRPLAmendmentIsNotKnownToLibXRPL) { // OwnerPaysFee was removed from libXRPL in 2.6.0; confirm it's not present upstream - EXPECT_FALSE(ripple::allAmendments().contains(std::string{Amendments::OwnerPaysFee})); + EXPECT_FALSE(xrpl::allAmendments().contains(std::string{Amendments::OwnerPaysFee})); } TEST_F(AmendmentCenterTest, DeletedLibXRPLAmendmentIsPresentInGetAllWithCorrectFlags) @@ -178,7 +178,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") ); } @@ -208,14 +208,14 @@ 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"} + k1, xrpl::uint256{"7E365F775657DC0EB960E6295A1F44B3F67479F54D5D12C5D87E6DB234F072E3"} ); EXPECT_EQ( - k2, ripple::uint256{"B4F33541E0E2FC2F7AA17D2D2E6A9B424809123485251D3413E91CC462309772"} + k2, xrpl::uint256{"B4F33541E0E2FC2F7AA17D2D2E6A9B424809123485251D3413E91CC462309772"} ); }); } diff --git a/tests/unit/data/BackendInterfaceTests.cpp b/tests/unit/data/BackendInterfaceTests.cpp index da47f05c3..ceea17478 100644 --- a/tests/unit/data/BackendInterfaceTests.cpp +++ b/tests/unit/data/BackendInterfaceTests.cpp @@ -35,7 +35,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, kMaxSeq, _)) @@ -53,7 +53,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, kMaxSeq, _)) @@ -71,7 +71,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()}); @@ -93,7 +93,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()}); @@ -131,7 +131,7 @@ TEST_F( 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 4aea03f9e..db660b174 100644 --- a/tests/unit/data/LedgerCacheTests.cpp +++ b/tests/unit/data/LedgerCacheTests.cpp @@ -84,8 +84,8 @@ TEST_F(LedgerCachePrometheusMetricTest, startLoading) } 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 0da165f6f..51919611b 100644 --- a/tests/unit/data/cassandra/SettingsProviderTests.cpp +++ b/tests/unit/data/cassandra/SettingsProviderTests.cpp @@ -21,7 +21,6 @@ using namespace util; using namespace util::config; using namespace std; -namespace json = boost::json; using namespace data::cassandra; @@ -67,7 +66,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") + boost::json::parse(R"JSON({"database.cassandra.contact_points": "127.0.0.1"})JSON") ); SettingsProvider const provider{cfg.getObject("database.cassandra")}; @@ -97,7 +96,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", @@ -122,7 +121,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")); @@ -135,7 +134,7 @@ TEST_F(SettingsProviderTest, DriverOptionalOptionsSpecified) TEST_F(SettingsProviderTest, SecureBundleConfig) { auto const cfg = getParseSettingsConfig( - json::parse(R"JSON({"database.cassandra.secure_connect_bundle": "bundleData"})JSON") + boost::json::parse(R"JSON({"database.cassandra.secure_connect_bundle": "bundleData"})JSON") ); SettingsProvider const provider{cfg.getObject("database.cassandra")}; @@ -149,7 +148,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 20a47e321..b0faaf053 100644 --- a/tests/unit/data/impl/LedgerCacheFileTests.cpp +++ b/tests/unit/data/impl/LedgerCacheFileTests.cpp @@ -142,8 +142,8 @@ struct LedgerCacheFileTestBase : ::testing::Test { data.latestSeq = kLatestSequence; 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); @@ -154,8 +154,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); @@ -535,16 +535,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}}); @@ -583,10 +583,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( diff --git a/tests/unit/etl/CacheLoaderSettingsTests.cpp b/tests/unit/etl/CacheLoaderSettingsTests.cpp index c4540785c..f370da47e 100644 --- a/tests/unit/etl/CacheLoaderSettingsTests.cpp +++ b/tests/unit/etl/CacheLoaderSettingsTests.cpp @@ -10,7 +10,6 @@ #include #include -namespace json = boost::json; using namespace etl; using namespace testing; using namespace util::config; @@ -54,7 +53,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); @@ -62,7 +61,8 @@ 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); @@ -70,7 +70,8 @@ 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); @@ -79,7 +80,7 @@ TEST_F(CacheLoaderSettingsTest, NumMarkersCorrectlyPropagatedThroughConfig) TEST_F(CacheLoaderSettingsTest, PageFetchSizeCorrectlyPropagatedThroughConfig) { auto const cfg = - getParseCacheConfig(json::parse(R"JSON({"cache": {"page_fetch_size": 42}})JSON")); + getParseCacheConfig(boost::json::parse(R"JSON({"cache": {"page_fetch_size": 42}})JSON")); auto const settings = makeCacheLoaderSettings(cfg); EXPECT_EQ(settings.cachePageFetchSize, 42); @@ -87,7 +88,8 @@ 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); @@ -96,7 +98,8 @@ 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); @@ -106,14 +109,16 @@ 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); @@ -126,7 +131,7 @@ TEST_F(CacheLoaderSettingsTest, CacheFilePathCorrectlyPropagatedThroughConfig) static constexpr auto kCacheFilePath = "/path/to/cache.dat"; auto const jsonStr = fmt::format(R"JSON({{"cache": {{"file": {{"path": "{}"}}}}}})JSON", kCacheFilePath); - 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()); @@ -149,7 +154,7 @@ TEST_F(CacheLoaderSettingsTest, MaxSequenceLagPropagatedThoughConfig) 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 b4fea254c..d59014296 100644 --- a/tests/unit/etl/CacheLoaderTests.cpp +++ b/tests/unit/etl/CacheLoaderTests.cpp @@ -26,7 +26,6 @@ #include #include -namespace json = boost::json; using namespace etl; using namespace util; using namespace data; @@ -290,7 +289,8 @@ 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, std::move(cacheLoadingState)}; auto const diffs = diffProvider.getLatestDiff(); @@ -318,7 +318,8 @@ 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, std::move(cacheLoadingState)}; auto const diffs = diffProvider.getLatestDiff(); @@ -348,7 +349,8 @@ 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, std::move(cacheLoadingState)}; EXPECT_CALL(cache, updateImpl).Times(0); @@ -360,7 +362,8 @@ 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, std::move(cacheLoadingState)}; EXPECT_CALL(cache, updateImpl).Times(0); @@ -382,7 +385,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, @@ -441,7 +444,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") + boost::json::parse( + R"JSON({"cache": {"load": "none", "file": {"path": "/tmp/cache.bin"}}})JSON" + ) ); CacheLoader<> loaderWithCacheDisabled{ disabledCacheCfg, backend_, cache, std::make_unique() diff --git a/tests/unit/etl/CorruptionDetectorTests.cpp b/tests/unit/etl/CorruptionDetectorTests.cpp index a85a2089b..845929e0b 100644 --- a/tests/unit/etl/CorruptionDetectorTests.cpp +++ b/tests/unit/etl/CorruptionDetectorTests.cpp @@ -14,7 +14,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 e1ddc7483..e8c75d360 100644 --- a/tests/unit/etl/CursorFromAccountProviderTests.cpp +++ b/tests/unit/etl/CursorFromAccountProviderTests.cpp @@ -18,16 +18,16 @@ namespace { constexpr auto kSeq = 30; -std::vector const kAccountRoots = { - 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 kAccountRoots = { + 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 f247c9b26..ce86146c9 100644 --- a/tests/unit/etl/CursorFromDiffProviderTests.cpp +++ b/tests/unit/etl/CursorFromDiffProviderTests.cpp @@ -19,52 +19,52 @@ namespace { constexpr auto kSeq = 30; std::vector const kDiffsForSeq = { - {.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"}, + {.key = xrpl::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, + {.key = xrpl::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, + {.key = xrpl::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, + {.key = xrpl::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, + {.key = xrpl::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, + {.key = xrpl::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, + {.key = xrpl::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, + {.key = xrpl::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB95"}, + {.key = xrpl::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB95"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F9D"}, + {.key = xrpl::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F9D"}, .blob = Blob{'s'}}, }; std::vector const kDiffsForSeqMinuS1 = { - {.key = ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, + {.key = xrpl::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD1301"}, + {.key = xrpl::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD1301"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E12"}, + {.key = xrpl::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E12"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F03"}, + {.key = xrpl::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F03"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, + {.key = xrpl::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, .blob = Blob{'s'}}, // This object is changed in both Seq and Seq-1 - {.key = ripple::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E05"}, + {.key = xrpl::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E05"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B386"}, + {.key = xrpl::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B386"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE447"}, + {.key = xrpl::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE447"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CED8"}, + {.key = xrpl::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CED8"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB99"}, + {.key = xrpl::uint256{"BC0DAE09C0BFBC4A49AA94B849266588BFD6E1F554B184B5788AC55D6E07EB99"}, .blob = Blob{'s'}}, - {.key = ripple::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F90"}, + {.key = xrpl::uint256{"DCC8759A35CB946511763AA5553A82AA25F20B901C98C9BB74D423BCFAFF5F90"}, .blob = Blob{'s'}}, }; diff --git a/tests/unit/etl/ETLServiceTests.cpp b/tests/unit/etl/ETLServiceTests.cpp index 3facf6182..57a31b4b5 100644 --- a/tests/unit/etl/ETLServiceTests.cpp +++ b/tests/unit/etl/ETLServiceTests.cpp @@ -90,7 +90,7 @@ struct MockLoader : etl::LoaderInterface { using ExpectedType = std::expected; MOCK_METHOD(ExpectedType, load, (etl::model::LedgerData const&), (override)); MOCK_METHOD( - std::optional, + std::optional, loadInitialLedger, (etl::model::LedgerData const&), (override) @@ -316,7 +316,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) .Times(1) .InSequence(s) diff --git a/tests/unit/etl/ETLStateTests.cpp b/tests/unit/etl/ETLStateTests.cpp index b49d74fd4..3db5702f6 100644 --- a/tests/unit/etl/ETLStateTests.cpp +++ b/tests/unit/etl/ETLStateTests.cpp @@ -8,7 +8,6 @@ #include -namespace json = boost::json; using namespace util; using namespace testing; @@ -26,7 +25,7 @@ TEST_F(ETLStateTest, Error) TEST_F(ETLStateTest, NetworkIdValid) { - auto const json = json::parse( + auto const json = boost::json::parse( R"JSON({ "result": { "info": { @@ -43,7 +42,7 @@ TEST_F(ETLStateTest, NetworkIdValid) TEST_F(ETLStateTest, NetworkIdInvalid) { - auto const json = json::parse( + auto const json = boost::json::parse( R"JSON({ "result": { "info": { @@ -60,7 +59,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 aa219a3a6..cd5b1f533 100644 --- a/tests/unit/etl/ExtractionTests.cpp +++ b/tests/unit/etl/ExtractionTests.cpp @@ -38,9 +38,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"}}, @@ -95,11 +95,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); } @@ -111,7 +111,7 @@ TEST_F(ExtractionModelTests, ObjectCopyableAndEquatable) { auto third = other; - third.key = ripple::uint256{42}; + third.key = xrpl::uint256{42}; EXPECT_NE(obj, third); } { @@ -181,7 +181,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(); @@ -199,7 +199,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(); @@ -237,8 +237,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::kLastKey)); EXPECT_EQ(res.successor, uint256ToString(data::kFirstKey)); EXPECT_EQ(res.type, expected.type); @@ -260,8 +260,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); @@ -290,8 +290,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::kLastKey)); EXPECT_EQ(obj.successor, uint256ToString(data::kFirstKey)); EXPECT_EQ(obj.type, expected.type); @@ -308,8 +308,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 1357a280c..d378756e2 100644 --- a/tests/unit/etl/GrpcSourceTests.cpp +++ b/tests/unit/etl/GrpcSourceTests.cpp @@ -57,8 +57,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_; @@ -71,7 +71,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)); } } @@ -82,7 +82,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); @@ -101,7 +101,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); @@ -179,7 +179,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 ce9683eb1..41b939257 100644 --- a/tests/unit/etl/LedgerPublisherTests.cpp +++ b/tests/unit/etl/LedgerPublisherTests.cpp @@ -84,7 +84,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{})); @@ -134,7 +134,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; @@ -177,13 +177,13 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderCloseTimeGreaterThanNow) auto const nowPlus10 = system_clock::now() + seconds(10); auto const closeTime = duration_cast(nowPlus10.time_since_epoch()).count() - kRippleEpochStart; - 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; @@ -261,7 +261,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 @@ -342,9 +342,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 77ae08f7e..ee745aa49 100644 --- a/tests/unit/etl/NFTHelpersTests.cpp +++ b/tests/unit/etl/NFTHelpersTests.cpp @@ -41,12 +41,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()); @@ -55,34 +55,34 @@ 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) { ASSERT_TRUE(data.uri.has_value()); // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - 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); @@ -92,16 +92,16 @@ protected: TEST_F(NFTHelpersTest, NFTDataFromFailedTx) { - auto const tx = createNftModifyTxWithMetadata(kAccount, kNftId, ripple::Blob{}); + auto const tx = createNftModifyTxWithMetadata(kAccount, kNftId, 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ); EXPECT_EQ(nftTxs.size(), 0); @@ -117,17 +117,17 @@ TEST_F(NFTHelpersTest, NotNFTTx) 1, 4321u, createPriceDataSeries( - {createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)} + {createOraclePriceData(1e3, xrpl::toCurrency("EUR"), xrpl::toCurrency("XRP"), 2)} ), kPageIndex, 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ); EXPECT_EQ(nftTxs.size(), 0); @@ -137,15 +137,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, kNftId, 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ); EXPECT_EQ(nftTxs.size(), 1); @@ -157,10 +156,9 @@ TEST_F(NFTHelpersTest, NFTModifyWithURI) TEST_F(NFTHelpersTest, NFTModifyWithoutURI) { - auto const tx = createNftModifyTxWithMetadata(kAccount, kNftId, 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, kNftId, 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); @@ -173,10 +171,9 @@ TEST_F(NFTHelpersTest, NFTModifyWithoutURI) TEST_F(NFTHelpersTest, NFTMintFromModifiedNode) { auto const tx = createMintNftTxWithMetadata(kAccount, 1, 20, 1, kNftId); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); - 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(kPageIndex)); + 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); @@ -192,11 +189,11 @@ TEST_F(NFTHelpersTest, NFTMintCantFindNewNFT) auto const tx = createMintNftTxWithMetadataOfCreatedNode( kAccount, 1, 20, 1, std::nullopt, std::nullopt, kPageIndex ); - 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -205,12 +202,11 @@ 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, kNftId, uri, kPageIndex); - 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); @@ -226,9 +222,8 @@ TEST_F(NFTHelpersTest, NFTMintWithoutUriField) auto const tx = createMintNftTxWithMetadataOfCreatedNode( kAccount, 1, 20, 1, kNftId, std::nullopt, kPageIndex ); - 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); @@ -244,12 +239,12 @@ TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) auto const tx = createMintNftTxWithMetadataOfCreatedNode( kAccount, 1, 20, 1, kNftId, std::nullopt, kPageIndex ); - 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -258,10 +253,9 @@ TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode) { auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kAccount, kNftId); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[1].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); - 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(kPageIndex)); + 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); @@ -274,12 +268,12 @@ TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode) TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) { auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kAccount, kNftId); - 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -288,11 +282,10 @@ TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromModifiedNode) { auto const tx = createNftBurnTxWithMetadataOfModifiedNode(kAccount, kNftId); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPageIndex)); - 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); @@ -307,10 +300,9 @@ TEST_F(NFTHelpersTest, NFTCancelOffer) auto const tx = createCancelNftOffersTxWithMetadata( kAccount, 1, 2, std::vector{kNftId, kNftID2} ); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPageIndex)); - 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(kPageIndex)); + 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); @@ -324,9 +316,8 @@ TEST_F(NFTHelpersTest, NFTCancelOfferContainsDuplicateNFTs) auto const tx = createCancelNftOffersTxWithMetadata( kAccount, 1, 2, std::vector{kNftID2, kNftId, kNftID2, kNftId} ); - 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); @@ -341,13 +332,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(kNftId, 3)); @@ -365,16 +356,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(kNftID2)); - EXPECT_EQ(uniqueNFTDatas[1].tokenID, ripple::uint256(kNftId)); + EXPECT_EQ(uniqueNFTDatas[0].tokenID, xrpl::uint256(kNftID2)); + EXPECT_EQ(uniqueNFTDatas[1].tokenID, xrpl::uint256(kNftId)); } TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) { auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kAccount, 1, 2, kNftId, kOfferId); - 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); @@ -389,13 +379,13 @@ TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) TEST_F(NFTHelpersTest, NFTAcceptBuyerOfferCheckOfferIDFail) { auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kAccount, 1, 2, kNftId, kOfferId); - 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(kPageIndex)); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPageIndex)); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -406,9 +396,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromCreatedNode) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, 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); @@ -424,9 +413,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromModifiedNode) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, 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); @@ -443,11 +431,11 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferCheckFail) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kAccount, 1, 2, kNftId, kOfferId, kPageIndex, 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -458,13 +446,13 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferNotInMeta) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kAccount, 1, 2, kNftId, kOfferId, kPageIndex, 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(kPageIndex)); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPageIndex)); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -475,12 +463,12 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferZeroMetaNode) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, 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()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -491,16 +479,16 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kAccount2, 1, 2, kNftId, kOfferId, kPageIndex, 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(kNftID2)); + .getField(xrpl::sfFinalFields) + .downcast() + .setFieldH256(xrpl::sfNFTokenID, xrpl::uint256(kNftID2)); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -509,9 +497,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) TEST_F(NFTHelpersTest, NFTCreateOffer) { auto const tx = createCreateNftOfferTxWithMetadata(kAccount, 1, 2, kNftId, 1, kOfferId); - 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); @@ -523,8 +510,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({{kNftId, url1}, {kNftID2, url2}}, std::nullopt); @@ -543,14 +530,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(kNftId)); + EXPECT_EQ(nftDatas[0].tokenID, xrpl::uint256(kNftId)); EXPECT_EQ(*(nftDatas[0].uri), uri1Blob); // NOLINT(bugprone-unchecked-optional-access) 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(kNftID2)); + EXPECT_EQ(nftDatas[1].tokenID, xrpl::uint256(kNftID2)); EXPECT_EQ(*(nftDatas[1].uri), uri2Blob); // NOLINT(bugprone-unchecked-optional-access) 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 27a3e190a..9b515f429 100644 --- a/tests/unit/etl/RegistryTests.cpp +++ b/tests/unit/etl/RegistryTests.cpp @@ -42,7 +42,7 @@ struct Ext4SpecMissing { }; struct Ext4Fixed { - using spec = etl::model::Spec; + using spec = etl::model::Spec; static void onTransaction(uint32_t, etl::model::Transaction const&); @@ -59,7 +59,7 @@ struct Ext6SpecMissing { }; struct Ext6Fixed { - using spec = etl::model::Spec; + using spec = etl::model::Spec; static void onInitialTransaction(uint32_t, etl::model::Transaction const&); @@ -67,11 +67,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&); @@ -98,13 +98,13 @@ 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); @@ -130,15 +130,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)); }; @@ -156,15 +156,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)); }; @@ -200,7 +200,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 @@ -236,7 +236,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 @@ -261,9 +261,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{}; @@ -290,9 +290,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{}; @@ -372,9 +372,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{}; @@ -417,9 +417,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; @@ -450,9 +450,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(), @@ -486,8 +486,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{}; @@ -513,8 +513,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{}; @@ -568,8 +568,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{}; @@ -595,8 +595,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{}; @@ -788,7 +788,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(), @@ -831,7 +831,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)); @@ -854,7 +854,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 d8317fa9b..417c0d245 100644 --- a/tests/unit/etl/TaskManagerTests.cpp +++ b/tests/unit/etl/TaskManagerTests.cpp @@ -46,7 +46,7 @@ struct MockLoader : etl::LoaderInterface { using ExpectedType = std::expected; MOCK_METHOD(ExpectedType, load, (LedgerData const&), (override)); MOCK_METHOD( - std::optional, + std::optional, loadInitialLedger, (LedgerData const&), (override) diff --git a/tests/unit/etl/ext/CoreTests.cpp b/tests/unit/etl/ext/CoreTests.cpp index 2027c1091..76a35c513 100644 --- a/tests/unit/etl/ext/CoreTests.cpp +++ b/tests/unit/etl/ext/CoreTests.cpp @@ -24,9 +24,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(kLedgerHash, kSeq); diff --git a/tests/unit/etl/ext/MPTTests.cpp b/tests/unit/etl/ext/MPTTests.cpp index 64664d695..79863e697 100644 --- a/tests/unit/etl/ext/MPTTests.cpp +++ b/tests/unit/etl/ext/MPTTests.cpp @@ -70,65 +70,65 @@ constinit auto const kHash3 = "6005B465CBBF7FA8E41AC0C0CD38491026D9411FCB7BA46E2 auto createTransactionFromObjects( - ripple::STObject const& txObj, - ripple::STObject const& metaObj, - ripple::TxType type + xrpl::STObject const& txObj, + xrpl::STObject const& metaObj, + xrpl::TxType type ) { auto const txBlob = txObj.getSerializer().peekData(); auto const metaBlob = metaObj.getSerializer().peekData(); - ripple::SerialIter txIter{txBlob.data(), txBlob.size()}; - ripple::uint256 const id{kHash}; + xrpl::SerialIter txIter{txBlob.data(), txBlob.size()}; + xrpl::uint256 const id{kHash}; return etl::model::Transaction{ .raw = "", .metaRaw = "", - .sttx = ripple::STTx{txIter}, - .meta = ripple::TxMeta{id, kSeq, metaBlob}, + .sttx = xrpl::STTx{txIter}, + .meta = xrpl::TxMeta{id, kSeq, metaBlob}, .id = id, .key = std::string{kHash}, .type = type }; } -ripple::STObject +xrpl::STObject createNewMPTokenNode(std::string_view holder) { - ripple::STObject newFields(ripple::sfNewFields); - newFields.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN); - newFields[ripple::sfMPTokenIssuanceID] = ripple::uint192{kMptIssuanceID}; - newFields.setAccountID(ripple::sfAccount, getAccountIdWithString(holder)); + xrpl::STObject newFields(xrpl::sfNewFields); + newFields.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN); + newFields[xrpl::sfMPTokenIssuanceID] = xrpl::uint192{kMptIssuanceID}; + newFields.setAccountID(xrpl::sfAccount, getAccountIdWithString(holder)); - ripple::STObject createdNode(ripple::sfCreatedNode); - createdNode.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN); - createdNode.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{}); - createdNode.emplace_back(std::move(newFields)); + xrpl::STObject createdNode(xrpl::sfCreatedNode); + createdNode.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN); + createdNode.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{}); + createdNode.set(std::move(newFields)); return createdNode; } -ripple::STObject -createPaymentMetaWithNewMPTokens(ripple::TER result = ripple::tesSUCCESS) +xrpl::STObject +createPaymentMetaWithNewMPTokens(xrpl::TER result = xrpl::tesSUCCESS) { - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldU8(ripple::sfTransactionResult, TERtoInt(result)); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldU8(xrpl::sfTransactionResult, TERtoInt(result)); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); - ripple::STArray affectedNodes(ripple::sfAffectedNodes); + xrpl::STArray affectedNodes(xrpl::sfAffectedNodes); affectedNodes.push_back(createNewMPTokenNode(kHolderAccount)); affectedNodes.push_back(createNewMPTokenNode(kHolderAccount2)); - metaObj.setFieldArray(ripple::sfAffectedNodes, affectedNodes); + metaObj.setFieldArray(xrpl::sfAffectedNodes, affectedNodes); return metaObj; } auto -createPaymentWithMultipleHoldersTestData(ripple::TER result = ripple::tesSUCCESS) +createPaymentWithMultipleHoldersTestData(xrpl::TER result = xrpl::tesSUCCESS) { auto transactions = std::vector{createTransactionFromObjects( createPaymentTransactionObject(kHolderAccount, kHolderAccount2, 1, 1, 1), createPaymentMetaWithNewMPTokens(result), - ripple::TxType::ttPAYMENT + xrpl::TxType::ttPAYMENT )}; auto const header = createLedgerHeader(kLedgerHash, kSeq); @@ -148,9 +148,9 @@ createTestDataWithoutMPToken() { auto transactions = std::vector{ util::createTransaction( - ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE + xrpl::TxType::ttMPTOKEN_ISSUANCE_CREATE ), // metadata does not create an MPT holder - util::createTransaction(ripple::TxType::ttAMM_CREATE), // metadata is not MPT + util::createTransaction(xrpl::TxType::ttAMM_CREATE), // metadata is not MPT }; auto const header = createLedgerHeader(kLedgerHash, kSeq); @@ -170,12 +170,12 @@ createTestData() { auto transactions = std::vector{ util::createTransaction( - ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE + xrpl::TxType::ttMPTOKEN_ISSUANCE_CREATE ), // metadata does not create an MPT holder - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash, kTxnMeta, kTxnHex), - util::createTransaction(ripple::TxType::ttAMM_CREATE), // metadata is not MPT + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHash, kTxnMeta, kTxnHex), + util::createTransaction(xrpl::TxType::ttAMM_CREATE), // metadata is not MPT util::createTransaction( - ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE + xrpl::TxType::ttMPTOKEN_ISSUANCE_CREATE ), // metadata does not create an MPT holder }; @@ -195,9 +195,9 @@ auto createMultipleHoldersTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash, kTxnMeta, kTxnHex), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash2, kTxnMeta, kTxnHex), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHash3, kTxnMeta, kTxnHex) + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHash, kTxnMeta, kTxnHex), + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHash2, kTxnMeta, kTxnHex), + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHash3, kTxnMeta, kTxnHex) }; auto const header = createLedgerHeader(kLedgerHash, kSeq); @@ -271,7 +271,7 @@ TEST_F(MPTExtTests, OnInitialDataWithMultipleHolders) TEST_F(MPTExtTests, OnInitialDataDoesNotWriteFailedMPTokenCreations) { - auto const data = createPaymentWithMultipleHoldersTestData(ripple::tecINCOMPLETE); + auto const data = createPaymentWithMultipleHoldersTestData(xrpl::tecINCOMPLETE); EXPECT_CALL(*backend_, writeMPTHolders).Times(0); @@ -290,7 +290,7 @@ TEST_F(MPTExtTests, OnInitialDataDoesNotWriteWithoutCreatedMPToken) TEST_F(MPTExtTests, OnInitialDataWritesAllMPTsCreatedByPayment) { auto const data = createPaymentWithMultipleHoldersTestData(); - auto const expectedMptID = ripple::uint192{kMptIssuanceID}; + auto const expectedMptID = xrpl::uint192{kMptIssuanceID}; auto const expectedAccount = getAccountIdWithString(kHolderAccount); auto const expectedAccount2 = getAccountIdWithString(kHolderAccount2); diff --git a/tests/unit/etl/ext/NFTTests.cpp b/tests/unit/etl/ext/NFTTests.cpp index a5ce62908..82b7e4c66 100644 --- a/tests/unit/etl/ext/NFTTests.cpp +++ b/tests/unit/etl/ext/NFTTests.cpp @@ -389,10 +389,10 @@ auto createTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN, kHash2, kTxnMetA2, kTxnHeX2), - 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, kTxnMetA2, kTxnHeX2), + 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(kLedgerHash, kSeq); diff --git a/tests/unit/etl/ext/SuccessorTests.cpp b/tests/unit/etl/ext/SuccessorTests.cpp index bd8228bec..4f23f8fc3 100644 --- a/tests/unit/etl/ext/SuccessorTests.cpp +++ b/tests/unit/etl/ext/SuccessorTests.cpp @@ -37,9 +37,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(kLedgerHash, kSeq); @@ -55,7 +55,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"); @@ -422,12 +422,12 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndNoSuccessor using namespace etl::model; auto const firstKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); auto const secondKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto const data = createInitialTestData({firstKey, secondKey}); - auto successorChain = std::queue(); + auto successorChain = std::queue(); successorChain.push(firstKey); successorChain.push(secondKey); @@ -455,7 +455,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndNoSuccessor // NOLINTBEGIN(bugprone-unchecked-optional-access) for (auto const& key : *data.edgeKeys) { - 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)); } @@ -469,12 +469,12 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndSuccessorsF using namespace etl::model; auto const firstKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); auto const secondKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto const data = createInitialTestData({firstKey, secondKey}); - auto successorChain = std::queue(); + auto successorChain = std::queue(); successorChain.push(firstKey); successorChain.push(secondKey); @@ -502,7 +502,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndSuccessorsF // NOLINTBEGIN(bugprone-unchecked-optional-access) for (auto const& key : *data.edgeKeys) { - 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))); @@ -517,12 +517,12 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsAndBookDirAndSuccessorsForE using namespace etl::model; auto const firstKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); auto const secondKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto const data = createInitialTestData({firstKey, secondKey}); - auto successorChain = std::queue(); + auto successorChain = std::queue(); successorChain.push(firstKey); successorChain.push(secondKey); @@ -562,7 +562,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsAndBookDirAndSuccessorsForE // NOLINTBEGIN(bugprone-unchecked-optional-access) for (auto const& key : *data.edgeKeys) { - 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))) @@ -608,7 +608,7 @@ TEST_F(SuccessorExtTests, OnInitialObjectsWithNonEmptyLastKey) using namespace etl::model; auto const lastKey = uint256ToString( - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960D") + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960D") ); auto const data = std::vector{ util::createObject( @@ -731,9 +731,9 @@ TEST_F(SuccessorExtAssertTests, OnInitialDataIsFullWithEdgeKeysButHasObjects) using namespace etl::model; auto const firstKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960C"); auto const secondKey = - ripple::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); + xrpl::uint256("B00AA769C00726371689ED66A7CF57C2502F1BF4BDFF2ACADF67A2A7B5E8960E"); auto data = createInitialTestData({firstKey, secondKey}); data.objects = {util::createObject()}; diff --git a/tests/unit/feed/BookChangesFeedTests.cpp b/tests/unit/feed/BookChangesFeedTests.cpp index 9f5b12d65..336b41ef2 100644 --- a/tests/unit/feed/BookChangesFeedTests.cpp +++ b/tests/unit/feed/BookChangesFeedTests.cpp @@ -34,11 +34,10 @@ TEST_F(FeedBookChangeTest, Pub) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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 d13fffad9..162f00e36 100644 --- a/tests/unit/feed/ForwardFeedTests.cpp +++ b/tests/unit/feed/ForwardFeedTests.cpp @@ -8,7 +8,6 @@ #include using namespace feed::impl; -namespace json = boost::json; using namespace util::prometheus; namespace { @@ -33,7 +32,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); @@ -49,7 +48,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 599f4842f..97740cf35 100644 --- a/tests/unit/feed/LedgerFeedTests.cpp +++ b/tests/unit/feed/LedgerFeedTests.cpp @@ -16,7 +16,6 @@ constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25 } // namespace using namespace feed::impl; -namespace json = boost::json; using namespace testing; using FeedLedgerTest = FeedBaseTest; @@ -49,7 +48,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(kLedgerResponse)); + EXPECT_EQ(res, boost::json::parse(kLedgerResponse)); }); ioContext.run(); EXPECT_EQ(testFeedPtr->count(), 1); @@ -71,7 +70,7 @@ TEST_F(FeedLedgerTest, SubPub) // test publish EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kLedgerPub))).Times(1); auto const ledgerHeader2 = createLedgerHeader(kLedgerHash, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; testFeedPtr->pub(ledgerHeader2, fee2, "10-31", 8, networkID); @@ -109,7 +108,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(kLedgerResponse)); + EXPECT_EQ(res, boost::json::parse(kLedgerResponse)); }); ioContext.run(); @@ -123,7 +122,7 @@ TEST_F(FeedLedgerTest, AutoDisconnect) EXPECT_EQ(testFeedPtr->count(), 0); auto const ledgerHeader2 = createLedgerHeader(kLedgerHash, 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 4695ba405..6db3e4151 100644 --- a/tests/unit/feed/ProposedTransactionFeedTests.cpp +++ b/tests/unit/feed/ProposedTransactionFeedTests.cpp @@ -56,7 +56,6 @@ constexpr auto kDummyTransactionV2 = } // namespace using namespace feed::impl; -namespace json = boost::json; using namespace util::prometheus; using FeedProposedTransactionTest = FeedBaseTest; @@ -68,12 +67,12 @@ TEST_F(FeedProposedTransactionTest, ProposedTransaction) EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 0); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransaction) @@ -93,13 +92,13 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransaction) EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); // unsub testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, SubStreamAndAccount) @@ -114,20 +113,20 @@ TEST_F(FeedProposedTransactionTest, SubStreamAndAccount) EXPECT_EQ(testFeedPtr->transactionSubcount(), 1); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))).Times(2); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); // unsub testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); // unsub transaction testFeedPtr->unsub(sessionPtr); EXPECT_EQ(testFeedPtr->transactionSubcount(), 0); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate) @@ -141,19 +140,19 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate) EXPECT_EQ(testFeedPtr->accountSubCount(), 2); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); // unsub account1 testFeedPtr->unsub(account, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 1); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); // unsub account2 testFeedPtr->unsub(account2, sessionPtr); EXPECT_EQ(testFeedPtr->accountSubCount(), 0); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, Count) @@ -264,10 +263,10 @@ TEST_F(FeedProposedTransactionTest, ProposedTransactionV2) testFeedPtr->sub(sessionPtr); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); testFeedPtr->unsub(sessionPtr); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransactionV2) @@ -279,10 +278,10 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransactionV2) testFeedPtr->sub(account, sessionPtr); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); testFeedPtr->unsub(account, sessionPtr); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, MixedVersionSubscribers) @@ -299,7 +298,7 @@ TEST_F(FeedProposedTransactionTest, MixedVersionSubscribers) EXPECT_CALL(*mockSessionV2Ptr, apiSubversion).WillOnce(testing::Return(2u)); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransaction))); EXPECT_CALL(*mockSessionV2Ptr, send(sharedStringJsonEq(kDummyTransactionV2))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicateV2) @@ -314,7 +313,7 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicateV2) // Both accounts are affected; v2 subscriber should receive the message only once (dedup) EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2u)); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } TEST_F(FeedProposedTransactionTest, SubStreamAndAccountV2) @@ -328,7 +327,7 @@ TEST_F(FeedProposedTransactionTest, SubStreamAndAccountV2) // Subscribed to both stream and account: receives message twice (matches v1 behaviour) EXPECT_CALL(*mockSessionPtr, apiSubversion).WillRepeatedly(testing::Return(2u)); EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDummyTransactionV2))).Times(2); - testFeedPtr->pub(json::parse(kDummyTransaction).get_object()); + testFeedPtr->pub(boost::json::parse(kDummyTransaction).get_object()); } struct ProposedTransactionFeedMockPrometheusTest : WithMockPrometheus, SyncExecutionCtxFixture { diff --git a/tests/unit/feed/SubscriptionManagerTests.cpp b/tests/unit/feed/SubscriptionManagerTests.cpp index 1f0709940..f7b9b7c65 100644 --- a/tests/unit/feed/SubscriptionManagerTests.cpp +++ b/tests/unit/feed/SubscriptionManagerTests.cpp @@ -39,7 +39,6 @@ constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25 } // namespace -namespace json = boost::json; using namespace feed; using namespace feed::impl; using namespace data; @@ -83,8 +82,8 @@ TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtx) EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(testing::AtMost(2)); - subscriptionManagerPtr_->forwardManifest(json::parse(kJsonManifest).get_object()); - subscriptionManagerPtr_->forwardValidation(json::parse(kJsonValidation).get_object()); + subscriptionManagerPtr_->forwardManifest(boost::json::parse(kJsonManifest).get_object()); + subscriptionManagerPtr_->forwardValidation(boost::json::parse(kJsonValidation).get_object()); } TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtxSessionDieEarly) @@ -98,10 +97,10 @@ TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtxSessionDieEarly) session_.reset(); subscriptionManagerPtr_->forwardManifest( - json::parse(R"JSON({"manifest": "test"})JSON").get_object() + boost::json::parse(R"JSON({"manifest": "test"})JSON").get_object() ); subscriptionManagerPtr_->forwardValidation( - json::parse(R"JSON({"validation": "test"})JSON").get_object() + boost::json::parse(R"JSON({"validation": "test"})JSON").get_object() ); } @@ -151,10 +150,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(kReportReturn)); + EXPECT_EQ(subscriptionManagerPtr_->report(), boost::json::parse(kReportReturn)); // count down when unsub manually subscriptionManagerPtr_->unsubBookChanges(session1); @@ -170,7 +169,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); @@ -196,11 +195,11 @@ TEST_F(SubscriptionManagerTest, ManifestTest) EXPECT_CALL(*sessionPtr_, onDisconnect); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummyManifest))); subscriptionManagerPtr_->subManifest(session_); - subscriptionManagerPtr_->forwardManifest(json::parse(kDummyManifest).get_object()); + subscriptionManagerPtr_->forwardManifest(boost::json::parse(kDummyManifest).get_object()); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummyManifest))).Times(0); subscriptionManagerPtr_->unsubManifest(session_); - subscriptionManagerPtr_->forwardManifest(json::parse(kDummyManifest).get_object()); + subscriptionManagerPtr_->forwardManifest(boost::json::parse(kDummyManifest).get_object()); } TEST_F(SubscriptionManagerTest, ValidationTest) @@ -209,11 +208,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) @@ -225,11 +224,10 @@ TEST_F(SubscriptionManagerTest, BookChangesTest) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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 kBookChangePublish = @@ -289,14 +287,14 @@ TEST_F(SubscriptionManagerTest, LedgerTest) EXPECT_CALL(*sessionPtr_, onDisconnect); auto const res = subscriptionManagerPtr_->subLedger(yield, session_); // check the response - EXPECT_EQ(res, json::parse(kLedgerResponse)); + EXPECT_EQ(res, boost::json::parse(kLedgerResponse)); }); ctx.run(); EXPECT_EQ(subscriptionManagerPtr_->report()["ledger"], 1); // test publish auto const ledgerHeader2 = createLedgerHeader(kLedgerHash, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; static constexpr auto kLedgerPub = R"JSON({ @@ -323,7 +321,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_); @@ -477,7 +475,7 @@ TEST_F(SubscriptionManagerTest, ProposedTransactionTest) EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDummyTransaction))).Times(2); EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kOrderbookPublish))).Times(2); subscriptionManagerPtr_->forwardProposedTransaction( - json::parse(kDummyTransaction).get_object() + boost::json::parse(kDummyTransaction).get_object() ); auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); diff --git a/tests/unit/feed/TransactionFeedTests.cpp b/tests/unit/feed/TransactionFeedTests.cpp index 65e506940..d1956f790 100644 --- a/tests/unit/feed/TransactionFeedTests.cpp +++ b/tests/unit/feed/TransactionFeedTests.cpp @@ -220,7 +220,7 @@ TEST_F(FeedTransactionTest, SubTransactionV1) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -244,7 +244,7 @@ TEST_F(FeedTransactionTest, SubTransactionForProposedTx) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -267,7 +267,7 @@ TEST_F(FeedTransactionTest, SubTransactionV2) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -295,7 +295,7 @@ TEST_F(FeedTransactionTest, SubAccountV1) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -323,7 +323,7 @@ TEST_F(FeedTransactionTest, SubForProposedAccount) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -348,7 +348,7 @@ TEST_F(FeedTransactionTest, SubAccountV2) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -377,7 +377,7 @@ TEST_F(FeedTransactionTest, SubBothTransactionAndAccount) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -399,7 +399,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); @@ -588,7 +588,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); @@ -681,7 +681,7 @@ TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -720,7 +720,7 @@ TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -756,7 +756,7 @@ TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -817,7 +817,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); @@ -842,33 +842,33 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = + 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{kTxnId}); - 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{kTxnId}); + 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, kTxnId, 3); + xrpl::STObject const accountRoot = createAccountRootObject(kIssuer, 0, 1, 10, 2, kTxnId, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -984,32 +984,32 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = + 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{kTxnId}); - 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{kTxnId}); + 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, kTxnId, 3); + xrpl::STObject const accountRoot = createAccountRootObject(kIssuer, 0, 1, 10, 2, kTxnId, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -1025,33 +1025,33 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = + 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{kTxnId}); - 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{kTxnId}); + 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, kTxnId, 3); + xrpl::STObject const accountRoot = + createAccountRootObject(kIssuer, xrpl::lsfGlobalFreeze, 1, 10, 2, kTxnId, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -1073,7 +1073,7 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -1102,7 +1102,7 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidated) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -1126,7 +1126,7 @@ TEST_F(FeedTransactionTest, SubProposedDisconnect) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -1151,7 +1151,7 @@ TEST_F(FeedTransactionTest, SubProposedAccountDisconnect) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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) @@ -1175,37 +1175,37 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = + xrpl::STObject const obj = createCreateOfferTransactionObject(kAccount1, 1, 32, kLptokenCurrency, kAmmAccount, 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{kTxnId}); - 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{kTxnId}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, 0); auto const issue2 = getIssue(kLptokenCurrency, kAmmAccount); - 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(kAmmAccount); - auto const kk = ripple::keylet::account(ammAccount).key; - ripple::STObject const ammAccountRoot = + auto const kk = xrpl::keylet::account(ammAccount).key; + xrpl::STObject const ammAccountRoot = createAccountRootObject(kAmmAccount, 0, 1, 10, 2, kTxnId, 3, 0, ammID); EXPECT_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .Times(2) @@ -1255,21 +1255,20 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) ) .WillOnce(testing::Return(true)); - auto const ammObj = createAmmObject( - kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), kCurrency, kIssuer - ); + auto const ammObj = + createAmmObject(kAmmAccount, "XRP", xrpl::toBase58(xrpl::xrpAccount()), kCurrency, kIssuer); EXPECT_CALL( - *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) + *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 = + xrpl::STObject const issuerAccountRoot = createAccountRootObject(kIssuer, 4194304, 1, 10, 2, kTxnId, 3); EXPECT_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(issuerAccount).key, testing::_, testing::_) + doFetchLedgerObject(xrpl::keylet::account(issuerAccount).key, testing::_, testing::_) ) .WillOnce(testing::Return(issuerAccountRoot.getSerializer().peekData())); @@ -1392,7 +1391,7 @@ TEST_F(FeedTransactionTest, PublishesMPTokenAuthorizeTx) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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)); @@ -1435,7 +1434,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_); @@ -1468,7 +1467,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 2d3e5ea4c..85aeb0ad9 100644 --- a/tests/unit/rpc/APIVersionTests.cpp +++ b/tests/unit/rpc/APIVersionTests.cpp @@ -16,7 +16,6 @@ constexpr auto kMaxApiVersion = 10u; using namespace util::config; using namespace rpc::impl; -namespace json = boost::json; class RPCAPIVersionTest : public virtual ::testing::Test { protected: @@ -25,35 +24,37 @@ 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(), kDefaultApiVersion); } 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); } } @@ -61,17 +62,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); } @@ -88,33 +89,38 @@ 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(), kDefaultApiVersion); } { - 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 1d08c113e..6dd320ca6 100644 --- a/tests/unit/rpc/AmendmentsTests.cpp +++ b/tests/unit/rpc/AmendmentsTests.cpp @@ -9,7 +9,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 d2d2a74af..0c09ea4aa 100644 --- a/tests/unit/rpc/BaseTests.cpp +++ b/tests/unit/rpc/BaseTests.cpp @@ -28,20 +28,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)); @@ -49,12 +47,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)); @@ -62,14 +60,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)); @@ -77,50 +75,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()); } @@ -133,10 +131,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", @@ -147,27 +145,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)); } } @@ -179,13 +177,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)); } @@ -195,13 +193,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)); } @@ -211,19 +209,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)); } @@ -233,13 +231,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)); } @@ -251,7 +249,7 @@ TEST_F(RPCBaseTest, MinValidatorAfterType) {"amount3", Type{}, Min{std::numeric_limits::min()}}, }; - auto bigInput = json::parse( + 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 @@ -263,13 +261,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)); } @@ -281,7 +279,7 @@ TEST_F(RPCBaseTest, MaxValidatorAfterType) {"amount3", Type{}, Max{std::numeric_limits::min()}}, }; - auto bigInput = json::parse( + 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 @@ -293,13 +291,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)); } @@ -309,10 +307,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)); } @@ -321,7 +319,7 @@ TEST_F(RPCBaseTest, ArrayAtValidator) auto spec = RpcSpec{ {"arr", Required{}, - Type{}, + Type{}, ValidateArrayAt{ 0, { @@ -338,16 +336,17 @@ 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)); } @@ -356,42 +355,43 @@ 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( + passingInput = 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)); } @@ -401,32 +401,32 @@ TEST_F(RPCBaseTest, WithCustomError) {"transaction", WithCustomError{ CustomValidators::uint256HexStringValidator, - rpc::Status{ripple::rpcBAD_FEATURE, "MyCustomError"} + rpc::Status{xrpl::RpcBadFeature, "MyCustomError"} }}, {"other", WithCustomError{ - Type{}, rpc::Status{ripple::rpcALREADY_MULTISIG, "MyCustomError2"} + 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( + 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) @@ -435,51 +435,53 @@ 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 { + 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)); } @@ -490,13 +492,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)); } @@ -505,21 +507,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"); @@ -530,25 +532,27 @@ 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( + 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"); + boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })JSON"); ASSERT_TRUE(spec.process(passingInput)); - passingInput = json::parse( + passingInput = boost::json::parse( R"JSON({ "account": "020000000000000000000000000000000000000000000000000000000000000000" })JSON" ); ASSERT_TRUE(spec.process(passingInput)); @@ -559,22 +563,24 @@ 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( + 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"); + boost::json::parse(R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })JSON"); ASSERT_TRUE(spec.process(passingInput)); } @@ -583,16 +589,16 @@ 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)); } @@ -600,16 +606,17 @@ TEST_F(RPCBaseTest, Uint160HexStringValidator) { auto const spec = RpcSpec{{"marker", CustomValidators::uint160HexStringValidator}}; auto passingInput = - json::parse(R"JSON({ "marker": "F609A18102218C75767209946A77523CBD97E225"})JSON"); + 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"); @@ -618,17 +625,17 @@ TEST_F(RPCBaseTest, Uint160HexStringValidator) TEST_F(RPCBaseTest, Uint192HexStringValidator) { auto const spec = RpcSpec{{"mpt_issuance_id", CustomValidators::uint192HexStringValidator}}; - auto passingInput = json::parse( + auto passingInput = 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( + failingInput = boost::json::parse( R"JSON({ "mpt_issuance_id": "0000012F27A9DE73EAA1E8831FA253E19030A17E2D038198983515BC"})JSON" ); err = spec.process(failingInput); @@ -639,17 +646,17 @@ TEST_F(RPCBaseTest, Uint192HexStringValidator) TEST_F(RPCBaseTest, Uint256HexStringValidator) { auto const spec = RpcSpec{{"transaction", CustomValidators::uint256HexStringValidator}}; - auto passingInput = json::parse( + 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( + failingInput = boost::json::parse( R"JSON({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC"})JSON" ); err = spec.process(failingInput); @@ -660,28 +667,29 @@ 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"); + boost::json::parse(R"JSON({ "currency": "0158415500000000C1F76FF6ECB0BAC600000000"})JSON"); ASSERT_TRUE(spec.process(passingInput)); passingInput = - json::parse(R"JSON({ "currency": "0158415500000000c1f76ff6ecb0bac600000000"})JSON"); + 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"); @@ -690,16 +698,18 @@ 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); } @@ -707,7 +717,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", @@ -722,15 +732,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); } @@ -738,20 +748,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); } @@ -762,14 +772,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 } @@ -780,18 +790,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(), ""); } @@ -802,29 +812,30 @@ 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> + testing::StrictMock< + testing::MockFunction> mockModifier; auto const customModifier = CustomModifier{mockModifier.AsStdFunction()}; auto const spec = RpcSpec{ @@ -832,13 +843,13 @@ TEST_F(RPCBaseTest, 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 553541501..2f7866254 100644 --- a/tests/unit/rpc/ErrorTests.cpp +++ b/tests/unit/rpc/ErrorTests.cpp @@ -48,18 +48,18 @@ check( TEST(RPCErrorsTest, StatusAsBool) { - // Only rpcSUCCESS status should return false - EXPECT_FALSE(Status{RippledError::rpcSUCCESS}); + // Only RpcSuccess status should return false + 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, }; @@ -69,21 +69,21 @@ 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}; + auto const status = Status{RippledError::RpcInvalidParams}; check( - makeError(status), "invalidParams", RippledError::rpcINVALID_PARAMS, "Invalid parameters." + makeError(status), "invalidParams", RippledError::RpcInvalidParams, "Invalid parameters." ); } @@ -95,14 +95,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) @@ -223,7 +223,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{ @@ -244,7 +244,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 c7fd322e0..396bfb5eb 100644 --- a/tests/unit/rpc/ForwardingProxyTests.cpp +++ b/tests/unit/rpc/ForwardingProxyTests.cpp @@ -26,7 +26,6 @@ using namespace rpc; using namespace testing; using namespace util::config; -namespace json = boost::json; namespace { constexpr auto kClientIp = "127.0.0.1"; @@ -264,7 +263,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)); @@ -294,14 +293,14 @@ 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(kClientIp), true, _) ) - .WillOnce(Return(json::object{})); + .WillOnce(Return(boost::json::object{})); EXPECT_CALL(*rawHandlerProviderPtr, contains(method)).WillOnce(Return(true)); @@ -332,8 +331,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, diff --git a/tests/unit/rpc/JsonBoolTests.cpp b/tests/unit/rpc/JsonBoolTests.cpp index 0c0198a92..95a546cb3 100644 --- a/tests/unit/rpc/JsonBoolTests.cpp +++ b/tests/unit/rpc/JsonBoolTests.cpp @@ -9,7 +9,6 @@ #include using namespace rpc; -namespace json = boost::json; using namespace testing; struct JsonBoolTestsCaseBundle { @@ -77,7 +76,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 986f41fb5..8b7733c14 100644 --- a/tests/unit/rpc/RPCEngineTests.cpp +++ b/tests/unit/rpc/RPCEngineTests.cpp @@ -39,7 +39,6 @@ using namespace data; using namespace rpc; using namespace util; -namespace json = boost::json; using namespace testing; using namespace util::config; @@ -129,7 +128,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, @@ -139,7 +138,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, @@ -149,7 +148,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, @@ -199,7 +198,7 @@ TEST_P(RPCEngineFlowParameterTest, Test) EXPECT_CALL(*mockLoadBalancerPtr_, forwardToRippled) .WillOnce(Return( std::expected( - json::parse(kForwardReply).as_object() + boost::json::parse(kForwardReply).as_object() ) )); EXPECT_CALL(*handlerProvider, contains).WillOnce(Return(true)); @@ -282,7 +281,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}); }); } @@ -314,7 +313,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}); }); } @@ -400,7 +399,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 011438243..5bc605abd 100644 --- a/tests/unit/rpc/RPCHelpersTests.cpp +++ b/tests/unit/rpc/RPCHelpersTests.cpp @@ -88,7 +88,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(); @@ -102,7 +102,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(); @@ -112,18 +112,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 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); @@ -146,15 +146,15 @@ 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 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kIndex1); @@ -162,8 +162,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())); @@ -184,19 +184,19 @@ 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 kNextPage = 99; static constexpr auto kLimit = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNextPage).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; int objectsCount = 10; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kIndex1); @@ -208,14 +208,14 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNextPage); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNextPage); // 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())); @@ -237,7 +237,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 kPageNum = 99; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -245,9 +245,9 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker) std::vector bbs; int objectsCount = 10; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kIndex1); @@ -259,8 +259,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())); @@ -291,22 +291,22 @@ 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 kPageNum = 99; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); int objectsCount = 10; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); - std::vector indexes; + 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())); @@ -323,7 +323,7 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithUnexistingIndexMarker) [&](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(); @@ -533,7 +533,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 @@ -562,7 +562,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, kLedgerSeqObject, _)) @@ -571,7 +571,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist) runSpawn([&](boost::asio::yield_context yield) { // return false: blob doesn't exist EXPECT_FALSE(fetchAndCheckAnyFlagsExists( - *backend_, kLedgerSeqObject, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLedgerSeqObject, issuerKey, {xrpl::lsfHighDeepFreeze}, yield )); }); } @@ -579,11 +579,11 @@ 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, kTxnId, 3); + createAccountRootObject(kAccount, xrpl::lsfHighDeepFreeze, 1, 10, 2, kTxnId, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -591,7 +591,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_AccountWithCorrectFlag) runSpawn([&](boost::asio::yield_context yield) { // returns true: accountObject has the highDeepFreeze flag EXPECT_TRUE(fetchAndCheckAnyFlagsExists( - *backend_, kLedgerSeqObject, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLedgerSeqObject, issuerKey, {xrpl::lsfHighDeepFreeze}, yield )); }); } @@ -599,11 +599,11 @@ 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, kTxnId, 3); + createAccountRootObject(kAccount, xrpl::lsfLowDeepFreeze, 1, 10, 2, kTxnId, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -611,7 +611,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_TrustLineIsFrozenAndCheckFreez runSpawn([&](boost::asio::yield_context yield) { // returns false: accountObject has the lowDeepFreeze flag EXPECT_FALSE(fetchAndCheckAnyFlagsExists( - *backend_, kLedgerSeqObject, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLedgerSeqObject, issuerKey, {xrpl::lsfHighDeepFreeze}, yield )); }); } @@ -619,10 +619,10 @@ 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, kTxnId, 3); + createAccountRootObject(kAccount, xrpl::lsfGlobalFreeze, 1, 10, 2, kTxnId, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -639,10 +639,9 @@ 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, kLedgerSeqObject, _)) @@ -650,7 +649,7 @@ TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsDeepFrozen) runSpawn([&](boost::asio::yield_context yield) { EXPECT_TRUE(isDeepFrozen( - *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account2, yield + *backend_, kLedgerSeqObject, account, xrpl::Currency{kCurrency}, account2, yield )); }); } @@ -661,10 +660,9 @@ 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, kLedgerSeqObject, _)) @@ -672,7 +670,7 @@ TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsNotDeepFrozen) runSpawn([&](boost::asio::yield_context yield) { EXPECT_FALSE(isDeepFrozen( - *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account2, yield + *backend_, kLedgerSeqObject, account, xrpl::Currency{kCurrency}, account2, yield )); }); } @@ -682,10 +680,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, kLedgerSeqObject, _)) @@ -694,7 +691,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_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account, yield + *backend_, kLedgerSeqObject, account, xrpl::Currency{kCurrency}, account, yield )); }); } @@ -705,16 +702,16 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerAccountIsGlobalFrozen) auto const issuer = getAccountIdWithString(kAccount2); auto const accountObject = - createAccountRootObject(kAccount2, ripple::lsfGlobalFreeze, 1, 10, 2, kTxnId, 3); - auto const issuerKey = ripple::keylet::account(issuer).key; + createAccountRootObject(kAccount2, xrpl::lsfGlobalFreeze, 1, 10, 2, kTxnId, 3); + auto const issuerKey = xrpl::keylet::account(issuer).key; ON_CALL(*backend_, doFetchLedgerObject(issuerKey, kLedgerSeqObject, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { - EXPECT_TRUE(isFrozen( - *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, issuer, yield - )); + EXPECT_TRUE( + isFrozen(*backend_, kLedgerSeqObject, account, xrpl::Currency{kCurrency}, issuer, yield) + ); }); } @@ -723,10 +720,9 @@ 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, kLedgerSeqObject, _)) @@ -734,7 +730,7 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerAndAccountIsSameWillNotBeFrozen) runSpawn([&](boost::asio::yield_context yield) { EXPECT_FALSE(isFrozen( - *backend_, kLedgerSeqObject, account, ripple::Currency{kCurrency}, account, yield + *backend_, kLedgerSeqObject, account, xrpl::Currency{kCurrency}, account, yield )); }); } @@ -743,13 +739,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, kLedgerSeqObject, _)) @@ -764,13 +760,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, kLedgerSeqObject, _)) @@ -785,9 +781,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, kTxnId, 1, 0 ); @@ -807,7 +803,7 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineNotfrozen) 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)); }); } @@ -815,9 +811,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, kLedgerSeqObject, _)) @@ -835,7 +831,7 @@ TEST_F(RPCHelpersTest, AccountHolds_NoTrustLine) 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)); }); } @@ -843,13 +839,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, kTxnId, 1, ripple::lsfHighFreeze + kCurrency, kAccount2, 500, kAccount, 1000, kAccount2, 1000, kTxnId, 1, xrpl::lsfHighFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLedgerSeqObject, _)) @@ -866,7 +862,7 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineButFrozen) true, yield ); - EXPECT_EQ(result, ripple::STAmount(getIssue(kCurrency, kAccount2), 0)); + EXPECT_EQ(result, xrpl::STAmount(getIssue(kCurrency, kAccount2), 0)); }); } @@ -879,15 +875,15 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; + xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLptokenCurrency)).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{kAmmId}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAmmId}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); @@ -906,7 +902,7 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLptokenCurrency), + xrpl::toCurrency(kLptokenCurrency), ammAccount, true, yield @@ -925,7 +921,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) "USD", kAccount2, 100, kAccount, 100, kAccount2, 100, kTxnId, 3 ); auto const usdRippleStateKk = - ripple::keylet::line(account2, account, ripple::to_currency("USD")).key; + 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::_)) @@ -938,7 +934,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) ) .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::_)) @@ -951,7 +947,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency("USD"), + xrpl::toCurrency("USD"), account2, true, yield @@ -971,7 +967,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; + xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLptokenCurrency)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -984,8 +980,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) ) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAmmId}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAmmId}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); @@ -995,16 +991,16 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); auto const amm = - createAmmObject(kAmmAccount, "USD", kIssuer, "XRP", ripple::toBase58(ripple::xrpAccount())); + createAmmObject(kAmmAccount, "USD", kIssuer, "XRP", xrpl::toBase58(xrpl::xrpAccount())); EXPECT_CALL( - *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) + *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 issuerKk = xrpl::keylet::account(issuer).key; auto const issuerAccountRoot = - createAccountRootObject(kIssuer, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, 0); + createAccountRootObject(kIssuer, xrpl::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); @@ -1014,7 +1010,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLptokenCurrency), + xrpl::toCurrency(kLptokenCurrency), ammAccount, true, yield @@ -1034,7 +1030,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; + xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLptokenCurrency)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)).Times(2); @@ -1047,8 +1043,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) ) .WillOnce(testing::Return(true)); - auto const ammID = ripple::uint256{kAmmId}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAmmId}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); @@ -1058,15 +1054,15 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); auto const amm = - createAmmObject(kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kIssuer); + createAmmObject(kAmmAccount, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "USD", kIssuer); EXPECT_CALL( - *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) + *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, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, 0); + createAccountRootObject(kIssuer, xrpl::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, 0); EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_)) .WillOnce(Return(issuerAccountRoot.getSerializer().peekData())); @@ -1076,7 +1072,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLptokenCurrency), + xrpl::toCurrency(kLptokenCurrency), ammAccount, true, yield @@ -1096,7 +1092,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) kLptokenCurrency, kAmmAccount, 100, kAccount, 100, kAmmAccount, 100, kTxnId, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLptokenCurrency)).key; + xrpl::keylet::line(ammAccount, account, xrpl::toCurrency(kLptokenCurrency)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -1109,8 +1105,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) ) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAmmId}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAmmId}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2, 0, ammID); @@ -1120,21 +1116,20 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); auto const amm = - createAmmObject(kAmmAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kIssuer); + createAmmObject(kAmmAccount, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "USD", kIssuer); EXPECT_CALL( - *backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_) + *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, kTxnId, 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())); @@ -1145,7 +1140,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLptokenCurrency), + xrpl::toCurrency(kLptokenCurrency), ammAccount, true, yield diff --git a/tests/unit/rpc/handlers/AMMInfoTests.cpp b/tests/unit/rpc/handlers/AMMInfoTests.cpp index 51a02282d..fe02f11b7 100644 --- a/tests/unit/rpc/handlers/AMMInfoTests.cpp +++ b/tests/unit/rpc/handlers/AMMInfoTests.cpp @@ -27,7 +27,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -138,7 +137,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); @@ -161,7 +160,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": "{}", @@ -189,7 +188,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": "{}" @@ -214,7 +213,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": "{}" @@ -243,7 +242,7 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountNotFoundMissingAmmField) 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": "{}" @@ -267,14 +266,14 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAmmBlobNotFound) { auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); auto const accountKey = getAccountKey(kAmmAccount); - auto const ammId = ripple::uint256{kAmmId}; - auto const ammKeylet = ripple::keylet::amm(ammId); + auto const ammId = xrpl::uint256{kAmmId}; + auto const ammKeylet = xrpl::keylet::amm(ammId); auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( - kAmmAccounT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAmmAccounT2 + kAmmAccounT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAmmAccounT2 ); - accountRoot.setFieldH256(ripple::sfAMMID, ripple::uint256{kAmmId}); + accountRoot.setFieldH256(xrpl::sfAMMID, xrpl::uint256{kAmmId}); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) @@ -282,7 +281,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": "{}" @@ -307,14 +306,14 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAccBlobNotFound) auto const lgrInfo = createLedgerHeader(kLedgerHash, 30); auto const accountKey = getAccountKey(kAmmAccount); auto const account2Key = getAccountKey(kAmmAccounT2); - auto const ammId = ripple::uint256{kAmmId}; - auto const ammKeylet = ripple::keylet::amm(ammId); + auto const ammId = xrpl::uint256{kAmmId}; + auto const ammKeylet = xrpl::keylet::amm(ammId); auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto const ammObj = createAmmObject( - kAmmAccounT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAmmAccounT2 + kAmmAccounT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAmmAccounT2 ); - accountRoot.setFieldH256(ripple::sfAMMID, ammId); + accountRoot.setFieldH256(xrpl::sfAMMID, ammId); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) @@ -324,7 +323,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": "{}" @@ -349,22 +348,21 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( kAmmAccount, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAmmAccounT2, kLpIssueCurrency ); - 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)); @@ -378,7 +376,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) 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": "{}" @@ -390,7 +388,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": {{ @@ -432,25 +430,24 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const account2Root = createAccountRootObject(kAmmAccounT2, 0, 2, 300, 2, kIndex1, 2); auto const ammObj = createAmmObject( kAmmAccounT2, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAmmAccount, kLpIssueCurrency ); 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( kLpIssueCurrency, kAmmAccount, 12, kAmmAccounT2, 1000, kAmmAccount, 2000, kIndex1, 2 @@ -469,7 +466,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 +480,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,11 +522,10 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( @@ -537,10 +533,10 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) "JPY", kAmmAccounT2, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), kLpIssueCurrency ); - 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)); @@ -554,7 +550,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) 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": "{}" @@ -566,7 +562,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": {{ @@ -608,16 +604,15 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject(kAmmAccount, "USD", kAmmAccount, "JPY", kAmmAccounT2, kLpIssueCurrency); - 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)); @@ -631,7 +626,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) 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": "{}" @@ -643,7 +638,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": {{ @@ -692,18 +687,16 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject(kAmmAccount, "USD", kAmmAccount, "JPY", kAmmAccounT2, kLpIssueCurrency); - 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 @@ -717,7 +710,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) 2000, kIndex1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( "JPY", @@ -729,7 +722,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) 2000, kIndex1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -745,7 +738,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": "{}" @@ -757,7 +750,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": {{ @@ -806,20 +799,18 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2); + createAccountRootObject(kAmmAccount, xrpl::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject(kAmmAccount, "USD", kAmmAccount, "JPY", kAmmAccounT2, kLpIssueCurrency); - 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 @@ -833,7 +824,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) 2000, kIndex1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( "JPY", @@ -845,7 +836,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) 2000, kIndex1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -861,7 +852,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": "{}" @@ -873,7 +864,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": {{ @@ -922,22 +913,21 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( kAmmAccount, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAmmAccounT2, kLpIssueCurrency ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject( "JPY", kAmmAccounT2, -8, kAmmAccount, 1000, kAmmAccounT2, 2000, kIndex2, 2, 0 @@ -954,7 +944,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": "{}" @@ -966,7 +956,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": {{ @@ -1008,24 +998,23 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( kAmmAccount, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAmmAccounT2, kLpIssueCurrency ); 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", kAmmAccounT2, -8, kAmmAccount, 1000, kAmmAccounT2, 2000, kIndex2, 2, 0 @@ -1042,7 +1031,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": "{}" @@ -1054,7 +1043,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": {{ @@ -1110,17 +1099,16 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); - auto const ammKey = ripple::uint256{kAmmId}; - 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{kAmmId}; + 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject( kAmmAccount, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAmmAccounT2, kLpIssueCurrency @@ -1128,13 +1116,13 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) ammSetAuctionSlot( ammObj, account2, - ripple::amountFromString(ripple::xrpIssue(), "100"), + 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", kAmmAccounT2, -8, kAmmAccount, 1000, kAmmAccounT2, 2000, kIndex2, 2, 0 @@ -1151,7 +1139,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": "{}" @@ -1163,7 +1151,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": {{ @@ -1223,23 +1211,23 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); - 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(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); auto ammObj = createAmmObject(kAmmAccount, "JPY", kAmmAccount, "USD", kAmmAccounT2, kLpIssueCurrency); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLpIssueCurrency}, account1}; + auto const auctionIssue = xrpl::Issue{xrpl::Currency{kLpIssueCurrency}, account1}; ammSetAuctionSlot( ammObj, account2, - ripple::amountFromString(auctionIssue, "100"), + 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::_)) @@ -1249,7 +1237,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": {{ @@ -1269,7 +1257,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": {{ @@ -1342,24 +1330,24 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) auto const lgrInfo = createLedgerHeader(kLedgerHash, kSeq); auto const account1 = getAccountIdWithString(kAmmAccount); auto const account2 = getAccountIdWithString(kAmmAccounT2); - 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(kAmmAccount, "JPY", kAmmAccount, "USD", kAmmAccounT2, kLpIssueCurrency); auto accountRoot = createAccountRootObject(kAmmAccount, 0, 2, 200, 2, kIndex1, 2); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLpIssueCurrency}, account1}; + auto const auctionIssue = xrpl::Issue{xrpl::Currency{kLpIssueCurrency}, account1}; ammSetAuctionSlot( ammObj, account2, - ripple::amountFromString(auctionIssue, "100"), + 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::_)) @@ -1369,7 +1357,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": {{ @@ -1389,7 +1377,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 7faddd04a..513413938 100644 --- a/tests/unit/rpc/handlers/AccountChannelsTests.cpp +++ b/tests/unit/rpc/handlers/AccountChannelsTests.cpp @@ -23,7 +23,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -49,7 +48,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": "{}", @@ -70,7 +69,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": "{}", @@ -91,7 +90,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": "{}", @@ -112,7 +111,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": "{}", @@ -135,7 +134,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": "{}", @@ -158,7 +157,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": "{}", @@ -181,7 +180,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": "{}", @@ -206,7 +205,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": "{}", @@ -224,7 +223,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": "{}", @@ -246,7 +245,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}); @@ -262,7 +261,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}); @@ -278,11 +277,11 @@ TEST_F(RPCAccountChannelsHandlerTest, AccountNotString) TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .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": "{}", @@ -308,9 +307,9 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -333,9 +332,9 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -360,10 +359,10 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -389,7 +388,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": "{}", @@ -412,13 +411,13 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCAccountChannelsHandlerTest, NonExistAccount) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -476,16 +475,16 @@ 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())); @@ -493,14 +492,14 @@ TEST_F(RPCAccountChannelsHandlerTest, DefaultParameterTest) // return two payment channel objects std::vector bbs; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 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": "{}" @@ -512,7 +511,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(kCorrectOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCorrectOutput), *output.result); }); } @@ -524,27 +523,27 @@ 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 = + xrpl::STObject const channel = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 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); @@ -554,7 +553,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": "{}", @@ -575,7 +574,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": "{}", @@ -590,7 +589,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": "{}", @@ -612,22 +611,22 @@ 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 = + xrpl::STObject const channel = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); bbs.push_back(channel.getSerializer().peekData()); } @@ -636,12 +635,12 @@ TEST_F(RPCAccountChannelsHandlerTest, UseDestination) repetitions = 20; while ((repetitions--) != 0) { indexes.emplace_back(kIndex1); - ripple::STObject const channel = + xrpl::STObject const channel = createPaymentChannelLedgerObject(kAccount, kAccount3, 100, 10, 32, kTxnId, 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); @@ -649,7 +648,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": "{}", @@ -676,20 +675,20 @@ 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": "{}" @@ -751,16 +750,16 @@ 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())); @@ -768,17 +767,17 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) // return two payment channel objects std::vector bbs; - ripple::STObject channel1 = + xrpl::STObject channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); - channel1.setFieldU32(ripple::sfExpiration, 100); - channel1.setFieldU32(ripple::sfCancelAfter, 200); - channel1.setFieldU32(ripple::sfSourceTag, 300); - channel1.setFieldU32(ripple::sfDestinationTag, 400); + 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": "{}" @@ -790,7 +789,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(kCorrectOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCorrectOutput), *output.result); }); } @@ -798,11 +797,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 kNextPage = 99; static constexpr auto kLimit = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNextPage).key; auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -813,11 +812,11 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); std::vector bbs; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 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); @@ -830,21 +829,21 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNextPage); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNextPage); // 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": "{}", @@ -870,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 kNextPage = 99; static constexpr auto kLimit = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNextPage).key; auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -884,10 +883,10 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); std::vector bbs; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 28); int objectsCount = kLimit; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kIndex1); @@ -895,15 +894,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": "{}", @@ -934,16 +933,16 @@ 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,14 +950,14 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitLessThanMin) // return two payment channel objects std::vector bbs; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 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": "{}", @@ -986,16 +985,16 @@ 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())); @@ -1003,14 +1002,14 @@ TEST_F(RPCAccountChannelsHandlerTest, LimitMoreThanMax) // return two payment channel objects std::vector bbs; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 10, 32, kTxnId, 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 d144c15e0..8220331d5 100644 --- a/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp +++ b/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp @@ -24,8 +24,6 @@ using namespace rpc; using namespace data; using namespace testing; -namespace json = boost::json; - namespace { constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"; @@ -54,7 +52,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": "{}" @@ -77,9 +75,9 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaIntSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(30, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}" @@ -104,9 +102,9 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaStringSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(12, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -130,10 +128,10 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -174,14 +172,14 @@ 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 + {xrpl::uint256{kIndex1}, xrpl::uint256{kIndex2}, xrpl::uint256{kIndex2}}, kIndex1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + 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); @@ -208,7 +206,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": "{}" @@ -220,7 +218,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)); }); } @@ -229,15 +227,15 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderHash) // return valid ledgerHeader auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); @@ -249,7 +247,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": "{}", @@ -274,12 +272,12 @@ 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); @@ -291,7 +289,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 624a9b00f..eada9d155 100644 --- a/tests/unit/rpc/handlers/AccountInfoTests.cpp +++ b/tests/unit/rpc/handlers/AccountInfoTests.cpp @@ -26,7 +26,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -137,7 +136,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); @@ -157,7 +156,7 @@ TEST_F(AccountInfoParameterTest, ApiV1SignerListIsNotBool) runSpawn([&, this](auto yield) { auto const handler = AnyHandler{AccountInfoHandler{backend_, mockAmendmentCenterPtr_}}; - auto const req = json::parse(kReqJson); + auto const req = boost::json::parse(kReqJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1}); ASSERT_FALSE(output); @@ -171,9 +170,9 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaIntSequence) { // return empty ledgerHeader EXPECT_CALL(*backend_, fetchLedgerBySequence(30, _)) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -197,7 +196,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": "{}", @@ -219,10 +218,10 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillOnce(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -250,7 +249,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": "{}" @@ -278,7 +277,7 @@ TEST_F(RPCAccountInfoHandlerTest, AccountInvalid) .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": "{}" @@ -302,11 +301,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, _)) @@ -317,7 +316,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsInvalid) .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": "{}", @@ -404,11 +403,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()) @@ -421,7 +420,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV2) .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": "{}", @@ -434,7 +433,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)); }); } @@ -506,11 +505,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()) @@ -523,7 +522,7 @@ TEST_F(RPCAccountInfoHandlerTest, SignerListsTrueV1) .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": "{}", @@ -536,7 +535,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)); }); } @@ -580,12 +579,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, @@ -602,7 +601,7 @@ TEST_F(RPCAccountInfoHandlerTest, Flags) .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": "{}" @@ -614,7 +613,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)); }); } @@ -624,7 +623,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())); @@ -636,7 +635,7 @@ TEST_F(RPCAccountInfoHandlerTest, IdentAndSignerListsFalse) .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": "{}" @@ -658,7 +657,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())); @@ -669,14 +668,14 @@ TEST_F(RPCAccountInfoHandlerTest, EmptySignerLists) 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": "{}", @@ -745,14 +744,14 @@ 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, @@ -769,7 +768,7 @@ TEST_F(RPCAccountInfoHandlerTest, DisallowIncoming) .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": "{}" @@ -781,7 +780,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)); }); } @@ -828,13 +827,13 @@ 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, @@ -851,7 +850,7 @@ TEST_F(RPCAccountInfoHandlerTest, AmendmentsEnabled) .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": "{}" @@ -863,7 +862,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 4b5639088..d473349cf 100644 --- a/tests/unit/rpc/handlers/AccountLinesTests.cpp +++ b/tests/unit/rpc/handlers/AccountLinesTests.cpp @@ -26,7 +26,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -57,7 +56,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": "{}", @@ -80,7 +79,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": "{}", @@ -103,7 +102,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": "{}", @@ -126,7 +125,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": "{}", @@ -151,7 +150,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": "{}", @@ -169,7 +168,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": "{}", @@ -191,7 +190,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" @@ -209,7 +208,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" @@ -227,7 +226,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" @@ -245,7 +244,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 @@ -264,7 +263,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" @@ -282,7 +281,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 @@ -300,7 +299,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 @@ -318,11 +317,11 @@ TEST_F(RPCAccountLinesHandlerTest, LimitZero) TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .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": "{}", @@ -348,9 +347,9 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -373,9 +372,9 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -400,10 +399,10 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -429,7 +428,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": "{}", @@ -452,13 +451,13 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCAccountLinesHandlerTest, NonExistAccount) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -486,16 +485,16 @@ 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())); @@ -515,7 +514,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": "{}" @@ -555,7 +554,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); }); } @@ -567,15 +566,15 @@ 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; @@ -586,9 +585,9 @@ TEST_F(RPCAccountLinesHandlerTest, UseLimit) ); 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); @@ -598,7 +597,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": "{}", @@ -619,7 +618,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": "{}", @@ -634,7 +633,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": "{}", @@ -656,15 +655,15 @@ 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 @@ -687,7 +686,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); @@ -695,7 +694,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": "{}", @@ -722,20 +721,20 @@ 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": "{}" @@ -794,8 +793,8 @@ 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 @@ -803,8 +802,8 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) .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())); @@ -815,24 +814,24 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) auto line1 = createRippleStateLedgerObject( "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 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, kTxnId, 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": "{}" @@ -844,7 +843,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(kCorrectOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCorrectOutput), *output.result); }); } @@ -887,8 +886,8 @@ 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 @@ -896,8 +895,8 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) .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())); @@ -907,19 +906,19 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) auto line1 = createRippleStateLedgerObject( "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 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, kTxnId, 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": "{}" @@ -931,7 +930,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(kCorrectOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCorrectOutput), *output.result); }); } @@ -939,11 +938,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 kNextPage = 99; static constexpr auto kLimit = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNextPage).key; auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -960,7 +959,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); @@ -973,21 +972,21 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNextPage); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIndex1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNextPage); // 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": "{}", @@ -1013,10 +1012,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 kNextPage = 99; static constexpr auto kLimit = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNextPage).key; + auto ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNextPage).key; auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -1031,7 +1030,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput) "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 0 ); int objectsCount = kLimit; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kIndex1); @@ -1039,15 +1038,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": "{}", @@ -1078,16 +1077,16 @@ 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())); @@ -1107,7 +1106,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": "{}", @@ -1151,7 +1150,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); }); } @@ -1162,16 +1161,16 @@ 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())); @@ -1191,7 +1190,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": "{}", @@ -1235,7 +1234,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 7646d4a2e..aff0ca9cc 100644 --- a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp @@ -29,7 +29,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -194,7 +193,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); @@ -208,10 +207,10 @@ TEST_P(AccountMPTokenIssuancesParameterTest, InvalidParams) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -237,9 +236,9 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerStringIndex { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -263,9 +262,9 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -288,9 +287,9 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByHash) { auto const ledgerHeader = createLedgerHeader(kLedgerHash, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -314,7 +313,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": "{}", @@ -337,12 +336,12 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByIndex) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistAccount) { auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -370,14 +369,14 @@ 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{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kIssuanceIndeX1}, xrpl::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -388,8 +387,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) kAccount, 1, std::nullopt, - ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | - ripple::lsfMPTCanEscrow, + xrpl::lsfMPTCanTrade | xrpl::lsfMPTRequireAuth | xrpl::lsfMPTCanTransfer | + xrpl::lsfMPTCanEscrow, kIssuancE1OutstandingAmount, std::nullopt, kIssuancE1AssetScale, @@ -402,7 +401,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) kAccount, 2, kIssuancE2Metadata, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kIssuancE2OutstandingAmount, kIssuancE2TransferFee, std::nullopt, @@ -435,12 +434,13 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) kIssuanceOuT1, kIssuanceOuT2 ); - 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); }); } @@ -451,12 +451,12 @@ 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{kIssuanceIndeX1}); + auto const indexes = std::vector(50, xrpl::uint256{kIssuanceIndeX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); @@ -466,8 +466,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -476,7 +476,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": "{}", @@ -499,7 +499,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": "{}", @@ -519,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": "{}", @@ -546,14 +546,14 @@ 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), kNextPage).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), kNextPage).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{kIssuanceIndeX1}); + auto const indexes = std::vector(10, xrpl::uint256{kIssuanceIndeX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLimit); @@ -565,19 +565,19 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerOutput) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); // mock the first directory page - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNextPage); + xrpl::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); + ownerDir1.setFieldU64(xrpl::sfIndexNext, kNextPage); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); // mock the second directory page - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kIssuanceIndeX2); - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kIssuanceIndeX2); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); runSpawn([this, kLimit, kNextPage](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -608,13 +608,13 @@ 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), kNextPage).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNextPage).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{kIssuanceIndeX1}); + auto const indexes = std::vector(kLimit, xrpl::uint256{kIssuanceIndeX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLimit); @@ -624,15 +624,15 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kIssuanceIndeX1); + 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, kNextPage](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -661,13 +661,13 @@ 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{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kIssuanceIndeX1}, xrpl::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -677,8 +677,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) kAccount, 1, std::nullopt, - ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | - ripple::lsfMPTCanEscrow, + xrpl::lsfMPTCanTrade | xrpl::lsfMPTRequireAuth | xrpl::lsfMPTCanTransfer | + xrpl::lsfMPTCanEscrow, kIssuancE1OutstandingAmount, std::nullopt, kIssuancE1AssetScale, @@ -691,7 +691,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) kAccount, 2, kIssuancE2Metadata, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kIssuancE2OutstandingAmount, kIssuancE2TransferFee, std::nullopt, @@ -706,7 +706,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": "{}", @@ -739,7 +739,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); }); } @@ -749,13 +749,13 @@ 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{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kIssuanceIndeX1}, xrpl::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -765,8 +765,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) kAccount, 1, std::nullopt, - ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | - ripple::lsfMPTCanEscrow, + xrpl::lsfMPTCanTrade | xrpl::lsfMPTRequireAuth | xrpl::lsfMPTCanTransfer | + xrpl::lsfMPTCanEscrow, kIssuancE1OutstandingAmount, std::nullopt, kIssuancE1AssetScale, @@ -779,7 +779,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) kAccount, 2, kIssuancE2Metadata, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kIssuancE2OutstandingAmount, kIssuancE2TransferFee, std::nullopt, @@ -794,7 +794,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": "{}", @@ -827,7 +827,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); }); } @@ -837,17 +837,17 @@ 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({}, kIssuanceIndeX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kIssuanceIndeX1); 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": "{}" @@ -864,25 +864,25 @@ 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(kLedgerHash, 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{kIssuanceIndeX1}, ripple::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kIssuanceIndeX1}, xrpl::uint256{kIssuanceIndeX2}}, kIssuanceIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -892,7 +892,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) kAccount, 3, std::nullopt, - ripple::lsfMPTCanTransfer, + xrpl::lsfMPTCanTransfer, kIssuancE1OutstandingAmount, kIssuancE1TransferFee, std::nullopt, @@ -908,7 +908,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) kAccount, 5, kIssuancE2Metadata, - ripple::lsfMPTCanTransfer, + xrpl::lsfMPTCanTransfer, kIssuancE2OutstandingAmount, kIssuancE2TransferFee, std::nullopt, @@ -924,7 +924,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": "{}" @@ -984,7 +984,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); }); } @@ -1001,22 +1001,20 @@ static auto generateSingleFlagTests() { return std::vector{ - {.testName = "Locked", .flag = ripple::lsfMPTLocked, .expectedJsonKey = "mpt_locked"}, - {.testName = "CanLock", .flag = ripple::lsfMPTCanLock, .expectedJsonKey = "mpt_can_lock"}, + {.testName = "Locked", .flag = xrpl::lsfMPTLocked, .expectedJsonKey = "mpt_locked"}, + {.testName = "CanLock", .flag = xrpl::lsfMPTCanLock, .expectedJsonKey = "mpt_can_lock"}, {.testName = "RequireAuth", - .flag = ripple::lsfMPTRequireAuth, + .flag = xrpl::lsfMPTRequireAuth, .expectedJsonKey = "mpt_require_auth"}, {.testName = "CanEscrow", - .flag = ripple::lsfMPTCanEscrow, + .flag = xrpl::lsfMPTCanEscrow, .expectedJsonKey = "mpt_can_escrow"}, - {.testName = "CanTrade", - .flag = ripple::lsfMPTCanTrade, - .expectedJsonKey = "mpt_can_trade"}, + {.testName = "CanTrade", .flag = xrpl::lsfMPTCanTrade, .expectedJsonKey = "mpt_can_trade"}, {.testName = "CanTransfer", - .flag = ripple::lsfMPTCanTransfer, + .flag = xrpl::lsfMPTCanTransfer, .expectedJsonKey = "mpt_can_transfer"}, {.testName = "CanClawback", - .flag = ripple::lsfMPTCanClawback, + .flag = xrpl::lsfMPTCanClawback, .expectedJsonKey = "mpt_can_clawback"}, }; } @@ -1036,13 +1034,13 @@ 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{kIssuanceIndeX1}}, kIssuanceIndeX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kIssuanceIndeX1}}, kIssuanceIndeX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1054,7 +1052,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": "{}" @@ -1090,28 +1088,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"}, }; } @@ -1131,13 +1129,13 @@ 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{kIssuanceIndeX1}}, kIssuanceIndeX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kIssuanceIndeX1}}, kIssuanceIndeX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1160,7 +1158,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 c332b2960..61eed2f0e 100644 --- a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp @@ -27,7 +27,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -166,7 +165,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()); @@ -178,10 +177,10 @@ TEST_P(AccountMPTokensParameterTest, InvalidParams) TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash to return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -206,9 +205,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence to return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -231,9 +230,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence to return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -255,10 +254,10 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByHash) { auto const ledgerHeader = createLedgerHeader(kLedgerHash, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillOnce(Return(ledgerHeader)); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -283,7 +282,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": "{}", @@ -305,12 +304,12 @@ TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByIndex) TEST_F(RPCAccountMPTokensHandlerTest, NonExistAccount) { auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -337,13 +336,13 @@ 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{kTokenIndeX1}, ripple::uint256{kTokenIndeX2}}, kTokenIndeX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kTokenIndeX1}, xrpl::uint256{kTokenIndeX2}}, kTokenIndeX1 ); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -351,9 +350,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) auto const bbs = std::vector{ createMpTokenObject( kAccount, - ripple::uint192(kIssuanceIdHex), + xrpl::uint192(kIssuanceIdHex), kTokeN1Amount, - ripple::lsfMPTLocked, + xrpl::lsfMPTLocked, kTokeN1LockedAmount ) .getSerializer() @@ -361,9 +360,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) createMpTokenObject( kAccount, - ripple::uint192(kIssuanceIdHex), + xrpl::uint192(kIssuanceIdHex), kTokeN2Amount, - ripple::lsfMPTAuthorized, + xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() @@ -391,11 +390,12 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) kTokenOuT1, kTokenOuT2 ); - 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); }); } @@ -406,18 +406,18 @@ 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{kTokenIndeX1}); + auto const indexes = std::vector(50, xrpl::uint256{kTokenIndeX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); for (int i = 0; i < 50; ++i) { v.push_back( - createMpTokenObject(kAccount, ripple::uint192(kIssuanceIdHex), i, 0, std::nullopt) + createMpTokenObject(kAccount, xrpl::uint192(kIssuanceIdHex), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -425,8 +425,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTokenIndeX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTokenIndeX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -435,7 +435,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": "{}", @@ -457,7 +457,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": "{}", @@ -477,7 +477,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": "{}", @@ -505,9 +505,9 @@ 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), kNextPage).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), kNextPage).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); @@ -516,7 +516,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput) v.reserve(kLimit); for (int i = 0; i < kLimit; ++i) { v.push_back( - createMpTokenObject(kAccount, ripple::uint192(kIssuanceIdHex), i, 0, std::nullopt) + createMpTokenObject(kAccount, xrpl::uint192(kIssuanceIdHex), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -525,24 +525,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(kTokenIndeX1); } - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTokenIndeX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNextPage); + xrpl::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTokenIndeX1); + ownerDir1.setFieldU64(xrpl::sfIndexNext, kNextPage); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTokenIndeX2); - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTokenIndeX2); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); runSpawn([this, kLimit, kNextPage](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -573,18 +573,18 @@ 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), kNextPage).key; + auto const ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNextPage).key; - auto const indexes = std::vector(kLimit, ripple::uint256{kTokenIndeX1}); + auto const indexes = std::vector(kLimit, xrpl::uint256{kTokenIndeX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLimit); for (int i = 0; i < kLimit; ++i) { v.push_back( - createMpTokenObject(kAccount, ripple::uint192(kIssuanceIdHex), i, 0, std::nullopt) + createMpTokenObject(kAccount, xrpl::uint192(kIssuanceIdHex), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -592,8 +592,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTokenIndeX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTokenIndeX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -601,7 +601,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); runSpawn([this, kLimit, kNextPage](auto yield) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -629,13 +629,13 @@ 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{kTokenIndeX1}, ripple::uint256{kTokenIndeX2}}, kTokenIndeX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kTokenIndeX1}, xrpl::uint256{kTokenIndeX2}}, kTokenIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -643,9 +643,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) auto const bbs = std::vector{ createMpTokenObject( kAccount, - ripple::uint192(kIssuanceIdHex), + xrpl::uint192(kIssuanceIdHex), kTokeN1Amount, - ripple::lsfMPTLocked, + xrpl::lsfMPTLocked, kTokeN1LockedAmount ) .getSerializer() @@ -653,9 +653,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) createMpTokenObject( kAccount, - ripple::uint192(kIssuanceIdHex), + xrpl::uint192(kIssuanceIdHex), kTokeN2Amount, - ripple::lsfMPTAuthorized, + xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() @@ -665,7 +665,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": "{}", @@ -698,7 +698,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); }); } @@ -708,13 +708,13 @@ 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{kTokenIndeX1}, ripple::uint256{kTokenIndeX2}}, kTokenIndeX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kTokenIndeX1}, xrpl::uint256{kTokenIndeX2}}, kTokenIndeX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -722,9 +722,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) auto const bbs = std::vector{ createMpTokenObject( kAccount, - ripple::uint192(kIssuanceIdHex), + xrpl::uint192(kIssuanceIdHex), kTokeN1Amount, - ripple::lsfMPTLocked, + xrpl::lsfMPTLocked, kTokeN1LockedAmount ) .getSerializer() @@ -732,9 +732,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) createMpTokenObject( kAccount, - ripple::uint192(kIssuanceIdHex), + xrpl::uint192(kIssuanceIdHex), kTokeN2Amount, - ripple::lsfMPTAuthorized, + xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() @@ -744,7 +744,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": "{}", @@ -777,7 +777,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); }); } @@ -787,17 +787,17 @@ 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({}, kTokenIndeX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kTokenIndeX1); 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 32b20a35c..dd34cffec 100644 --- a/tests/unit/rpc/handlers/AccountNFTsTests.cpp +++ b/tests/unit/rpc/handlers/AccountNFTsTests.cpp @@ -40,7 +40,6 @@ constexpr auto kMinSeq = 10; using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCAccountNFTsHandlerTest : HandlerBaseTest { @@ -152,7 +151,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()); @@ -165,10 +164,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -195,9 +194,9 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaStringIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -224,9 +223,9 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaIntIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -255,7 +254,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": "{}" @@ -309,10 +308,10 @@ TEST_F(RPCAccountNFTsHandlerTest, NormalPath) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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(kTokenId, "www.ok.com")}, std::nullopt ); @@ -320,7 +319,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": "{}" @@ -332,7 +331,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(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } @@ -346,10 +345,10 @@ TEST_F(RPCAccountNFTsHandlerTest, Limit) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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(kTokenId, "www.ok.com")}, firstPage ); @@ -357,7 +356,7 @@ TEST_F(RPCAccountNFTsHandlerTest, Limit) .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": "{}", @@ -372,7 +371,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)); }); } @@ -384,17 +383,17 @@ TEST_F(RPCAccountNFTsHandlerTest, Marker) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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(kTokenId, "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": "{}", @@ -420,10 +419,10 @@ TEST_F(RPCAccountNFTsHandlerTest, InvalidMarker) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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": "{}", @@ -453,10 +452,10 @@ TEST_F(RPCAccountNFTsHandlerTest, AccountWithNoNFT) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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": "{}" @@ -480,17 +479,17 @@ TEST_F(RPCAccountNFTsHandlerTest, invalidPage) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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(kTokenId, "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": "{}", @@ -549,10 +548,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitLessThanMin) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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(kTokenId, "www.ok.com")}, std::nullopt ); @@ -560,7 +559,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": "{}", @@ -574,7 +573,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(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } @@ -615,10 +614,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitMoreThanMax) auto const accountObject = createAccountRootObject(kAccount, 0, 1, 10, 2, kTxnId, 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(kTokenId, "www.ok.com")}, std::nullopt ); @@ -626,7 +625,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": "{}", @@ -640,6 +639,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(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } diff --git a/tests/unit/rpc/handlers/AccountObjectsTests.cpp b/tests/unit/rpc/handlers/AccountObjectsTests.cpp index 95ebb79c5..0f2f00f24 100644 --- a/tests/unit/rpc/handlers/AccountObjectsTests.cpp +++ b/tests/unit/rpc/handlers/AccountObjectsTests.cpp @@ -30,7 +30,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -199,7 +198,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()); @@ -212,9 +211,9 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaIntSequence) { // return empty ledgerHeader EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -238,7 +237,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaStringSequence) // return empty ledgerHeader EXPECT_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)).WillOnce(Return(std::nullopt)); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -260,10 +259,10 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillOnce(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -290,7 +289,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": "{}" @@ -346,17 +345,17 @@ 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, kMaxSeq, _)) .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; @@ -367,7 +366,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": "{}" @@ -380,7 +379,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -390,7 +389,7 @@ 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, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); @@ -398,13 +397,13 @@ TEST_F(RPCAccountObjectsHandlerTest, Limit) 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; + 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; @@ -416,7 +415,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": "{}", @@ -443,7 +442,7 @@ TEST_F(RPCAccountObjectsHandlerTest, Marker) auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq); 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, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); @@ -451,9 +450,9 @@ TEST_F(RPCAccountObjectsHandlerTest, Marker) 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; + 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())); @@ -467,7 +466,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": "{}", @@ -494,25 +493,25 @@ 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, kMaxSeq, _)) .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; @@ -526,7 +525,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": "{}", @@ -555,18 +554,18 @@ 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, kMaxSeq, _)) .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; + 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; @@ -578,10 +577,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()); @@ -589,7 +588,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": "{}", @@ -613,18 +612,18 @@ 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, kMaxSeq, _)) .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; + 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; @@ -635,12 +634,12 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterAmmType) bbs.push_back(line1.getSerializer().peekData()); auto const ammObject = - createAmmObject(kAccount, "XRP", toBase58(ripple::xrpAccount()), "JPY", kAccount2); + 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": "{}", @@ -666,18 +665,18 @@ 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, kMaxSeq, _)) .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; + 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; @@ -688,10 +687,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()); @@ -699,7 +698,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": "{}", @@ -724,18 +723,18 @@ 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, kMaxSeq, _)) .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; + 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( @@ -747,10 +746,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 ); @@ -761,7 +760,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": "{}", @@ -785,18 +784,18 @@ 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, kMaxSeq, _)) .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; + 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( @@ -811,7 +810,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": "{}", @@ -836,38 +835,38 @@ 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, kMaxSeq, _)) .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; + 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 ); @@ -877,7 +876,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": "{}", @@ -904,37 +903,37 @@ TEST_F( 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, kMaxSeq, _)) .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; + 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 ); @@ -944,7 +943,7 @@ TEST_F( 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": "{}", @@ -1032,19 +1031,19 @@ 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, kMaxSeq, _)) .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 nftMaxKK = xrpl::keylet::nftpageMax(account).key; auto const nftPage2KK = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kIndex1}).key; + xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{kIndex1}).key; auto const nftpage1 = createNftTokenPage( std::vector{std::make_pair(kTokenId, "www.ok.com")}, nftPage2KK ); @@ -1066,7 +1065,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": "{}" @@ -1079,7 +1078,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1089,19 +1088,18 @@ 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, kMaxSeq, _)) .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(kTokenId, "www.ok.com")}, previous ); @@ -1110,7 +1108,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": "{}", @@ -1128,7 +1126,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()) ); }); } @@ -1139,19 +1137,18 @@ 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, kMaxSeq, _)) .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(kTokenId, "www.ok.com")}, previous ); @@ -1165,7 +1162,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": "{}", @@ -1186,7 +1183,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTReachLimitNoMarker) output.result.value().as_object().at("marker").as_string(), fmt::format( "{},{}", - ripple::strHex(ripple::uint256(beast::zero)), + xrpl::strHex(xrpl::uint256(beast::kZero)), std::numeric_limits::max() ) ); @@ -1199,23 +1196,20 @@ 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, kMaxSeq, _)) .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(kTokenId, "www.ok.com")}, previous ); @@ -1230,9 +1224,9 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) .WillOnce(Return(nftpage11.getSerializer().peekData())); auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kIndex1}, ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1 + {xrpl::uint256{kIndex1}, xrpl::uint256{kIndex1}, xrpl::uint256{kIndex1}}, kIndex1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1245,10 +1239,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 ); @@ -1259,14 +1253,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() ) ); @@ -1289,14 +1283,14 @@ 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, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kIndex1}, ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1 + {xrpl::uint256{kIndex1}, xrpl::uint256{kIndex1}, xrpl::uint256{kIndex1}}, kIndex1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1309,10 +1303,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 ); @@ -1323,14 +1317,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() ) ); @@ -1350,11 +1344,11 @@ 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, kMaxSeq, _)) .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": "{}", @@ -1382,23 +1376,23 @@ 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, kMaxSeq, _)) .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, kMaxSeq, _)) .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() ) ); @@ -1419,23 +1413,20 @@ 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, kMaxSeq, _)) .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(kTokenId, "www.ok.com")}, previous ); @@ -1450,8 +1441,8 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) .WillOnce(Return(nftpage11.getSerializer().peekData())); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex1}}, kIndex1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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())); @@ -1464,10 +1455,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 ); @@ -1478,7 +1469,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": "{}", @@ -1486,7 +1477,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) "limit": 12 }})JSON", kAccount, - ripple::strHex(marker), + xrpl::strHex(marker), std::numeric_limits::max() ) ); @@ -1551,19 +1542,19 @@ 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, kMaxSeq, _)) .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 nftMaxKK = xrpl::keylet::nftpageMax(account).key; auto const nftPage2KK = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kIndex1}).key; + xrpl::keylet::nftpage(xrpl::keylet::nftpageMin(account), xrpl::uint256{kIndex1}).key; auto const nftpage1 = createNftTokenPage( std::vector{std::make_pair(kTokenId, "www.ok.com")}, nftPage2KK ); @@ -1585,7 +1576,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": "{}", @@ -1599,7 +1590,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1609,7 +1600,7 @@ 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, kMaxSeq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); @@ -1617,8 +1608,8 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) 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; + 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())); @@ -1631,7 +1622,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": "{}", @@ -1640,7 +1631,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) }})JSON", kAccount, kLimit, - ripple::strHex(ripple::uint256{beast::zero}), + xrpl::strHex(xrpl::uint256{beast::kZero}), std::numeric_limits::max() ) ); @@ -1697,17 +1688,17 @@ 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, kMaxSeq, _)) .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; @@ -1718,7 +1709,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": "{}", @@ -1733,7 +1724,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1778,17 +1769,17 @@ 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, kMaxSeq, _)) .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; @@ -1799,7 +1790,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": "{}", @@ -1814,7 +1805,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1824,17 +1815,17 @@ 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, kMaxSeq, _)) .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; @@ -1844,7 +1835,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": "{}", @@ -1865,7 +1856,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))) ); }); } @@ -1876,28 +1867,28 @@ 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, kMaxSeq, _)) .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))); + 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 16ef4717d..447968bd8 100644 --- a/tests/unit/rpc/handlers/AccountOffersTests.cpp +++ b/tests/unit/rpc/handlers/AccountOffersTests.cpp @@ -35,7 +35,6 @@ constexpr auto kIndex1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1 using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCAccountOffersHandlerTest : HandlerBaseTest { @@ -147,7 +146,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()); @@ -160,10 +159,10 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -190,9 +189,9 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaStringIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -219,9 +218,9 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaIntIndex) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kSeq, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -250,7 +249,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": "{}" @@ -301,12 +300,12 @@ 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, kLedgerSeq, _)) .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, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -316,19 +315,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": "{}" @@ -340,7 +339,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)); }); } @@ -352,13 +351,13 @@ 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, kLedgerSeq, _)) .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; + createOwnerDirLedgerObject(std::vector{20, xrpl::uint256{kIndex1}}, kIndex1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kAccount)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -369,10 +368,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()); @@ -380,7 +379,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": "{}", @@ -406,15 +405,15 @@ 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, kLedgerSeq, _)) .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; + 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, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -426,10 +425,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()); @@ -437,7 +436,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": "{}", @@ -465,19 +464,19 @@ 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, kLedgerSeq, _)) .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, kLedgerSeq, _)) .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": "{}", @@ -506,14 +505,14 @@ 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, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLimitMin + 1, ripple::uint256{kIndex1}}, kIndex1 + std::vector{AccountOffersHandler::kLimitMin + 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, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -523,13 +522,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::kLimitMin + 1); for (auto i = 0; i < AccountOffersHandler::kLimitMin + 1; i++) @@ -538,7 +537,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": "{}", @@ -564,15 +563,15 @@ 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, kLedgerSeq, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 + std::vector{AccountOffersHandler::kLimitMax + 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, kLedgerSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -582,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::kLimitMax + 1); for (auto i = 0; i < AccountOffersHandler::kLimitMax + 1; i++) bbs.push_back(offer.getSerializer().peekData()); @@ -596,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 50636bf40..7709d08ce 100644 --- a/tests/unit/rpc/handlers/AccountTxTests.cpp +++ b/tests/unit/rpc/handlers/AccountTxTests.cpp @@ -23,7 +23,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -408,7 +407,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()); @@ -440,21 +439,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); @@ -512,7 +509,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": "{}", @@ -532,7 +529,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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")); @@ -560,7 +557,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": "{}", @@ -580,7 +577,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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")); @@ -608,7 +605,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": "{}", @@ -628,7 +625,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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")); @@ -656,7 +653,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": "{}", @@ -676,7 +673,7 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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")); @@ -702,7 +699,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": "{}", @@ -722,7 +719,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( @@ -764,7 +761,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": "{}", @@ -784,7 +781,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( @@ -828,7 +825,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": "{}", @@ -851,7 +848,7 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker) 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") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); }); @@ -870,7 +867,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": "{}", @@ -907,7 +904,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": "{}", @@ -956,7 +953,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": "{}", @@ -983,7 +980,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": "{}", @@ -1007,7 +1004,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": "{}", @@ -1045,14 +1042,14 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash) auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq - 1); EXPECT_CALL(*backend_, fetchLedgerByHash); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -1098,7 +1095,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": "{}", @@ -1139,7 +1136,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": "{}", @@ -1184,7 +1181,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": "{}", @@ -1206,7 +1203,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq) 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") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); }); } @@ -1408,7 +1405,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": "{}", @@ -1424,7 +1421,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)); }); } @@ -1637,7 +1634,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": "{}", @@ -1653,7 +1650,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)); }); } @@ -1731,7 +1728,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": "{}", @@ -1745,7 +1742,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)); }); } @@ -2261,13 +2258,13 @@ 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 0e808c19c..85d42e87e 100644 --- a/tests/unit/rpc/handlers/AllHandlerTests.cpp +++ b/tests/unit/rpc/handlers/AllHandlerTests.cpp @@ -196,9 +196,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; @@ -247,7 +247,7 @@ createInput() SubscribeHandler::Input input{}; input.books = std::vector{SubscribeHandler::OrderBook{ - .book = ripple::Book{}, .taker = kAccount, .snapshot = true, .both = true + .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 56521bbc2..db7ff3af5 100644 --- a/tests/unit/rpc/handlers/BookChangesTests.cpp +++ b/tests/unit/rpc/handlers/BookChangesTests.cpp @@ -21,7 +21,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -92,7 +91,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()); @@ -106,9 +105,9 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaIntSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)) - .WillByDefault(Return(std::optional{})); + .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}); @@ -125,7 +124,7 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaStringSequence) // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kMaxSeq, _)).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}); @@ -139,10 +138,10 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillOnce(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}" @@ -188,11 +187,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); @@ -200,9 +198,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -235,10 +233,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 = + xrpl::STObject const metaObj = createMetaDataForBookChange(kCurrency, kIssuer, 22, 1, 3, 3, 1, kDomain); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); @@ -247,8 +245,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } diff --git a/tests/unit/rpc/handlers/BookOffersTests.cpp b/tests/unit/rpc/handlers/BookOffersTests.cpp index e5795991b..5ebc606ad 100644 --- a/tests/unit/rpc/handlers/BookOffersTests.cpp +++ b/tests/unit/rpc/handlers/BookOffersTests.cpp @@ -62,7 +62,6 @@ struct ParameterTestBundle { using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCBookOffersHandlerTest : HandlerBaseTest { @@ -83,7 +82,8 @@ 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); @@ -497,10 +497,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; }; @@ -547,9 +547,10 @@ 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)); }); } @@ -560,17 +561,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()), kPayS20XrpGetS10UsdBookDir ); @@ -578,10 +579,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()), kPayS20XrpGetS10UsdBookDir ); @@ -589,9 +590,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, kPayS20UsdGetS10XrpBookDir ); @@ -600,9 +601,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, kPayS20UsdGetS10XrpBookDir, kDomain @@ -610,31 +611,19 @@ generateNormalPathBookOffersTestBundles() auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - account, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + 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 + 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 + xrpl::xrpCurrency(), xrpl::xrpAccount(), xrpl::toCurrency("USD"), account, std::nullopt ) .value() ); @@ -696,34 +685,34 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPayS20UsdGetS10XrpBookDir}}, + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, + 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": "{}", @@ -762,34 +751,34 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPayS20UsdGetS10XrpBookDir}}, + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, + 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": "{}", @@ -834,27 +823,25 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPayS20UsdGetS10XrpBookDir}}, + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, + 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": "{}", @@ -899,27 +886,25 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJsonWithDomain, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBookWithDomain, ripple::uint256{kPayS20UsdGetS10XrpBookDir}}, - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} + std::map>{ + {getsXRPPaysUSDBookWithDomain, xrpl::uint256{kPayS20UsdGetS10XrpBookDir}}, + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20UsdGetS10XrpBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, + 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": "{}", @@ -965,27 +950,27 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPayS20XrpGetS10UsdBookDir}}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({xrpl::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject( - kAccount, ripple::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 + kAccount, xrpl::lsfGlobalFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 ) .getSerializer() .peekData()} }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1031,28 +1016,28 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPayS20XrpGetS10UsdBookDir}}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, + 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, kTransferRateX2) .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": "{}", @@ -1099,31 +1084,31 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPayS20XrpGetS10UsdBookDir}}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, createOwnerDirLedgerObject( - {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, kIndex1 + {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, kTransferRateX2) .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 @@ -1198,25 +1183,25 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPayS20XrpGetS10UsdBookDir}}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, + 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, kTransferRateX2) .getSerializer() .peekData()}, }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10USDPays20XRPOwnerOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOwnerOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1256,28 +1241,28 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPayS20XrpGetS10UsdBookDir}}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, + 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, kTransferRateX2) .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": "{}", @@ -1323,27 +1308,27 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPayS20XrpGetS10UsdBookDir}}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({xrpl::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object, is deep frozen so unfunded - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject( - kAccount, ripple::lsfLowDeepFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 + kAccount, xrpl::lsfLowDeepFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 ) .getSerializer() .peekData()}, }, .ledgerObjectCalls = 4, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1389,30 +1374,30 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPayS20XrpGetS10UsdBookDir}}, - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPayS20XrpGetS10UsdBookDir}}, + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPayS20XrpGetS10UsdBookDir}, - createOwnerDirLedgerObject({ripple::uint256{kIndex2}}, kIndex1) + {xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, + createOwnerDirLedgerObject({xrpl::uint256{kIndex2}}, kIndex1) .getSerializer() .peekData()}, // gets issuer account object, is deep frozen so unfunded - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject( - kAccount, ripple::lsfLowDeepFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 + kAccount, xrpl::lsfLowDeepFreeze, 2, 200, 2, kIndex1, 2, kTransferRateX2 ) .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": "{}", @@ -1469,9 +1454,9 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaIntSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(30, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": 30, @@ -1501,9 +1486,9 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(30, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "ledger_index": "30", @@ -1532,10 +1517,10 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillByDefault(Return(std::optional{})); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1576,36 +1561,32 @@ TEST_F(RPCBookOffersHandlerTest, Limit) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + xrpl::toCurrency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); + .WillByDefault(Return(xrpl::uint256{kPayS20UsdGetS10XrpBookDir})); 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{kPayS20UsdGetS10XrpBookDir}, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, seq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, seq, _) + 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, kTransferRateX2) .getSerializer() @@ -1616,9 +1597,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, kPayS20UsdGetS10XrpBookDir ); @@ -1627,7 +1608,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": {{ @@ -1665,37 +1646,33 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + xrpl::toCurrency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); + .WillByDefault(Return(xrpl::uint256{kPayS20UsdGetS10XrpBookDir})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); auto const indexes = - std::vector(BookOffersHandler::kLimitMax + 1, ripple::uint256{kIndex2}); + std::vector(BookOffersHandler::kLimitMax + 1, xrpl::uint256{kIndex2}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, seq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, seq, _) + 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, kTransferRateX2) .getSerializer() @@ -1706,9 +1683,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, kPayS20UsdGetS10XrpBookDir ); @@ -1719,7 +1696,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 7a08e7b38..07cf381b0 100644 --- a/tests/unit/rpc/handlers/CredentialHelpersTests.cpp +++ b/tests/unit/rpc/handlers/CredentialHelpersTests.cpp @@ -41,7 +41,7 @@ constexpr std::string_view kCredentialType = "credType"; TEST(CreateAuthCredentialsTest, UniqueCredentials) { - ripple::STArray credentials; + xrpl::STArray credentials; auto const cred1 = createCredentialObject(kAccount, kAccount2, kCredentialType); auto const cred2 = createCredentialObject(kAccount2, kAccount, kCredentialType); @@ -53,14 +53,14 @@ 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()} + 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()} + cred2.getAccountID(xrpl::sfIssuer), xrpl::Slice{cred2Type.data(), cred2Type.size()} ); EXPECT_TRUE(result.count(expectedCred1)); @@ -72,27 +72,27 @@ TEST(ParseAuthorizeCredentialsTest, ValidCredentialsArray) boost::json::array credentials; boost::json::object credential1; credential1[JS(issuer)] = kAccount; - credential1[JS(credential_type)] = ripple::strHex(kCredentialType); + credential1[JS(credential_type)] = xrpl::strHex(kCredentialType); 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( // NOLINT(bugprone-unchecked-optional-access) + *xrpl::parseBase58( // NOLINT(bugprone-unchecked-optional-access) static_cast(credential1[JS(issuer)].as_string()) ); auto const expectedCredentialType = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::strUnHex(static_cast(credential1[JS(credential_type)].as_string())); + *xrpl::strUnHex(static_cast(credential1[JS(credential_type)].as_string())); - 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, @@ -110,7 +110,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(); @@ -130,12 +130,11 @@ TEST_F(CredentialHelperTest, GetValidCredentialArray) boost::json::array credentialsArray = {kCredentialId}; - ripple::STArray expectedAuthCreds; - ripple::STObject credential(ripple::sfCredential); - credential.setAccountID(ripple::sfIssuer, getAccountIdWithString(kAccount2)); + xrpl::STArray expectedAuthCreds; + xrpl::STObject credential(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, getAccountIdWithString(kAccount2)); credential.setFieldVL( - ripple::sfCredentialType, - ripple::Blob{std::begin(kCredentialType), std::end(kCredentialType)} + xrpl::sfCredentialType, xrpl::Blob{std::begin(kCredentialType), std::end(kCredentialType)} ); expectedAuthCreds.push_back(std::move(credential)); diff --git a/tests/unit/rpc/handlers/DefaultProcessorTests.cpp b/tests/unit/rpc/handlers/DefaultProcessorTests.cpp index 800b52f0d..cb4066ec0 100644 --- a/tests/unit/rpc/handlers/DefaultProcessorTests.cpp +++ b/tests/unit/rpc/handlers/DefaultProcessorTests.cpp @@ -16,8 +16,6 @@ using namespace rpc; using namespace rpc::validation; using namespace tests::common; -namespace json = boost::json; - class RPCDefaultProcessorTest : public HandlerBaseTest {}; TEST_F(RPCDefaultProcessorTest, ValidInput) @@ -26,7 +24,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)); @@ -45,7 +43,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}); @@ -60,7 +58,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 e07b4f948..457a3fd97 100644 --- a/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp +++ b/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp @@ -43,7 +43,6 @@ constexpr auto kRangeMax = 30; using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCDepositAuthorizedTest : HandlerBaseTest { @@ -203,7 +202,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); @@ -221,7 +220,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": "{}", @@ -250,7 +249,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": "{}", @@ -275,12 +274,12 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaStringSequence) TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -306,14 +305,14 @@ TEST_F(RPCDepositAuthorizedTest, SourceAccountDoesNotExist) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -342,7 +341,7 @@ TEST_F(RPCDepositAuthorizedTest, DestinationAccountDoesNotExist) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -351,13 +350,13 @@ TEST_F(RPCDepositAuthorizedTest, DestinationAccountDoesNotExist) .WillByDefault(Return(accountRoot.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + 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": "{}", @@ -396,7 +395,7 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -405,7 +404,7 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) .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": "{}", @@ -423,7 +422,7 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -441,7 +440,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -450,17 +449,17 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + 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": "{}", @@ -478,7 +477,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -496,28 +495,28 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + 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, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + 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": "{}", @@ -535,7 +534,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -553,29 +552,29 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + 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, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + 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": "{}", @@ -593,7 +592,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -614,17 +613,17 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + createAccountRootObject(kAccount2, xrpl::lsfDepositAuth, 2, 200, 2, kIndex2, 2); auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kAccount), getAccountIdWithString(kAccount2), - ripple::Slice(kCredentialType.data(), kCredentialType.size()) + xrpl::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -632,19 +631,19 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + 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": "{}", @@ -655,7 +654,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) kAccount, kAccount2, kLedgerHash, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -664,7 +663,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -672,17 +671,17 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + createAccountRootObject(kAccount2, xrpl::lsfDepositAuth, 2, 200, 2, kIndex2, 2); auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType, false); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kAccount), getAccountIdWithString(kAccount2), - ripple::Slice(kCredentialType.data(), kCredentialType.size()) + xrpl::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -690,12 +689,12 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -703,7 +702,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -714,7 +713,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) kAccount, kAccount2, kLedgerHash, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -734,23 +733,23 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) auto ledgerHeader = createLedgerHeader(kLedgerHash, 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{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + 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, kCredentialType, true, 23); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kAccount), getAccountIdWithString(kAccount2), - ripple::Slice(kCredentialType.data(), kCredentialType.size()) + xrpl::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -758,12 +757,12 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -771,7 +770,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -782,7 +781,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) kAccount, kAccount2, kLedgerHash, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -801,17 +800,17 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + createAccountRootObject(kAccount2, xrpl::lsfDepositAuth, 2, 200, 2, kIndex2, 2); auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kAccount), getAccountIdWithString(kAccount2), - ripple::Slice(kCredentialType.data(), kCredentialType.size()) + xrpl::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -819,12 +818,12 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -832,7 +831,7 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "source_account": "{}", @@ -843,8 +842,8 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) kAccount, kAccount2, kLedgerHash, - ripple::strHex(credentialIndex), - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex), + xrpl::strHex(credentialIndex) ) ); @@ -863,29 +862,29 @@ TEST_F(RPCDepositAuthorizedTest, NoElementsInCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + 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, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + 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": "{}", @@ -914,17 +913,17 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + createAccountRootObject(kAccount2, xrpl::lsfDepositAuth, 2, 200, 2, kIndex2, 2); auto const credential = createCredentialObject(kAccount, kAccount2, kCredentialType); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kAccount), getAccountIdWithString(kAccount2), - ripple::Slice(kCredentialType.data(), kCredentialType.size()) + xrpl::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -932,12 +931,12 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) ) .WillByDefault(Return(account2Root.getSerializer().peekData())); ON_CALL(*backend_, doFetchLedgerObject(credentialIndex, _, _)) @@ -945,9 +944,9 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) 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": "{}", @@ -982,19 +981,19 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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); + 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, kCredentialType); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kAccount2), getAccountIdWithString(kAccount), - ripple::Slice(kCredentialType.data(), kCredentialType.size()) + xrpl::Slice(kCredentialType.data(), kCredentialType.size()) ) .key; @@ -1002,19 +1001,19 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals .WillByDefault(Return(std::optional{{1, 2, 3}})); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount)).key, _, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, _, _) ) .WillByDefault(Return(account1Root.getSerializer().peekData())); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kAccount2)).key, _, _) + 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": "{}", @@ -1025,7 +1024,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals kAccount, kAccount2, kLedgerHash, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); diff --git a/tests/unit/rpc/handlers/FeatureTests.cpp b/tests/unit/rpc/handlers/FeatureTests.cpp index 387523d3a..36a576861 100644 --- a/tests/unit/rpc/handlers/FeatureTests.cpp +++ b/tests/unit/rpc/handlers/FeatureTests.cpp @@ -213,7 +213,7 @@ TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCFeatureHandlerTest, LedgerNotExistViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, testing::_)) .WillOnce(testing::Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -391,7 +391,7 @@ TEST_F(RPCFeatureHandlerTest, BadFeaturePath) TEST_F(RPCFeatureHandlerTest, DeletedLibXRPLAmendmentQueryByNameReturnsSupportedFalse) { auto const ownerPaysFeeKey = - ripple::to_string(data::Amendment::getAmendmentId(Amendments::OwnerPaysFee)); + xrpl::to_string(data::Amendment::getAmendmentId(Amendments::OwnerPaysFee)); auto const all = std::vector{{ .name = Amendments::OwnerPaysFee, .feature = data::Amendment::getAmendmentId(Amendments::OwnerPaysFee), @@ -439,7 +439,7 @@ TEST_F(RPCFeatureHandlerTest, DeletedLibXRPLAmendmentQueryByNameReturnsSupported TEST_F(RPCFeatureHandlerTest, DeletedLibXRPLAmendmentQueryByHashReturnsSupportedFalse) { auto const ownerPaysFeeKey = - ripple::to_string(data::Amendment::getAmendmentId(Amendments::OwnerPaysFee)); + xrpl::to_string(data::Amendment::getAmendmentId(Amendments::OwnerPaysFee)); auto const all = std::vector{{ .name = Amendments::OwnerPaysFee, .feature = data::Amendment::getAmendmentId(Amendments::OwnerPaysFee), diff --git a/tests/unit/rpc/handlers/GatewayBalancesTests.cpp b/tests/unit/rpc/handlers/GatewayBalancesTests.cpp index 8088ca4e1..dfe62fdb5 100644 --- a/tests/unit/rpc/handlers/GatewayBalancesTests.cpp +++ b/tests/unit/rpc/handlers/GatewayBalancesTests.cpp @@ -28,7 +28,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -68,7 +67,8 @@ TEST_P(ParameterTest, CheckError) auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { auto const output = handler.process( - json::parse(bundle.testJson), Context{.yield = yield, .apiVersion = bundle.apiVersion} + boost::json::parse(bundle.testJson), + Context{.yield = yield, .apiVersion = bundle.apiVersion} ); ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); @@ -255,12 +255,12 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaStringIndex) auto const seq = 123; EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)) - .WillOnce(Return(std::optional{})); + .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": "{}", @@ -284,12 +284,12 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaIntIndex) auto const seq = 123; EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)) - .WillOnce(Return(std::optional{})); + .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": "{}", @@ -310,13 +310,13 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaIntIndex) TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .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": "{}", @@ -342,14 +342,14 @@ TEST_F(RPCGatewayBalancesHandlerTest, AccountNotFound) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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": "{}" @@ -368,8 +368,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; }; @@ -387,13 +387,13 @@ 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())); @@ -406,7 +406,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": "{}", @@ -419,7 +419,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)); }); } @@ -429,24 +429,24 @@ generateNormalPathTestBundles() auto frozenState = createRippleStateLedgerObject( "JPY", kIssuer, -50, kAccount, 10, kAccount3, 20, kTxnId, 123 ); - frozenState.setFieldU32(ripple::sfFlags, ripple::lsfLowFreeze); + frozenState.setFieldU32(xrpl::sfFlags, xrpl::lsfLowFreeze); auto overflowState = createRippleStateLedgerObject("JPY", kIssuer, 50, kAccount, 10, kAccount3, 20, kTxnId, 123); int64_t const min64 = -9922966390934554; overflowState.setFieldAmount( - ripple::sfBalance, ripple::STAmount(getIssue("JPY", kIssuer), min64, 80) + 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 = @@ -524,7 +524,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, kTxnId, 123 )}, @@ -544,7 +544,7 @@ generateNormalPathTestBundles() NormalTestBundle{ .testName = "ObligationOverflow", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, kIndex1 + {xrpl::uint256{kIndex2}, xrpl::uint256{kIndex2}}, kIndex1 ), .mockedObjects = std::vector{overflowState, overflowState}, .expectedJson = fmt::format( @@ -563,10 +563,10 @@ 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 = @@ -624,8 +624,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{ @@ -682,8 +681,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; }; @@ -698,11 +697,11 @@ TEST_P(EscrowTest, CheckEscrowOutput) auto const ledgerHeader = createLedgerHeader(kLedgerHash, 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())); @@ -715,7 +714,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": "{}" @@ -726,7 +725,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)); }); } @@ -735,20 +734,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({{ @@ -764,7 +763,7 @@ generateEscrowTestBundles() EscrowTestBundle{ .testName = "MultipleEscrowXRP", .mockedDir = createOwnerDirLedgerObject( - {ripple::uint256{kIndex2}, ripple::uint256{kIndex2}}, kIndex1 + {xrpl::uint256{kIndex2}, xrpl::uint256{kIndex2}}, kIndex1 ), .mockedObjects = std::vector{escrow1, escrow2}, .expectedJson = fmt::format( @@ -780,7 +779,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({{ @@ -796,8 +795,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 71f5a9346..4a0855082 100644 --- a/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp +++ b/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp @@ -24,7 +24,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -53,16 +52,16 @@ mockLedgerObject( "70726F7669646572", 64u, time, - ripple::Blob(8, 'a'), - ripple::Blob(8, 'a'), + xrpl::Blob(8, 'a'), + xrpl::Blob(8, 'a'), kRangeMax - 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, kRangeMax, _)) .WillOnce(Return(oracleObject.getSerializer().peekData())); } @@ -386,7 +385,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()); @@ -397,7 +396,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", @@ -408,7 +407,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OverOraclesMax) for (auto i = 0; i < maxOracles + 1; ++i) { req.at("oracles").as_array().push_back( - json::object{ + boost::json::object{ {"account", "rGh1VZCRBJY6rJiaFpD4LZtyHiuCkC8aeD"}, {"oracle_document_id", 2} } ); @@ -427,7 +426,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, LedgerNotFound) { EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillOnce(Return(std::nullopt)); constexpr auto kDocumentId = 1; - auto const req = json::parse( + auto const req = boost::json::parse( fmt::format( R"JSON({{ "base_asset": "USD", @@ -462,7 +461,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) mockLedgerObject(*backend_, kAccount, kDocumentId, 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", @@ -479,7 +478,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntrySinglePriceData) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -513,7 +512,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) mockLedgerObject(*backend_, kAccount, kDocumentId, 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", @@ -530,7 +529,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryStrOracleDocumentId) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -564,7 +563,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) mockLedgerObject(*backend_, kAccount, kDocumentId, 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", @@ -581,7 +580,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, PreviousTxNotFound) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -616,23 +615,23 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) constexpr auto kDocumentId = 1; mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTx1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTx1), _)) .WillRepeatedly(Return(createOracleSetTxWithMetadata( kAccount, kRangeMax, 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", @@ -649,7 +648,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -690,7 +689,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) mockLedgerObject(*backend_, kAccount, kDocumentID3, 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", @@ -719,7 +718,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesOdd) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -760,7 +759,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) mockLedgerObject(*backend_, kAccount, kDocumentID3, 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", @@ -795,7 +794,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryMultipleOraclesEven) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -837,7 +836,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) mockLedgerObject(*backend_, kAccount, kDocumentID3, 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", @@ -874,7 +873,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, OracleLedgerEntryTrim) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -911,12 +910,12 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoOracleEntryFound) constexpr auto kDocumentId = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; + xrpl::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; EXPECT_CALL(*backend_, doFetchLedgerObject(oracleIndex, kRangeMax, _)) .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", @@ -951,7 +950,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoMatchAssetPair) mockLedgerObject(*backend_, kAccount, kDocumentId, 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", @@ -996,7 +995,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) mockLedgerObject(*backend_, kAccount, kDocumentID3, 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", @@ -1033,7 +1032,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIsZero) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -1078,7 +1077,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) mockLedgerObject(*backend_, kAccount, kDocumentID3, 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", @@ -1115,7 +1114,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, ValidTimeThreshold) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -1160,7 +1159,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) mockLedgerObject(*backend_, kAccount, kDocumentID3, 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", @@ -1197,7 +1196,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdTooLong) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -1241,7 +1240,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) mockLedgerObject(*backend_, kAccount, kDocumentID3, 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", @@ -1278,7 +1277,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, TimeThresholdIncludeOldest) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -1311,26 +1310,26 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) constexpr auto kDocumentId = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; + xrpl::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; mockLedgerObject(*backend_, kAccount, kDocumentId, 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, kRangeMax, 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", @@ -1347,7 +1346,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) ) ); - auto const expected = json::parse( + auto const expected = boost::json::parse( fmt::format( R"JSON({{ "entire_set": {{ @@ -1378,41 +1377,41 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NotFoundInTxHistory) constexpr auto kDocumentId = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; + xrpl::keylet::oracle(getAccountIdWithString(kAccount), kDocumentId).key; mockLedgerObject(*backend_, kAccount, kDocumentId, kTx1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTx1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTx1), _)) .WillOnce(Return(createOracleSetTxWithMetadata( kAccount, kRangeMax, 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, kRangeMax, 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 698dd2a7b..5e3255ee7 100644 --- a/tests/unit/rpc/handlers/LedgerDataTests.cpp +++ b/tests/unit/rpc/handlers/LedgerDataTests.cpp @@ -23,7 +23,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -152,7 +151,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()); @@ -168,7 +167,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": {} @@ -191,7 +190,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": "{}" @@ -210,12 +209,12 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}" @@ -238,12 +237,12 @@ TEST_F(RPCLedgerDataHandlerTest, MarkerNotExist) .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .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": "{}" @@ -286,7 +285,7 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -304,7 +303,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")); @@ -312,7 +311,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(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLedgerExpected)); 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(), kLedgerHash); @@ -347,7 +346,7 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -365,7 +364,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 = kApiVersion}); ASSERT_TRUE(output); EXPECT_TRUE(output.result->as_object().contains("ledger")); @@ -373,7 +372,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(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLedgerExpected)); }); } @@ -404,7 +403,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -423,7 +422,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"); @@ -435,7 +434,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(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLedgerExpected)); 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(), kLedgerHash); @@ -469,7 +468,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + 1); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -479,7 +478,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) } auto const amm = - createAmmObject(kAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAccount2); + createAmmObject(kAccount, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAccount2); bbs.push_back(amm.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -487,7 +486,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"); @@ -499,7 +498,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(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLedgerExpected)); 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(), kLedgerHash); @@ -533,8 +532,8 @@ TEST_F(RPCLedgerDataHandlerTest, OutOfOrder) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(2); ON_CALL(*backend_, doFetchSuccessorKey(kFirstKey, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kIndex2}, kRangeMax, _)) + .WillByDefault(Return(xrpl::uint256{kIndex2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kIndex2}, kRangeMax, _)) .WillByDefault(Return(std::nullopt)); auto const line = createRippleStateLedgerObject( @@ -547,12 +546,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(kLedgerExpected)); + EXPECT_EQ(output.result->as_object().at("ledger"), boost::json::parse(kLedgerExpected)); EXPECT_EQ(output.result->as_object().at("marker").as_uint64(), kRangeMax); EXPECT_EQ(output.result->as_object().at("state").as_array().size(), 1); EXPECT_EQ(output.result->as_object().at("ledger_hash").as_string(), kLedgerHash); @@ -567,7 +566,7 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) .WillByDefault(Return(createLedgerHeader(kLedgerHash, kRangeMax))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillByDefault(Return(createRippleStateLedgerObject( "USD", kAccount2, 10, kAccount, 100, kAccount2, 200, kTxnId, 123 ) @@ -577,10 +576,10 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) auto limit = 10; std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kIndex1}, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kIndex2}, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kIndex1}, kRangeMax, _)) + .WillByDefault(Return(xrpl::uint256{kIndex2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kIndex2}, kRangeMax, _)) + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limit--) != 0) { auto const line = createRippleStateLedgerObject( @@ -594,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,7 +630,7 @@ TEST_F(RPCLedgerDataHandlerTest, DiffMarker) ); bbs.push_back(line.getSerializer().peekData()); los.emplace_back( - LedgerObject{.key = ripple::uint256{kIndex2}, .blob = Blob{}} + LedgerObject{.key = xrpl::uint256{kIndex2}, .blob = Blob{}} ); // NOLINT(modernize-use-emplace) } ON_CALL(*backend_, fetchLedgerDiff(kRangeMax, _)).WillByDefault(Return(los)); @@ -641,7 +640,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 +671,7 @@ TEST_F(RPCLedgerDataHandlerTest, Binary) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limit--) != 0) { auto const line = createRippleStateLedgerObject( @@ -686,7 +685,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 @@ -714,7 +713,7 @@ TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLimitBinary); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limit--) != 0u) { auto const line = createRippleStateLedgerObject( @@ -728,7 +727,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": {}, @@ -762,7 +761,7 @@ TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLimitJson); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); while ((limit--) != 0u) { auto const line = createRippleStateLedgerObject( @@ -776,7 +775,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": {}, @@ -806,7 +805,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); auto const issuance = createMptIssuanceObject(kAccount, 2, "metadata"); bbs.push_back(issuance.getSerializer().peekData()); @@ -816,7 +815,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"); @@ -835,7 +834,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))) ); }); } @@ -849,10 +848,10 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPToken) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); ON_CALL(*backend_, doFetchSuccessorKey(_, kRangeMax, _)) - .WillByDefault(Return(ripple::uint256{kIndex2})); + .WillByDefault(Return(xrpl::uint256{kIndex2})); auto const mptoken = - createMpTokenObject(kAccount, ripple::makeMptID(2, getAccountIdWithString(kAccount))); + createMpTokenObject(kAccount, xrpl::makeMptID(2, getAccountIdWithString(kAccount))); bbs.push_back(mptoken.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -860,7 +859,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 063270fcb..485adac6d 100644 --- a/tests/unit/rpc/handlers/LedgerEntryTests.cpp +++ b/tests/unit/rpc/handlers/LedgerEntryTests.cpp @@ -40,7 +40,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -2419,7 +2418,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); @@ -2466,7 +2465,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" @@ -2488,7 +2487,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 @@ -2512,13 +2511,13 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotFound) .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, kRangeMax, _)) .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": "{}" @@ -2536,8 +2535,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, @@ -2548,8 +2547,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{ @@ -2561,9 +2560,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = - createAccountRootObject(kAccount2, ripple::lsfGlobalFreeze, 1, 10, 2, kIndex1, 3) + createAccountRootObject(kAccount2, xrpl::lsfGlobalFreeze, 1, 10, 2, kIndex1, 3) }, NormalPathTestBundle{ .testName = "Payment_channel", @@ -2574,7 +2573,7 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createPaymentChannelLedgerObject(kAccount, kAccount2, 100, 200, 300, kIndex1, 400) }, @@ -2587,7 +2586,7 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createNftTokenPage( std::vector{std::make_pair(kTokenId, "www.ok.com")}, std::nullopt @@ -2602,7 +2601,7 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createCheckLedgerObject(kAccount, kAccount2) }, NormalPathTestBundle{ @@ -2614,9 +2613,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kIndex1}}, kIndex1 + std::vector{xrpl::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2628,7 +2627,7 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createOfferLedgerObject( kAccount, 100, @@ -2636,7 +2635,7 @@ generateTestValuesForNormalPathTest() "USD", "XRP", kAccount2, - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), kIndex1 ) }, @@ -2649,7 +2648,7 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createEscrowLedgerObject(kAccount, kAccount2) }, NormalPathTestBundle{ @@ -2661,7 +2660,7 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createTicketLedgerObject(kAccount, 0) }, NormalPathTestBundle{ @@ -2673,7 +2672,7 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createDepositPreauthLedgerObjectByAuth(kAccount, kAccount2) }, NormalPathTestBundle{ @@ -2685,7 +2684,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{ @@ -2697,7 +2696,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{ @@ -2712,9 +2711,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::keylet::page(ripple::uint256{kIndex1}, 2).key, + .expectedIndex = xrpl::keylet::page(xrpl::uint256{kIndex1}, 2).key, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kIndex1}}, kIndex1 + std::vector{xrpl::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2729,9 +2728,9 @@ generateTestValuesForNormalPathTest() }})JSON", kAccount ), - .expectedIndex = ripple::keylet::page(ripple::keylet::ownerDir(account1), 2).key, + .expectedIndex = xrpl::keylet::page(xrpl::keylet::ownerDir(account1), 2).key, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kIndex1}}, kIndex1 + std::vector{xrpl::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2746,9 +2745,9 @@ generateTestValuesForNormalPathTest() kAccount ), // default sub_index is 0 - .expectedIndex = ripple::keylet::page(ripple::keylet::ownerDir(account1), 0).key, + .expectedIndex = xrpl::keylet::page(xrpl::keylet::ownerDir(account1), 0).key, .mockedEntity = createOwnerDirLedgerObject( - std::vector{ripple::uint256{kIndex1}}, kIndex1 + std::vector{xrpl::uint256{kIndex1}}, kIndex1 ) }, NormalPathTestBundle{ @@ -2763,7 +2762,7 @@ generateTestValuesForNormalPathTest() }})JSON", kAccount ), - .expectedIndex = ripple::keylet::escrow(account1, 1).key, + .expectedIndex = xrpl::keylet::escrow(account1, 1).key, .mockedEntity = createEscrowLedgerObject(kAccount, kAccount2) }, NormalPathTestBundle{ @@ -2779,7 +2778,7 @@ generateTestValuesForNormalPathTest() kAccount, kAccount2 ), - .expectedIndex = ripple::keylet::depositPreauth(account1, account2).key, + .expectedIndex = xrpl::keylet::depositPreauth(account1, account2).key, .mockedEntity = createDepositPreauthLedgerObjectByAuth(kAccount, kAccount2) }, NormalPathTestBundle{ @@ -2801,7 +2800,7 @@ generateTestValuesForNormalPathTest() kAccount2, kCredentialType ), - .expectedIndex = ripple::keylet::depositPreauth( + .expectedIndex = xrpl::keylet::depositPreauth( account1, credentials::createAuthCredentials(createAuthCredentialArray( std::vector{kAccount2}, @@ -2828,14 +2827,14 @@ generateTestValuesForNormalPathTest() kAccount2, kCredentialType ), - .expectedIndex = ripple::keylet::credential( + .expectedIndex = xrpl::keylet::credential( account1, account2, - ripple::Slice( + xrpl::Slice( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::strUnHex(kCredentialType)->data(), + xrpl::strUnHex(kCredentialType)->data(), // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::strUnHex(kCredentialType)->size() + xrpl::strUnHex(kCredentialType)->size() ) ) .key, @@ -2854,7 +2853,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 ) @@ -2871,7 +2870,7 @@ generateTestValuesForNormalPathTest() }})JSON", kAccount ), - .expectedIndex = ripple::getTicketIndex(account1, 2), + .expectedIndex = xrpl::getTicketIndex(account1, 2), .mockedEntity = createTicketLedgerObject(kAccount, 0) }, NormalPathTestBundle{ @@ -2886,7 +2885,7 @@ generateTestValuesForNormalPathTest() }})JSON", kAccount ), - .expectedIndex = ripple::keylet::offer(account1, 2).key, + .expectedIndex = xrpl::keylet::offer(account1, 2).key, .mockedEntity = createOfferLedgerObject( kAccount, 100, @@ -2894,7 +2893,7 @@ generateTestValuesForNormalPathTest() "USD", "XRP", kAccount2, - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), kIndex1 ) }, @@ -2907,9 +2906,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = createAmmObject( - kAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAccount2 + kAccount, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAccount2 ) }, NormalPathTestBundle{ @@ -2930,13 +2929,13 @@ generateTestValuesForNormalPathTest() "JPY", kAccount2 ), - .expectedIndex = ripple::keylet::amm( - getIssue("XRP", ripple::toBase58(ripple::xrpAccount())), - getIssue("JPY", kAccount2) - ) - .key, + .expectedIndex = + xrpl::keylet::amm( + getIssue("XRP", xrpl::toBase58(xrpl::xrpAccount())), getIssue("JPY", kAccount2) + ) + .key, .mockedEntity = createAmmObject( - kAccount, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAccount2 + kAccount, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAccount2 ) }, NormalPathTestBundle{ @@ -2962,14 +2961,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) @@ -2997,14 +2996,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) @@ -3031,10 +3030,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) ), @@ -3067,10 +3066,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) ), @@ -3093,18 +3092,18 @@ 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'), kRangeMax - 2, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( - 2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3 + 2e4, xrpl::toCurrency("XRP"), xrpl::toCurrency("USD"), 3 )}) ) }, @@ -3120,18 +3119,18 @@ 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'), kRangeMax - 2, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( - 2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3 + 2e4, xrpl::toCurrency("XRP"), xrpl::toCurrency("USD"), 3 )}) ) }, @@ -3142,20 +3141,20 @@ 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'), kRangeMax - 4, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( - 1e3, ripple::to_currency("USD"), ripple::to_currency("XRP"), 2 + 1e3, xrpl::toCurrency("USD"), xrpl::toCurrency("XRP"), 2 )}) ) }, @@ -3166,9 +3165,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{ @@ -3180,8 +3179,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", @@ -3194,10 +3193,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", @@ -3208,10 +3207,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256(kIndex1), - .mockedEntity = createPermissionedDomainObject( - kAccount, kIndex1, kRangeMax, 0, ripple::uint256{0}, 0 - ) + .expectedIndex = xrpl::uint256(kIndex1), + .mockedEntity = + createPermissionedDomainObject(kAccount, kIndex1, kRangeMax, 0, xrpl::uint256{0}, 0) }, NormalPathTestBundle{ .testName = "PermissionedDomainViaObject", @@ -3226,15 +3224,14 @@ generateTestValuesForNormalPathTest() kAccount, kRangeMax ), - .expectedIndex = ripple::keylet::permissionedDomain( + .expectedIndex = xrpl::keylet::permissionedDomain( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::parseBase58(kAccount), + *xrpl::parseBase58(kAccount), kRangeMax ) .key, - .mockedEntity = createPermissionedDomainObject( - kAccount, kIndex1, kRangeMax, 0, ripple::uint256{0}, 0 - ) + .mockedEntity = + createPermissionedDomainObject(kAccount, kIndex1, kRangeMax, 0, xrpl::uint256{0}, 0) }, NormalPathTestBundle{ .testName = "CreateVaultObjectByHexString", @@ -3245,16 +3242,16 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256(kIndex1), + .expectedIndex = xrpl::uint256(kIndex1), .mockedEntity = createVault( kAccount, kAccount, kRangeMax, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{0}, + xrpl::uint256{0}, 0 ) }, @@ -3273,16 +3270,16 @@ generateTestValuesForNormalPathTest() ), .expectedIndex = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::vault(*ripple::parseBase58(kAccount), kRangeMax).key, + xrpl::keylet::vault(*xrpl::parseBase58(kAccount), kRangeMax).key, .mockedEntity = createVault( kAccount, kAccount, kRangeMax, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{0}, + xrpl::uint256{0}, 0 ) }, @@ -3295,9 +3292,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256(kIndex1), + .expectedIndex = xrpl::uint256(kIndex1), .mockedEntity = createLoanBroker( - kAccount, kAccount, kRangeMax, ripple::uint256{kIndex1}, 1, ripple::uint256{0}, 0 + kAccount, kAccount, kRangeMax, xrpl::uint256{kIndex1}, 1, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3313,14 +3310,14 @@ generateTestValuesForNormalPathTest() kAccount, kRangeMax ), - .expectedIndex = ripple::keylet::loanbroker( + .expectedIndex = xrpl::keylet::loanbroker( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::parseBase58(kAccount), + *xrpl::parseBase58(kAccount), kRangeMax ) .key, .mockedEntity = createLoanBroker( - kAccount, kAccount, kRangeMax, ripple::uint256{kIndex1}, 1, ripple::uint256{0}, 0 + kAccount, kAccount, kRangeMax, xrpl::uint256{kIndex1}, 1, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3332,9 +3329,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256(kIndex1), + .expectedIndex = xrpl::uint256(kIndex1), .mockedEntity = createLoan( - kAccount, ripple::uint256{kIndex1}, 1, 1000, 86400, 100, ripple::uint256{0}, 0 + kAccount, xrpl::uint256{kIndex1}, 1, 1000, 86400, 100, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3349,9 +3346,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::keylet::loan(ripple::uint256{kIndex1}, 1).key, + .expectedIndex = xrpl::keylet::loan(xrpl::uint256{kIndex1}, 1).key, .mockedEntity = createLoan( - kAccount, ripple::uint256{kIndex1}, 1, 1000, 86400, 100, ripple::uint256{0}, 0 + kAccount, xrpl::uint256{kIndex1}, 1, 1000, 86400, 100, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3363,9 +3360,9 @@ generateTestValuesForNormalPathTest() }})JSON", kIndex1 ), - .expectedIndex = ripple::uint256{kIndex1}, + .expectedIndex = xrpl::uint256{kIndex1}, .mockedEntity = - createDelegateObject(kAccount, kAccount2, kIndex1, 0, ripple::uint256{0}, 0) + createDelegateObject(kAccount, kAccount2, kIndex1, 0, xrpl::uint256{0}, 0) }, NormalPathTestBundle{ .testName = "DelegateViaObject", @@ -3380,12 +3377,12 @@ generateTestValuesForNormalPathTest() kAccount, kAccount2 ), - .expectedIndex = ripple::keylet::delegate( + .expectedIndex = xrpl::keylet::delegate( getAccountIdWithString(kAccount), getAccountIdWithString(kAccount2) ) .key, .mockedEntity = - createDelegateObject(kAccount, kAccount2, kIndex1, 0, ripple::uint256{0}, 0) + createDelegateObject(kAccount, kAccount2, kIndex1, 0, xrpl::uint256{0}, 0) }, }; } @@ -3412,7 +3409,7 @@ 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(); @@ -3420,10 +3417,10 @@ TEST_P(RPCLedgerEntryNormalPathTest, NormalPath) EXPECT_EQ(outputJson.at("ledger_index").as_uint64(), kRangeMax); EXPECT_EQ( outputJson.at("node_binary").as_string(), - ripple::strHex(testBundle.mockedEntity.getSerializer().peekData()) + xrpl::strHex(testBundle.mockedEntity.getSerializer().peekData()) ); EXPECT_EQ( - ripple::uint256(boost::json::value_to(outputJson.at("index")).data()), + xrpl::uint256(boost::json::value_to(outputJson.at("index")).data()), testBundle.expectedIndex ); }); @@ -3460,12 +3457,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}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .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": "{}" @@ -3475,7 +3472,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)); }); } @@ -3492,19 +3489,19 @@ TEST_F(RPCLedgerEntryTest, Vault_BinaryFalse) kAccount, kRangeMax, "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 = // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - ripple::keylet::vault(*ripple::parseBase58(kAccount), kRangeMax).key; + xrpl::keylet::vault(*xrpl::parseBase58(kAccount), kRangeMax).key; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{ + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{ vault.getSerializer().peekData().data(), vault.getSerializer().peekData().size() }, vaultKey @@ -3515,7 +3512,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, @@ -3545,18 +3542,18 @@ TEST_F(RPCLedgerEntryTest, LoanBroker_BinaryFalse) boost::json::object const entry; auto const loanBroker = createLoanBroker( - kAccount, kAccount, kRangeMax, ripple::uint256{kIndex1}, 1, ripple::uint256{1}, 0 + kAccount, kAccount, kRangeMax, xrpl::uint256{kIndex1}, 1, xrpl::uint256{1}, 0 ); - auto const loanBrokerKey = ripple::keylet::loanbroker( + auto const loanBrokerKey = xrpl::keylet::loanbroker( // NOLINTNEXTLINE(bugprone-unchecked-optional-access) - *ripple::parseBase58(kAccount), + *xrpl::parseBase58(kAccount), kRangeMax ) .key; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{ + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{ loanBroker.getSerializer().peekData().data(), loanBroker.getSerializer().peekData().size() }, @@ -3568,7 +3565,7 @@ TEST_F(RPCLedgerEntryTest, LoanBroker_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, @@ -3605,12 +3602,12 @@ TEST_F(RPCLedgerEntryTest, Loan_BinaryFalse) auto const loan = createLoan( kAccount, - ripple::uint256{kIndex1}, + xrpl::uint256{kIndex1}, kLoanSeq, kStartDate, kPaymentInterval, kInterestRate, - ripple::uint256{1}, + xrpl::uint256{1}, 0 ); @@ -3619,7 +3616,7 @@ TEST_F(RPCLedgerEntryTest, Loan_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, @@ -3651,12 +3648,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}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .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": "{}" @@ -3678,7 +3675,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": "{}", @@ -3703,7 +3700,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": "{}", @@ -3723,12 +3720,12 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerEntryTest, LedgerNotExistViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -3750,7 +3747,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()); @@ -3763,7 +3760,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()); @@ -3822,12 +3819,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}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .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": "{}", @@ -3838,7 +3835,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)); }); } @@ -3869,15 +3866,15 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const offer = createNftBuyOffer(kNftId, kAccount); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(uint32_t{kRangeMax})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax - 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": "{}", @@ -3888,7 +3885,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)); }); } @@ -3898,16 +3895,16 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotExist) { auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(uint32_t{kRangeMax})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax - 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": "{}", @@ -3956,12 +3953,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}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .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": "{}", @@ -3972,7 +3969,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)); }); } @@ -4020,14 +4017,14 @@ TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) auto const line2 = createRippleStateLedgerObject( "USD", kAccount, 10, kAccount2, 100, kAccount, 200, kTxnId, 123 ); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillRepeatedly(Return(line1.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax - 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": "{}", @@ -4038,7 +4035,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)); }); } @@ -4069,15 +4066,15 @@ TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const offer = createNftBuyOffer(kNftId, kAccount); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(uint32_t{kRangeMax - 4})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax - 5, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax - 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": "{}", @@ -4088,7 +4085,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)); }); } @@ -4098,14 +4095,14 @@ TEST_F(RPCLedgerEntryTest, ObjectSeqNotExist) { auto const ledgerinfo = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kIndex1}, kRangeMax, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kIndex1}, kRangeMax, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kIndex1}, kRangeMax, _)) .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": "{}", @@ -4145,7 +4142,7 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) } })JSON"; - auto const mptId = ripple::makeMptID(2, getAccountIdWithString(kAccount)); + auto const mptId = xrpl::makeMptID(2, getAccountIdWithString(kAccount)); auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)) @@ -4153,23 +4150,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, kRangeMax, _) - ) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::mptIssuance(mptId).key, kRangeMax, _)) .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 b83f22bc4..4224dba07 100644 --- a/tests/unit/rpc/handlers/LedgerIndexTests.cpp +++ b/tests/unit/rpc/handlers/LedgerIndexTests.cpp @@ -25,7 +25,6 @@ constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25 using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCLedgerIndexTest : HandlerBaseTestStrict { @@ -38,7 +37,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); @@ -54,7 +53,7 @@ TEST_F(RPCLedgerIndexTest, NoDateGiven) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).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); @@ -67,7 +66,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( kLedgerHash, kRangeMin, 1719318190 ); //"2024-06-25T12:23:10Z" @@ -85,7 +84,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( kLedgerHash, kRangeMin, 1719318190 ); //"2024-06-25T12:23:10Z" @@ -152,7 +151,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 @@ -166,7 +165,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 48569e691..8b9e0ad5c 100644 --- a/tests/unit/rpc/handlers/LedgerRangeTests.cpp +++ b/tests/unit/rpc/handlers/LedgerRangeTests.cpp @@ -8,7 +8,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -26,7 +25,7 @@ TEST_F(RPCLedgerRangeTest, LedgerRangeMinMaxSame) backend_->updateRange(kRangeMin); 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(); @@ -41,7 +40,7 @@ TEST_F(RPCLedgerRangeTest, LedgerRangeFullySet) backend_->setRange(kRangeMin, kRangeMax); 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 8e1d7a5a7..5c9fb44fd 100644 --- a/tests/unit/rpc/handlers/LedgerTests.cpp +++ b/tests/unit/rpc/handlers/LedgerTests.cpp @@ -44,7 +44,6 @@ constexpr auto kApiVersion = 2; using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; struct RPCLedgerHandlerTest : HandlerBaseTest { @@ -174,7 +173,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()); @@ -190,7 +189,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": {} @@ -213,7 +212,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": "{}" @@ -232,12 +231,12 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}" @@ -282,12 +281,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -300,7 +299,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, @@ -320,7 +319,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")); @@ -331,12 +330,13 @@ TEST_F(RPCLedgerHandlerTest, QueryViaLedgerHash) { auto const ledgerHeader = createLedgerHeader(kLedgerHash, kRangeMax); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kIndex1}, _)) + 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")); @@ -362,14 +362,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -414,7 +414,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, @@ -423,7 +423,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinary) ); auto const output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -468,7 +468,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, @@ -478,7 +478,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsExpandBinaryV2) auto const output = handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -561,7 +561,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, @@ -572,7 +572,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -658,7 +658,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, @@ -669,7 +669,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -696,7 +696,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, @@ -706,7 +706,7 @@ TEST_F(RPCLedgerHandlerTest, TwoRequestInARowTransactionsExpandNotBinaryV2) auto output = handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - auto const req2 = json::parse( + auto const req2 = boost::json::parse( fmt::format( R"JSON({{ "binary": false, @@ -734,11 +734,11 @@ TEST_F(RPCLedgerHandlerTest, TransactionsNotExpand) EXPECT_CALL(*backend_, fetchAllTransactionHashesInLedger).Times(1); ON_CALL(*backend_, fetchAllTransactionHashesInLedger(kRangeMax, _)) - .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" @@ -747,7 +747,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)) ); }); } @@ -786,12 +786,12 @@ TEST_F(RPCLedgerHandlerTest, DiffNotBinary) EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); los.push_back( - LedgerObject{.key = ripple::uint256{kIndex2}, .blob = Blob{}} + 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() } @@ -801,14 +801,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(kExpectedOut)); + EXPECT_EQ(output.result->at("ledger").at("diff"), boost::json::parse(kExpectedOut)); }); } @@ -835,12 +835,12 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary) EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); los.push_back( - LedgerObject{.key = ripple::uint256{kIndex2}, .blob = Blob{}} + 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() } @@ -850,7 +850,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 @@ -858,7 +858,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(kExpectedOut)); + EXPECT_EQ(output.result->at("ledger").at("diff"), boost::json::parse(kExpectedOut)); }); } @@ -941,7 +941,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, @@ -953,7 +953,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1021,7 +1021,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).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, kRangeMax, 200 /*balance*/, 2 /*owner object*/, kIndex1, kRangeMax - 1, 0 @@ -1033,7 +1033,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, kRangeMax, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRangeMax, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1055,7 +1055,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, @@ -1067,7 +1067,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(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1096,7 +1096,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).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, kRangeMax, 200 /*balance*/, 2 /*owner object*/, kIndex1, kRangeMax - 1, 0 @@ -1108,7 +1108,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, kRangeMax, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRangeMax, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1130,7 +1130,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, @@ -1140,7 +1140,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) ); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1167,7 +1167,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, @@ -1210,7 +1210,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) ON_CALL(*backend_, fetchLedgerBySequence(kRangeMax, _)).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, kRangeMax, 6 /*balance*/, 2 /*owner object*/, kIndex1, kRangeMax - 1, 0 @@ -1222,7 +1222,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, kRangeMax, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRangeMax, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1244,7 +1244,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, @@ -1254,7 +1254,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) ); auto output = handler.process(req, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOut)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOut)); }); } @@ -1268,10 +1268,10 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotXRP) 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, kRangeMax, _)) @@ -1296,7 +1296,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, @@ -1334,12 +1334,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, kRangeMax, _)) @@ -1364,7 +1364,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 6a4ab8250..58619c497 100644 --- a/tests/unit/rpc/handlers/MPTHoldersTests.cpp +++ b/tests/unit/rpc/handlers/MPTHoldersTests.cpp @@ -11,10 +11,10 @@ #include #include #include -#include -#include -#include +#include #include +#include +#include #include #include @@ -23,7 +23,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -62,7 +61,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": "{}", @@ -84,7 +83,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": "{}", @@ -106,7 +105,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": "{}", @@ -129,7 +128,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)}); @@ -145,7 +144,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()); @@ -159,7 +158,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)}); @@ -176,7 +175,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": "{}", @@ -198,7 +197,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": "{}", @@ -220,10 +219,10 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillByDefault(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -249,8 +248,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); - auto const input = json::parse( + .WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -273,8 +272,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); - auto const input = json::parse( + .WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -299,10 +298,10 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerinfo = createLedgerHeader(kLedgerHash, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -328,7 +327,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": "{}", @@ -351,13 +350,13 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCMPTHoldersHandlerTest, MPTNotFound) { auto ledgerinfo = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -394,23 +393,23 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters) auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); + auto const mptoken = createMpTokenObject(kHoldeR1Account, xrpl::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + xrpl::uint192(kMptId), 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": "{}" @@ -422,7 +421,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); }); } @@ -448,23 +447,23 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts) auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId), 0); + auto const mptoken = createMpTokenObject(kHoldeR1Account, xrpl::uint192(kMptId), 0); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + xrpl::uint192(kMptId), 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": "{}" @@ -476,7 +475,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); }); } @@ -499,18 +498,18 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex) auto ledgerInfo = createLedgerHeader(kLedgerHash, specificLedger); ON_CALL(*backend_, fetchLedgerBySequence(specificLedger, _)).WillByDefault(Return(ledgerInfo)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, specificLedger, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); + auto const mptoken = createMpTokenObject(kHoldeR1Account, xrpl::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMptId), + xrpl::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(specificLedger), @@ -519,7 +518,7 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -533,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); }); } @@ -550,16 +549,16 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter) }})JSON", kMptId, kMptOuT2, - ripple::strHex(getAccountIdWithString(kHoldeR1Account)) + xrpl::strHex(getAccountIdWithString(kHoldeR1Account)) ); auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHoldeR2Account, ripple::uint192(kMptId)); + auto const mptoken = createMpTokenObject(kHoldeR2Account, xrpl::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; auto const marker = getAccountIdWithString(kHoldeR1Account); ON_CALL(*backend_, fetchMPTHolders) @@ -567,13 +566,13 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter) EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMptId), testing::_, testing::Eq(marker), Const(30), testing::_ + xrpl::uint192(kMptId), testing::_, testing::Eq(marker), Const(30), testing::_ ) ) .Times(1); - auto const holder1AccountId = ripple::strHex(getAccountIdWithString(kHoldeR1Account)); - auto const input = json::parse( + auto const holder1AccountId = xrpl::strHex(getAccountIdWithString(kHoldeR1Account)); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "mpt_issuance_id": "{}", @@ -587,7 +586,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); }); } @@ -608,12 +607,12 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken1 = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); - auto const mptoken2 = createMpTokenObject(kHoldeR2Account, ripple::uint192(kMptId)); + auto const mptoken1 = createMpTokenObject(kHoldeR1Account, xrpl::uint192(kMptId)); + auto const mptoken2 = createMpTokenObject(kHoldeR2Account, xrpl::uint192(kMptId)); std::vector const mpts = { mptoken1.getSerializer().peekData(), mptoken2.getSerializer().peekData() }; @@ -622,12 +621,12 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMptId), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + xrpl::uint192(kMptId), 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": "{}" @@ -639,7 +638,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); }); } @@ -659,18 +658,18 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx) auto ledgerInfo = createLedgerHeader(kLedgerHash, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMptId)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMptId)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHoldeR1Account, ripple::uint192(kMptId)); + auto const mptoken = createMpTokenObject(kHoldeR1Account, xrpl::uint192(kMptId)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMptId), + xrpl::uint192(kMptId), Const(MPTHoldersHandler::kLimitMax), testing::Eq(std::nullopt), Const(30), @@ -679,7 +678,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": "{}", @@ -693,6 +692,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 29a9cb67c..57291e265 100644 --- a/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp @@ -23,7 +23,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -47,7 +46,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": "{}", @@ -69,7 +68,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": "{}", @@ -90,7 +89,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": "{}", @@ -111,7 +110,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": "{}", @@ -132,7 +131,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": "{}", @@ -154,7 +153,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": "{}", @@ -177,7 +176,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}); @@ -193,7 +192,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}); @@ -209,11 +208,11 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .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": "{}", @@ -239,9 +238,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -266,10 +265,10 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -295,7 +294,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": "{}", @@ -318,12 +317,12 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTBuyOffersHandlerTest, NoNFT) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -347,7 +346,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": "{}", @@ -366,12 +365,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": "{}", @@ -389,7 +388,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": "{}", @@ -433,9 +432,9 @@ 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{kNftId}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNftId}); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + createOwnerDirLedgerObject({xrpl::uint256{kIndex1}, xrpl::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -449,7 +448,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": "{}" @@ -462,7 +461,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, DefaultParameters) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCorrectOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCorrectOutput), *output.result); }); } @@ -474,16 +473,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(kNftId, 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())); @@ -492,7 +491,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": "{}", @@ -523,29 +522,29 @@ 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(kNftId, 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(kNftId, kAccount); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(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{kNftId}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNftId}); 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); @@ -553,7 +552,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": "{}", @@ -587,29 +586,29 @@ 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(kNftId, 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(kNftId, kAccount); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(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{kNftId}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNftId}); 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); @@ -619,7 +618,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": "{}", @@ -640,7 +639,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": "{}", @@ -655,7 +654,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": "{}", @@ -676,9 +675,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{kNftId}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTBuyOffersHandler::kLimitMin + 1, ripple::uint256{kIndex1}}, kIndex1 + std::vector{NFTBuyOffersHandler::kLimitMin + 1, xrpl::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -694,7 +693,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": "{}", @@ -721,9 +720,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{kNftId}); + auto const directory = xrpl::keylet::nftBuys(xrpl::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTBuyOffersHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 + std::vector{NFTBuyOffersHandler::kLimitMax + 1, xrpl::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -739,7 +738,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 2a9f679c8..e0d9f271f 100644 --- a/tests/unit/rpc/handlers/NFTHistoryTests.cpp +++ b/tests/unit/rpc/handlers/NFTHistoryTests.cpp @@ -21,7 +21,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -237,7 +236,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); @@ -252,21 +251,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); @@ -293,7 +290,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": "{}", @@ -313,7 +310,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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")); @@ -435,7 +432,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": "{}", @@ -576,7 +573,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": "{}", @@ -616,7 +613,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": "{}", @@ -636,7 +633,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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 +660,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": "{}", @@ -683,7 +680,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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")); @@ -710,7 +707,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": "{}", @@ -730,7 +727,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( @@ -772,7 +769,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": "{}", @@ -793,7 +790,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); EXPECT_EQ( @@ -836,7 +833,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": "{}", @@ -859,7 +856,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) 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") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); EXPECT_EQ(output.result->at("transactions").as_array().size(), 2); }); @@ -890,7 +887,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": "{}", @@ -918,7 +915,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": "{}", @@ -943,7 +940,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": "{}", @@ -982,12 +979,12 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash) auto const ledgerHeader = createLedgerHeader(kLedgerHash, kMaxSeq - 1); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -1028,7 +1025,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": "{}", @@ -1072,7 +1069,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": "{}", @@ -1094,7 +1091,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) 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") + boost::json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") ); }); } @@ -1119,7 +1116,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": "{}", @@ -1141,7 +1138,7 @@ TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMaxSeq - 1); EXPECT_EQ( output.result->at("marker").as_object(), - json::parse(R"JSON({"ledger": 12, "seq": 34})JSON") + 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::kLimitMax); diff --git a/tests/unit/rpc/handlers/NFTInfoTests.cpp b/tests/unit/rpc/handlers/NFTInfoTests.cpp index 01b8625d6..443199e03 100644 --- a/tests/unit/rpc/handlers/NFTInfoTests.cpp +++ b/tests/unit/rpc/handlers/NFTInfoTests.cpp @@ -19,7 +19,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -42,7 +41,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": "{}", @@ -64,7 +63,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": "{}", @@ -86,7 +85,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": "{}", @@ -109,7 +108,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}); @@ -125,7 +124,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}); @@ -141,11 +140,11 @@ TEST_F(RPCNFTInfoHandlerTest, NFTIDNotString) TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .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": "{}", @@ -171,9 +170,9 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -196,9 +195,9 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -223,10 +222,10 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -252,7 +251,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": "{}", @@ -275,13 +274,13 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTInfoHandlerTest, NonExistNFT) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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{kNftId}, 30, _)).Times(1); - auto const input = json::parse( + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNftId}, 30, _)).Times(1); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}", @@ -325,9 +324,9 @@ TEST_F(RPCNFTInfoHandlerTest, DefaultParameters) // fetch nft return something auto const nft = std::make_optional(createNft(kNftId, kAccount, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftId}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNftId}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -339,7 +338,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(kCurrentOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCurrentOutput), *output.result); }); } @@ -366,12 +365,12 @@ TEST_F(RPCNFTInfoHandlerTest, BurnedNFT) // fetch nft return something auto const nft = std::make_optional( - createNft(kNftId, kAccount, ledgerHeader.seq, ripple::Blob{'u', 'r', 'i'}, true) + createNft(kNftId, kAccount, ledgerHeader.seq, xrpl::Blob{'u', 'r', 'i'}, true) ); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftId}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNftId}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -383,7 +382,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(kCurrentOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCurrentOutput), *output.result); }); } @@ -410,11 +409,11 @@ TEST_F(RPCNFTInfoHandlerTest, NotBurnedNFTWithoutURI) // fetch nft return something auto const nft = - std::make_optional(createNft(kNftId, kAccount, ledgerHeader.seq, ripple::Blob{})); + std::make_optional(createNft(kNftId, kAccount, ledgerHeader.seq, xrpl::Blob{})); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftId}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNftId}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -426,7 +425,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(kCurrentOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCurrentOutput), *output.result); }); } @@ -454,9 +453,9 @@ TEST_F(RPCNFTInfoHandlerTest, NFTWithExtraFieldsSet) // fetch nft return something auto const nft = std::make_optional(createNft(kNftID2, kAccount, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNftID2}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNftID2}, 30, _)).Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "nft_id": "{}" @@ -468,6 +467,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(kCurrentOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCurrentOutput), *output.result); }); } diff --git a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp index 37a5920d9..94e4c1e18 100644 --- a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp @@ -23,7 +23,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -47,7 +46,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": "{}", @@ -68,7 +67,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": "{}", @@ -89,7 +88,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": "{}", @@ -110,7 +109,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": "{}", @@ -132,7 +131,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": "{}", @@ -154,7 +153,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": "{}", @@ -177,7 +176,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}); @@ -193,7 +192,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}); @@ -209,11 +208,11 @@ TEST_F(RPCNFTSellOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .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": "{}", @@ -239,9 +238,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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": "{}", @@ -266,10 +265,10 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -295,7 +294,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": "{}", @@ -318,12 +317,12 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTSellOffersHandlerTest, NoNFT) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -347,7 +346,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": "{}", @@ -366,12 +365,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": "{}", @@ -389,7 +388,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": "{}", @@ -433,9 +432,9 @@ 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{kNftId}); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNftId}); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); + createOwnerDirLedgerObject({xrpl::uint256{kIndex1}, xrpl::uint256{kIndex2}}, kIndex1); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -449,7 +448,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": "{}" @@ -462,7 +461,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, DefaultParameters) auto const output = handler.process(input, Context{yield}); ASSERT_TRUE(output); - EXPECT_EQ(json::parse(kCorrectOutput), *output.result); + EXPECT_EQ(boost::json::parse(kCorrectOutput), *output.result); }); } @@ -474,16 +473,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(kNftId, 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())); @@ -492,7 +491,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": "{}", @@ -523,29 +522,29 @@ 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(kNftId, 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(kNftId, kAccount); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(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{kNftId}); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNftId}); 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); @@ -553,7 +552,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": "{}", @@ -587,29 +586,29 @@ 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(kNftId, 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(kNftId, kAccount); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(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{kNftId}); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNftId}); 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); @@ -619,7 +618,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": "{}", @@ -640,7 +639,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": "{}", @@ -655,7 +654,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": "{}", @@ -676,9 +675,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{kNftId}); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLimitMin + 1, ripple::uint256{kIndex1}}, kIndex1 + std::vector{NFTSellOffersHandler::kLimitMin + 1, xrpl::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -694,7 +693,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": "{}", @@ -721,9 +720,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{kNftId}); + auto const directory = xrpl::keylet::nftSells(xrpl::uint256{kNftId}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 + std::vector{NFTSellOffersHandler::kLimitMax + 1, xrpl::uint256{kIndex1}}, kIndex1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -739,7 +738,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 ef68bddc5..1d90427e4 100644 --- a/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp +++ b/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp @@ -22,7 +22,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -89,7 +88,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": "{}", @@ -111,7 +110,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": "{}", @@ -133,7 +132,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": "{}", @@ -156,7 +155,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)}); @@ -172,7 +171,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()); @@ -186,7 +185,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)}); @@ -203,10 +202,10 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) + .WillByDefault(Return(std::optional{})); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -232,8 +231,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); - auto const input = json::parse( + .WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -256,8 +255,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); - auto const input = json::parse( + .WillOnce(Return(std::optional{})); + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -282,10 +281,10 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLedgerHash, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -311,7 +310,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": "{}", @@ -334,13 +333,13 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTsByIssuerHandlerTest, AccountNotFound) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -377,7 +376,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) auto ledgerHeader = createLedgerHeader(kLedgerHash, 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'})); @@ -390,7 +389,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}" @@ -402,7 +401,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); }); } @@ -436,7 +435,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex) 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'})); @@ -450,7 +449,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -464,7 +463,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); }); } @@ -485,7 +484,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) auto ledgerHeader = createLedgerHeader(kLedgerHash, 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'})); @@ -498,7 +497,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -511,7 +510,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); }); } @@ -532,20 +531,20 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MarkerParameter) auto ledgerHeader = createLedgerHeader(kLedgerHash, 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(kNftID3, kAccount, 29)}; auto const account = getAccountIdWithString(kAccount); ON_CALL(*backend_, fetchNFTsByIssuer) - .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = ripple::uint256{kNftID3}})); + .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = xrpl::uint256{kNftID3}})); EXPECT_CALL( - *backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(ripple::uint256{kNftID1}), _) + *backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(xrpl::uint256{kNftID1}), _) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -559,7 +558,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); }); } @@ -581,7 +580,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) auto ledgerHeader = createLedgerHeader(kLedgerHash, 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'})); @@ -598,7 +597,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}" @@ -610,7 +609,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); }); } @@ -630,7 +629,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) auto ledgerHeader = createLedgerHeader(kLedgerHash, 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'})); @@ -651,7 +650,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) ) .Times(1); - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "issuer": "{}", @@ -665,6 +664,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 79b8e3897..219abe71b 100644 --- a/tests/unit/rpc/handlers/NoRippleCheckTests.cpp +++ b/tests/unit/rpc/handlers/NoRippleCheckTests.cpp @@ -22,7 +22,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -157,7 +156,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); @@ -180,7 +179,7 @@ TEST_F(NoRippleCheckParameterTest, V1ApiTransactionsIsNotBool) EXPECT_CALL(*backend_, fetchLedgerBySequence); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{NoRippleCheckHandler{backend_}}; - auto const req = json::parse(kReqJson); + auto const req = boost::json::parse(kReqJson); auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1}); ASSERT_FALSE(output); @@ -194,10 +193,10 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(std::nullopt)); - static auto const kInput = json::parse( + static auto const kInput = boost::json::parse( fmt::format( R"JSON({{ "account": "{}", @@ -226,7 +225,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": "{}", @@ -255,7 +254,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": "{}", @@ -279,13 +278,13 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaStringIndex) TEST_F(RPCNoRippleCheckTest, AccountNotExist) { auto ledgerHeader = createLedgerHeader(kLedgerHash, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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": "{}", @@ -320,30 +319,30 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple })JSON"; auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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() - )); + .WillByDefault( + Return(createAccountRootObject(kAccount, xrpl::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; + 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, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -353,7 +352,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": "{}", @@ -368,7 +367,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(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } @@ -387,7 +386,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp })JSON"; auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -397,8 +396,8 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp 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; + 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); @@ -418,7 +417,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": "{}", @@ -433,7 +432,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(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } @@ -452,30 +451,30 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip })JSON"; auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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() - )); + .WillByDefault( + Return(createAccountRootObject(kAccount, xrpl::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; + 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, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -485,7 +484,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": "{}", @@ -500,7 +499,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(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } @@ -518,7 +517,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR })JSON"; auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -528,8 +527,8 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR 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; + 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); @@ -549,7 +548,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": "{}", @@ -564,7 +563,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(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } @@ -576,7 +575,7 @@ TEST_F( static constexpr auto kSeq = 30; auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -586,11 +585,11 @@ TEST_F( 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; + 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); @@ -609,7 +608,7 @@ TEST_F( 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": "{}", @@ -635,30 +634,30 @@ TEST_F(RPCNoRippleCheckTest, NormalPathLimit) constexpr auto kSeq = 30; auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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() - )); + .WillByDefault( + Return(createAccountRootObject(kAccount, xrpl::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; + 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, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -668,7 +667,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": "{}", @@ -738,13 +737,13 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) }})JSON", kTransactionSeq, kTransactionSeq + 1, - ripple::tfClearNoRipple, + xrpl::tfClearNoRipple, kTransactionSeq + 2, - ripple::tfClearNoRipple + xrpl::tfClearNoRipple ); auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -756,20 +755,20 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) .peekData()) ); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kIndex1}, ripple::uint256{kIndex2}}, kIndex1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kAccount)).key; + 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, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -779,7 +778,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": "{}", @@ -795,7 +794,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)); }); } @@ -804,27 +803,27 @@ TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax) constexpr auto kSeq = 30; auto ledgerHeader = createLedgerHeader(kLedgerHash, kSeq); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLedgerHash}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLedgerHash}, _)) .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() - )); + .WillByDefault( + Return(createAccountRootObject(kAccount, xrpl::lsfDefaultRipple, 2, 200, 2, kIndex1, 2) + .getSerializer() + .peekData()) + ); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NoRippleCheckHandler::kLimitMax + 1, ripple::uint256{kIndex1}}, kIndex1 + std::vector{NoRippleCheckHandler::kLimitMax + 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, kSeq, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, ripple::lsfLowNoRipple + "USD", kIssuer, 100, kAccount, 10, kAccount2, 20, kTxnId, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -836,7 +835,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 aaa4473df..c1e7cbdfc 100644 --- a/tests/unit/rpc/handlers/ServerInfoTests.cpp +++ b/tests/unit/rpc/handlers/ServerInfoTests.cpp @@ -24,7 +24,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using TestServerInfoHandler = BaseServerInfoHandler; @@ -128,7 +127,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); @@ -153,7 +152,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); @@ -193,7 +192,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, kClientIp}); validateNormalOutput(output); @@ -236,7 +235,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, kClientIp}); validateNormalOutput(output); @@ -277,7 +276,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, kClientIp}); validateNormalOutput(output); @@ -318,7 +317,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, kClientIp}); validateNormalOutput(output); @@ -332,7 +331,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, kClientIp}); validateNormalOutput(output); @@ -350,7 +349,7 @@ TEST_F(RPCServerInfoHandlerTest, AdminSectionPresentWhenAdminFlagIsSet) MockCounters const* rawCountersPtr = mockCountersPtr_.get(); MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -379,7 +378,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); @@ -393,7 +392,7 @@ TEST_F(RPCServerInfoHandlerTest, BackendCountersPresentWhenRequestWithParam) MockCounters const* rawCountersPtr = mockCountersPtr_.get(); MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -425,7 +424,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 } @@ -443,7 +442,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesPresent) MockCounters const* rawCountersPtr = mockCountersPtr_.get(); MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -454,7 +453,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", @@ -482,7 +481,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); @@ -497,7 +496,7 @@ TEST_F(RPCServerInfoHandlerTest, RippledForwardedValuesMissingNoExceptionThrown) MockCounters const* rawCountersPtr = mockCountersPtr_.get(); MockETLService const* rawETLServicePtr = mockETLServicePtr_.get(); - auto const empty = json::object{}; + auto const empty = boost::json::object{}; auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30, 3); // 3 seconds old EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); @@ -508,7 +507,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": {} } @@ -531,7 +530,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 6868d9c47..5825e3d4c 100644 --- a/tests/unit/rpc/handlers/SubscribeTests.cpp +++ b/tests/unit/rpc/handlers/SubscribeTests.cpp @@ -32,7 +32,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using std::chrono::milliseconds; @@ -570,7 +569,7 @@ TEST_P(SubscribeParameterTest, InvalidParams) 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()); @@ -586,7 +585,8 @@ TEST_F(RPCSubscribeHandlerTest, EmptyResponse) 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()); }); @@ -595,7 +595,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" @@ -630,7 +630,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" @@ -646,13 +646,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(kExpectedOutput)); + EXPECT_EQ(output.result->as_object(), boost::json::parse(kExpectedOutput)); }); } TEST_F(RPCSubscribeHandlerTest, Accounts) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "accounts": ["{}", "{}", "{}"] @@ -683,7 +683,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": ["{}", "{}", "{}"] @@ -716,7 +716,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": [ @@ -748,7 +748,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": [ @@ -781,7 +781,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": [ @@ -807,49 +807,41 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + 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 + xrpl::xrpCurrency(), xrpl::xrpAccount(), xrpl::toCurrency("USD"), issuer, std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMaxSeq, _)) - .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); + .WillByDefault(Return(xrpl::uint256{kPayS20UsdGetS10XrpBookDir})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault(Return(std::nullopt)); ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMaxSeq, _)) - .WillByDefault(Return(ripple::uint256{kPayS20XrpGetS10UsdBookDir})); + .WillByDefault(Return(xrpl::uint256{kPayS20XrpGetS10UsdBookDir})); 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{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) + auto const indexes = std::vector(10, xrpl::uint256{kIndex2}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kIndex1}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20XrpGetS10UsdBookDir}, kMaxSeq, _)) + auto const indexes2 = std::vector(10, xrpl::uint256{kIndex1}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, kMaxSeq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes2, kIndex2).getSerializer().peekData()) ); @@ -858,7 +850,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kAccount2)).key, kMaxSeq, _ + xrpl::keylet::account(getAccountIdWithString(kAccount2)).key, kMaxSeq, _ ) ) .WillByDefault(Return( @@ -868,9 +860,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) // issuer account root ON_CALL( *backend_, - doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kAccount)).key, kMaxSeq, _ - ) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, kMaxSeq, _) ) .WillByDefault(Return( createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() @@ -878,16 +868,16 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMaxSeq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kMaxSeq, _)) .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, kPayS20UsdGetS10XrpBookDir ); @@ -898,10 +888,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()), kPayS20XrpGetS10UsdBookDir ); @@ -976,18 +966,18 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) 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(kExpectedOffer) + boost::json::parse(kExpectedOffer) ); EXPECT_EQ( output.result->as_object().at("asks").as_array()[0].as_object(), - json::parse(kExpectedReversedOffer) + boost::json::parse(kExpectedReversedOffer) ); }); } TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) { - auto const input = json::parse( + auto const input = boost::json::parse( fmt::format( R"JSON({{ "books": [ @@ -1012,48 +1002,40 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + 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 + xrpl::xrpCurrency(), xrpl::xrpAccount(), xrpl::toCurrency("USD"), issuer, std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMaxSeq, _)) - .WillByDefault(Return(ripple::uint256{kPayS20UsdGetS10XrpBookDir})); + .WillByDefault(Return(xrpl::uint256{kPayS20UsdGetS10XrpBookDir})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault(Return(std::nullopt)); ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMaxSeq, _)) - .WillByDefault(Return(ripple::uint256{kPayS20XrpGetS10UsdBookDir})); + .WillByDefault(Return(xrpl::uint256{kPayS20XrpGetS10UsdBookDir})); 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{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) + auto const indexes = std::vector(10, xrpl::uint256{kIndex2}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPayS20UsdGetS10XrpBookDir}, kMaxSeq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kIndex1).getSerializer().peekData()) ); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kIndex1}); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPayS20XrpGetS10UsdBookDir}, kMaxSeq, _)) + auto const indexes2 = std::vector(10, xrpl::uint256{kIndex1}); + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPayS20XrpGetS10UsdBookDir}, kMaxSeq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes2, kIndex2).getSerializer().peekData()) ); @@ -1062,7 +1044,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kAccount2)).key, kMaxSeq, _ + xrpl::keylet::account(getAccountIdWithString(kAccount2)).key, kMaxSeq, _ ) ) .WillByDefault(Return( @@ -1072,9 +1054,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) // issuer account root ON_CALL( *backend_, - doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kAccount)).key, kMaxSeq, _ - ) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kAccount)).key, kMaxSeq, _) ) .WillByDefault(Return( createAccountRootObject(kAccount, 0, 2, 200, 2, kIndex1, 2).getSerializer().peekData() @@ -1082,16 +1062,16 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMaxSeq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kMaxSeq, _)) .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, kPayS20UsdGetS10XrpBookDir ); @@ -1102,10 +1082,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()), kPayS20XrpGetS10UsdBookDir ); @@ -1155,14 +1135,14 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) 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(kExpectedOffer) + boost::json::parse(kExpectedOffer) ); }); } 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 4804f7060..c30c39f15 100644 --- a/tests/unit/rpc/handlers/TestHandlerTests.cpp +++ b/tests/unit/rpc/handlers/TestHandlerTests.cpp @@ -12,8 +12,6 @@ using namespace rpc; using namespace rpc::validation; using namespace tests::common; -namespace json = boost::json; - class RPCTestHandlerTest : public HandlerBaseTest {}; // example handler tests @@ -21,7 +19,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"); @@ -38,7 +36,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(); @@ -50,7 +48,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"); @@ -60,7 +58,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."); }); } @@ -69,7 +67,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 ce30d8d36..f0970db83 100644 --- a/tests/unit/rpc/handlers/TransactionEntryTests.cpp +++ b/tests/unit/rpc/handlers/TransactionEntryTests.cpp @@ -17,7 +17,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; namespace { @@ -42,7 +41,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"); @@ -55,7 +54,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}); + 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"); @@ -66,11 +65,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": "{}", @@ -95,9 +94,9 @@ TEST_F(RPCTransactionEntryHandlerTest, NonExistLedgerViaLedgerIndex) { // mock fetchLedgerBySequence return empty ON_CALL(*backend_, fetchLedgerBySequence) - .WillByDefault(Return(std::optional{})); + .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", @@ -120,12 +119,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{kTxnId}, _)) + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)) .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": "{}" @@ -152,7 +151,7 @@ TEST_F(RPCTransactionEntryHandlerTest, LedgerSeqNotMatch) .peekData(); tx.date = 123456; tx.ledgerSequence = 10; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kIndex, 30))); @@ -160,7 +159,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": "{}", @@ -227,7 +226,7 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPath) .peekData(); tx.date = 123456; tx.ledgerSequence = 30; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); ON_CALL(*backend_, fetchLedgerBySequence) @@ -236,7 +235,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": "{}", @@ -248,7 +247,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); }); } @@ -303,13 +302,13 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) .peekData(); tx.date = 123456; tx.ledgerSequence = 30; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).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": "{}", @@ -322,6 +321,6 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) auto const output = handler.process(req, Context{.yield = yield, .apiVersion = kApiVersion}); 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 4b78f763b..b8acacc69 100644 --- a/tests/unit/rpc/handlers/TxTests.cpp +++ b/tests/unit/rpc/handlers/TxTests.cpp @@ -22,7 +22,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using TestTxHandler = TxHandler; @@ -131,7 +130,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", @@ -162,7 +161,7 @@ TEST_F(RPCTxTest, InvalidBinaryV1) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -170,7 +169,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", @@ -189,7 +188,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", @@ -212,7 +211,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", @@ -234,7 +233,7 @@ TEST_F(RPCTxTest, InvalidLgrRange) TEST_F(RPCTxTest, TxnNotFound) { - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -243,7 +242,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", @@ -264,7 +263,7 @@ TEST_F(RPCTxTest, TxnNotFound) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) { backend_->setRange(10, 30); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -273,7 +272,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", @@ -297,7 +296,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue) { backend_->setRange(1, 1000); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -306,7 +305,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", @@ -341,7 +340,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": "{}", @@ -373,7 +372,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -381,7 +380,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", @@ -393,7 +392,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(kDefaultOuT1)); + EXPECT_EQ(*output.result, boost::json::parse(kDefaultOuT1)); }); } @@ -407,7 +406,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v1) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -415,7 +414,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", @@ -441,7 +440,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v2) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)) .WillOnce(Return(std::nullopt)); @@ -451,7 +450,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", @@ -480,7 +479,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const ledgerHeader = createLedgerHeader(kLedgerHash, tx.ledgerSequence); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)) .WillOnce(Return(ledgerHeader)); @@ -491,7 +490,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", @@ -502,7 +501,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(kDefaultOuT2)); + EXPECT_EQ(*output.result, boost::json::parse(kDefaultOuT2)); }); } @@ -529,7 +528,7 @@ TEST_F(RPCTxTest, ReturnBinary) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).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)); }); } @@ -577,7 +576,7 @@ TEST_F(RPCTxTest, ReturnBinaryWithCTID) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -585,7 +584,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", @@ -597,7 +596,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)); }); } @@ -664,7 +663,7 @@ TEST_F(RPCTxTest, MintNFT) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -672,7 +671,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", @@ -683,7 +682,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)); }); } @@ -694,7 +693,7 @@ TEST_F(RPCTxTest, NFTAcceptOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -702,7 +701,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", @@ -724,7 +723,7 @@ TEST_F(RPCTxTest, NFTCancelOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -732,7 +731,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", @@ -763,7 +762,7 @@ TEST_F(RPCTxTest, NFTCreateOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -771,7 +770,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", @@ -790,7 +789,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", @@ -814,7 +813,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); @@ -828,7 +827,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); @@ -846,7 +845,8 @@ 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); @@ -864,7 +864,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", @@ -878,7 +878,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" @@ -936,7 +936,7 @@ TEST_F(RPCTxTest, ReturnCTIDForTxInput) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -944,7 +944,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", @@ -955,7 +955,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)); }); } @@ -1008,7 +1008,7 @@ TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTxnId}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -1016,7 +1016,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", @@ -1027,7 +1027,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)); }); } @@ -1103,7 +1103,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", @@ -1114,7 +1114,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)); }); } @@ -1149,7 +1149,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 910156334..c515bf775 100644 --- a/tests/unit/rpc/handlers/UnsubscribeTests.cpp +++ b/tests/unit/rpc/handlers/UnsubscribeTests.cpp @@ -23,7 +23,6 @@ using namespace rpc; using namespace data; -namespace json = boost::json; using namespace testing; using namespace feed; @@ -492,7 +491,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()); @@ -505,7 +504,8 @@ 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()); }); @@ -513,7 +513,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" @@ -536,7 +536,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": ["{}", "{}"] @@ -569,7 +569,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 +602,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": [ @@ -627,7 +627,7 @@ TEST_F(RPCUnsubscribeTest, Books) auto const book = *parsedBookMaybe; 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_}}; @@ -639,7 +639,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 c8de38425..414e735b7 100644 --- a/tests/unit/rpc/handlers/VaultInfoTests.cpp +++ b/tests/unit/rpc/handlers/VaultInfoTests.cpp @@ -24,7 +24,6 @@ using namespace rpc; using namespace data; using namespace testing; -namespace json = boost::json; namespace { @@ -168,7 +167,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 = kApiVersion}); ASSERT_FALSE(output); @@ -209,7 +208,7 @@ TEST_F(RPCVaultInfoHandlerTest, InputHasOwnerButNotFoundResultsInError) ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "entryNotFound"); - EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::rpcENTRY_NOT_FOUND); + EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::RpcEntryNotFound); EXPECT_EQ(err.at("error_message").as_string(), "Entry not found."); }); } @@ -220,7 +219,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{kVaultId}; + xrpl::uint256 const vaultKey = xrpl::uint256{kVaultId}; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKey, kSeq, _)) .WillOnce(Return(std::nullopt)); // intentionally invalid vault @@ -241,7 +240,7 @@ TEST_F(RPCVaultInfoHandlerTest, VaultIDFailsVaultDeserializationReturnsEntryNotF ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "entryNotFound"); - EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::rpcENTRY_NOT_FOUND); + EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::RpcEntryNotFound); EXPECT_EQ(err.at("error_message").as_string(), "vault object not found."); }); } @@ -251,8 +250,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; @@ -268,8 +267,8 @@ TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) prevTxSeq ); - auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVaultId}).key; - auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; + auto const vaultKeylet = xrpl::keylet::vault(xrpl::uint256{kVaultId}).key; + auto const mptIssuance = xrpl::keylet::mptIssuance(mptSharesID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSeq, _)) .WillOnce(Return(vault.getSerializer().peekData())); @@ -292,7 +291,7 @@ TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) ASSERT_FALSE(output); auto const err = rpc::makeError(output.result.error()); EXPECT_EQ(err.at("error").as_string(), "entryNotFound"); - EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::rpcENTRY_NOT_FOUND); + EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::RpcEntryNotFound); EXPECT_EQ(err.at("error_message").as_string(), "issuance object not found."); }); } @@ -341,8 +340,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; @@ -361,8 +360,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{kVaultId}).key; - auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; + auto const vaultKeylet = xrpl::keylet::vault(xrpl::uint256{kVaultId}).key; + auto const mptIssuance = xrpl::keylet::mptIssuance(mptSharesID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSeq, _)) .WillOnce(Return(vault.getSerializer().peekData())); @@ -385,7 +384,7 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } @@ -433,8 +432,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; @@ -455,9 +454,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())); @@ -485,6 +484,6 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq) auto const output = handler.process(kInput, Context{.yield = yield, .apiVersion = kApiVersion}); ASSERT_TRUE(output); - EXPECT_EQ(*output.result, json::parse(kExpectedOutput)); + EXPECT_EQ(*output.result, boost::json::parse(kExpectedOutput)); }); } diff --git a/tests/unit/util/AccountUtilsTests.cpp b/tests/unit/util/AccountUtilsTests.cpp index 0a7abe982..f02583998 100644 --- a/tests/unit/util/AccountUtilsTests.cpp +++ b/tests/unit/util/AccountUtilsTests.cpp @@ -11,17 +11,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/LedgerUtilsTests.cpp b/tests/unit/util/LedgerUtilsTests.cpp index 29687fd66..b8ed6d7c1 100644 --- a/tests/unit/util/LedgerUtilsTests.cpp +++ b/tests/unit/util/LedgerUtilsTests.cpp @@ -53,16 +53,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); }); } @@ -70,18 +70,18 @@ TEST(LedgerUtilsTests, DeletionBlockerTypes) { constexpr auto kTestedTypes = util::LedgerTypes::getDeletionBlockerLedgerTypes(); - static constexpr ripple::LedgerEntryType kDeletionBlockers[] = { - 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 kDeletionBlockers[] = { + 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(kDeletionBlockers) == kTestedTypes.size()); @@ -93,92 +93,92 @@ TEST(LedgerUtilsTests, DeletionBlockerTypes) struct LedgerEntryTypeParam { std::string input; - ripple::LedgerEntryType expected; + xrpl::LedgerEntryType expected; }; static LedgerEntryTypeParam const kChainTestCases[] = { // 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 kAccountOwnedTestCases[] = { // 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 = "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 = 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}, + .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 = "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 = 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} + .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 kCaseInsensitiveTestCases[] = { // 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 kInvalidTestCases[] = { - {.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 {}; @@ -224,7 +224,7 @@ INSTANTIATE_TEST_SUITE_P( v.end(), std::begin(kCaseInsensitiveTestCases), std::end(kCaseInsensitiveTestCases) ); v.insert(v.end(), std::begin(kInvalidTestCases), std::end(kInvalidTestCases)); - 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 573c21803..f32d05493 100644 --- a/tests/unit/util/ShasumTests.cpp +++ b/tests/unit/util/ShasumTests.cpp @@ -18,7 +18,7 @@ struct ShasumTest : testing::Test { TEST_F(ShasumTest, sha256sum) { - ripple::uint256 expected; + xrpl::uint256 expected; ASSERT_TRUE(expected.parseHex(kEmptyHash)); EXPECT_EQ(sha256sum(""), expected); @@ -38,7 +38,7 @@ TEST_F(ShasumTest, Sha256sumStreamingEmpty) Sha256sum hasher; auto result = std::move(hasher).finalize(); - ripple::uint256 expected; + xrpl::uint256 expected; ASSERT_TRUE(expected.parseHex(kEmptyHash)); EXPECT_EQ(result, expected); } @@ -50,7 +50,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(kHelloWorldHash)); EXPECT_EQ(result, expected); } @@ -63,7 +63,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(kHelloWorldHash)); EXPECT_EQ(result, expected); } diff --git a/tests/unit/util/TimeUtilsTests.cpp b/tests/unit/util/TimeUtilsTests.cpp index 18b65cf7c..a36e2504d 100644 --- a/tests/unit/util/TimeUtilsTests.cpp +++ b/tests/unit/util/TimeUtilsTests.cpp @@ -76,6 +76,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 aea48de00..6dc976cee 100644 --- a/tests/unit/util/TxUtilTests.cpp +++ b/tests/unit/util/TxUtilTests.cpp @@ -14,14 +14,14 @@ TEST(TxUtilTests, txTypesInLowercase) ASSERT_TRUE( std::size_t( std::distance( - ripple::TxFormats::getInstance().begin(), ripple::TxFormats::getInstance().end() + xrpl::TxFormats::getInstance().begin(), xrpl::TxFormats::getInstance().end() ) ) == types.size() ); std::for_each( - ripple::TxFormats::getInstance().begin(), - ripple::TxFormats::getInstance().end(), + 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 e733437ec..ea3d740b6 100644 --- a/tests/unit/web/AdminVerificationTests.cpp +++ b/tests/unit/web/AdminVerificationTests.cpp @@ -6,8 +6,8 @@ #include "web/AdminVerificationStrategy.hpp" #include -#include -#include +#include +#include #include #include #include @@ -65,7 +65,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 8f6c00a25..4b5fb0fdd 100644 --- a/tests/unit/web/RPCServerHandlerTests.cpp +++ b/tests/unit/web/RPCServerHandlerTests.cpp @@ -479,7 +479,7 @@ TEST_F(WebRPCServerHandlerTest, HTTPErrorPath) .WillOnce( testing::Return( rpc::Result{ - rpc::Status{rpc::RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"} + rpc::Status{rpc::RippledError::RpcInvalidParams, "ledgerIndexMalformed"} } ) ); @@ -534,7 +534,7 @@ TEST_F(WebRPCServerHandlerTest, WsErrorPath) .WillOnce( testing::Return( rpc::Result{ - rpc::Status{rpc::RippledError::rpcINVALID_PARAMS, "ledgerIndexMalformed"} + rpc::Status{rpc::RippledError::RpcInvalidParams, "ledgerIndexMalformed"} } ) ); diff --git a/tests/unit/web/ServerTests.cpp b/tests/unit/web/ServerTests.cpp index 544d2042c..d3a9aef60 100644 --- a/tests/unit/web/ServerTests.cpp +++ b/tests/unit/web/ServerTests.cpp @@ -669,7 +669,7 @@ INSTANTIATE_TEST_CASE_P( WebServerAdminTestParams{ .config = jsonServerConfigWithAdminPassword(tests::util::generateFreePort()), .headers = {WebHeader( - http::field::authentication_info, + http::field::accept, fmt::format( "{}{}", PasswordAdminVerificationStrategy::kPasswordPrefix, diff --git a/tests/unit/web/impl/ErrorHandlingTests.cpp b/tests/unit/web/impl/ErrorHandlingTests.cpp index 56fc934cb..6b36c4cee 100644 --- a/tests/unit/web/impl/ErrorHandlingTests.cpp +++ b/tests/unit/web/impl/ErrorHandlingTests.cpp @@ -46,7 +46,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)); } @@ -135,7 +135,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 }, @@ -177,7 +177,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 ee06d0e59..f0312395e 100644 --- a/tests/unit/web/ng/RPCServerHandlerTests.cpp +++ b/tests/unit/web/ng/RPCServerHandlerTests.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include #include #include @@ -93,7 +93,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); }); } @@ -109,7 +109,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); }); } @@ -126,7 +126,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"); }); @@ -218,7 +218,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); }); } @@ -242,7 +242,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( diff --git a/tests/unit/web/ng/impl/ErrorHandlingTests.cpp b/tests/unit/web/ng/impl/ErrorHandlingTests.cpp index f301662eb..dccd8042d 100644 --- a/tests/unit/web/ng/impl/ErrorHandlingTests.cpp +++ b/tests/unit/web/ng/impl/ErrorHandlingTests.cpp @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #include #include @@ -75,7 +75,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 }, @@ -117,7 +117,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 }, @@ -301,7 +301,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); }