From b0a941650ddcbe5c1cda772a37469eeccf6c5af6 Mon Sep 17 00:00:00 2001 From: Peter Chen Date: Fri, 10 Apr 2026 14:25:46 -0400 Subject: [PATCH] make clio compatible with newest libxrpl --- cmake/deps/OpenSSL.cmake | 2 +- conan.lock | 68 +- conanfile.py | 11 +- docs/examples/config/example-config.json | 6 +- src/data/AmendmentCenter.cpp | 25 +- src/data/AmendmentCenter.hpp | 7 +- src/data/BackendInterface.cpp | 78 +- src/data/BackendInterface.hpp | 66 +- src/data/CassandraBackend.hpp | 31 +- src/data/DBHelpers.hpp | 66 +- src/data/KeyspaceBackend.hpp | 52 +- src/data/LedgerCache.cpp | 8 +- src/data/LedgerCache.hpp | 12 +- src/data/LedgerCacheInterface.hpp | 8 +- src/data/LedgerHeaderCache.hpp | 4 +- src/data/Types.hpp | 36 +- src/data/cassandra/CassandraBackendFamily.hpp | 89 +- src/data/cassandra/impl/Collection.hpp | 6 +- src/data/cassandra/impl/Result.hpp | 12 +- src/data/cassandra/impl/Statement.hpp | 15 +- src/data/cassandra/impl/Tuple.hpp | 4 +- src/data/impl/InputFile.cpp | 2 +- src/data/impl/InputFile.hpp | 2 +- src/data/impl/LedgerCacheFile.cpp | 10 +- src/data/impl/OutputFile.cpp | 2 +- src/data/impl/OutputFile.hpp | 2 +- src/etl/ETLHelpers.cpp | 6 +- src/etl/ETLHelpers.hpp | 2 +- src/etl/ETLService.cpp | 2 +- src/etl/LoaderInterface.hpp | 2 +- src/etl/MPTHelpers.cpp | 38 +- src/etl/MPTHelpers.hpp | 6 +- src/etl/Models.hpp | 22 +- src/etl/NFTHelpers.cpp | 206 +- src/etl/NFTHelpers.hpp | 14 +- src/etl/RegistryInterface.hpp | 10 +- src/etl/impl/AsyncGrpcCall.cpp | 14 +- src/etl/impl/AsyncGrpcCall.hpp | 4 +- src/etl/impl/BaseCursorProvider.hpp | 4 +- src/etl/impl/CacheLoader.hpp | 2 +- src/etl/impl/CursorFromAccountProvider.hpp | 2 +- src/etl/impl/CursorFromDiffProvider.hpp | 6 +- src/etl/impl/CursorFromFixDiffNumProvider.hpp | 2 +- src/etl/impl/Extraction.cpp | 11 +- src/etl/impl/LedgerPublisher.hpp | 20 +- src/etl/impl/Loading.cpp | 2 +- src/etl/impl/Loading.hpp | 2 +- src/etl/impl/ext/MPT.cpp | 2 +- src/etl/impl/ext/Successor.cpp | 12 +- src/etl/impl/ext/Successor.hpp | 2 +- src/feed/SubscriptionManager.cpp | 20 +- src/feed/SubscriptionManager.hpp | 23 +- src/feed/SubscriptionManagerInterface.hpp | 23 +- src/feed/impl/BookChangesFeed.hpp | 2 +- src/feed/impl/LedgerFeed.cpp | 8 +- src/feed/impl/LedgerFeed.hpp | 8 +- src/feed/impl/ProposedTransactionFeed.cpp | 12 +- src/feed/impl/ProposedTransactionFeed.hpp | 8 +- src/feed/impl/TransactionFeed.cpp | 73 +- src/feed/impl/TransactionFeed.hpp | 26 +- .../cassandra/impl/ObjectsAdapter.cpp | 2 +- .../cassandra/impl/ObjectsAdapter.hpp | 4 +- .../cassandra/impl/TransactionsAdapter.cpp | 6 +- .../cassandra/impl/TransactionsAdapter.hpp | 5 +- src/rpc/AMMHelpers.cpp | 30 +- src/rpc/AMMHelpers.hpp | 24 +- src/rpc/BookChangesHelper.hpp | 84 +- src/rpc/CredentialHelpers.cpp | 58 +- src/rpc/CredentialHelpers.hpp | 14 +- src/rpc/Errors.cpp | 6 +- src/rpc/Errors.hpp | 4 +- src/rpc/JS.hpp | 6 +- src/rpc/RPCHelpers.cpp | 553 +++--- src/rpc/RPCHelpers.hpp | 152 +- src/rpc/common/Types.hpp | 4 +- src/rpc/common/Validators.cpp | 30 +- src/rpc/common/Validators.hpp | 8 +- src/rpc/handlers/AMMInfo.cpp | 24 +- src/rpc/handlers/AMMInfo.hpp | 8 +- src/rpc/handlers/AccountChannels.cpp | 43 +- src/rpc/handlers/AccountChannels.hpp | 2 +- src/rpc/handlers/AccountCurrencies.cpp | 18 +- src/rpc/handlers/AccountInfo.cpp | 55 +- src/rpc/handlers/AccountInfo.hpp | 4 +- src/rpc/handlers/AccountLines.cpp | 65 +- src/rpc/handlers/AccountLines.hpp | 6 +- src/rpc/handlers/AccountMPTokenIssuances.cpp | 82 +- src/rpc/handlers/AccountMPTokenIssuances.hpp | 4 +- src/rpc/handlers/AccountMPTokens.cpp | 28 +- src/rpc/handlers/AccountMPTokens.hpp | 2 +- src/rpc/handlers/AccountNFTs.cpp | 36 +- src/rpc/handlers/AccountObjects.cpp | 10 +- src/rpc/handlers/AccountObjects.hpp | 4 +- src/rpc/handlers/AccountOffers.cpp | 34 +- src/rpc/handlers/AccountOffers.hpp | 6 +- src/rpc/handlers/AccountTx.cpp | 6 +- src/rpc/handlers/BookChanges.cpp | 4 +- src/rpc/handlers/BookOffers.cpp | 10 +- src/rpc/handlers/BookOffers.hpp | 10 +- src/rpc/handlers/DepositAuthorized.cpp | 22 +- src/rpc/handlers/Feature.cpp | 6 +- src/rpc/handlers/GatewayBalances.cpp | 71 +- src/rpc/handlers/GatewayBalances.hpp | 27 +- src/rpc/handlers/GetAggregatePrice.cpp | 73 +- src/rpc/handlers/GetAggregatePrice.hpp | 10 +- src/rpc/handlers/Ledger.cpp | 24 +- src/rpc/handlers/LedgerData.cpp | 19 +- src/rpc/handlers/LedgerData.hpp | 4 +- src/rpc/handlers/LedgerEntry.cpp | 215 +- src/rpc/handlers/LedgerEntry.hpp | 22 +- src/rpc/handlers/LedgerIndex.cpp | 4 +- src/rpc/handlers/MPTHolders.cpp | 37 +- src/rpc/handlers/NFTBuyOffers.cpp | 2 +- src/rpc/handlers/NFTHistory.cpp | 8 +- src/rpc/handlers/NFTInfo.cpp | 4 +- src/rpc/handlers/NFTOffersCommon.cpp | 22 +- src/rpc/handlers/NFTOffersCommon.hpp | 6 +- src/rpc/handlers/NFTSellOffers.cpp | 2 +- src/rpc/handlers/NFTsByIssuer.cpp | 4 +- src/rpc/handlers/NoRippleCheck.cpp | 46 +- src/rpc/handlers/Random.cpp | 6 +- src/rpc/handlers/ServerInfo.hpp | 12 +- src/rpc/handlers/Subscribe.cpp | 4 +- src/rpc/handlers/Subscribe.hpp | 2 +- src/rpc/handlers/TransactionEntry.cpp | 6 +- src/rpc/handlers/TransactionEntry.hpp | 2 +- src/rpc/handlers/Tx.hpp | 12 +- src/rpc/handlers/Unsubscribe.cpp | 2 +- src/rpc/handlers/Unsubscribe.hpp | 2 +- src/rpc/handlers/VaultInfo.cpp | 24 +- src/util/AccountUtils.hpp | 6 +- src/util/LedgerUtils.cpp | 8 +- src/util/LedgerUtils.hpp | 98 +- src/util/Shasum.cpp | 18 +- src/util/Shasum.hpp | 10 +- src/util/TimeUtils.cpp | 6 +- src/util/TimeUtils.hpp | 2 +- src/util/TxUtils.cpp | 4 +- src/web/ProxyIpResolver.hpp | 4 +- tests/common/etl/FakeDiffProvider.hpp | 6 +- tests/common/util/BinaryTestObject.cpp | 32 +- tests/common/util/BinaryTestObject.hpp | 4 +- tests/common/util/MockBackend.hpp | 40 +- tests/common/util/MockLedgerCache.hpp | 8 +- tests/common/util/MockLedgerPublisher.hpp | 2 +- tests/common/util/MockSubscriptionManager.hpp | 23 +- tests/common/util/StringUtils.cpp | 8 +- tests/common/util/StringUtils.hpp | 4 +- tests/common/util/TestObject.cpp | 1740 ++++++++--------- tests/common/util/TestObject.hpp | 192 +- .../data/cassandra/BackendTests.cpp | 93 +- .../CassandraMigrationManagerTests.cpp | 14 +- .../CassandraMigrationTestBackend.hpp | 4 +- .../cassandra/ExampleObjectsMigrator.cpp | 6 +- .../cassandra/ExampleTransactionsMigrator.cpp | 6 +- tests/unit/data/AmendmentCenterTests.cpp | 34 +- tests/unit/data/BackendInterfaceTests.cpp | 10 +- tests/unit/data/LedgerCacheTests.cpp | 4 +- tests/unit/data/impl/LedgerCacheFileTests.cpp | 28 +- tests/unit/etl/CorruptionDetectorTests.cpp | 2 +- .../etl/CursorFromAccountProviderTests.cpp | 20 +- .../unit/etl/CursorFromDiffProviderTests.cpp | 44 +- tests/unit/etl/ETLServiceTests.cpp | 4 +- tests/unit/etl/ExtractionTests.cpp | 32 +- tests/unit/etl/GrpcSourceTests.cpp | 12 +- tests/unit/etl/LedgerPublisherTests.cpp | 14 +- tests/unit/etl/NFTHelpersTests.cpp | 185 +- tests/unit/etl/RegistryTests.cpp | 92 +- tests/unit/etl/TaskManagerTests.cpp | 2 +- tests/unit/etl/ext/CoreTests.cpp | 6 +- tests/unit/etl/ext/MPTTests.cpp | 14 +- tests/unit/etl/ext/NFTTests.cpp | 8 +- tests/unit/etl/ext/SuccessorTests.cpp | 38 +- tests/unit/feed/BookChangesFeedTests.cpp | 5 +- tests/unit/feed/LedgerFeedTests.cpp | 4 +- tests/unit/feed/SubscriptionManagerTests.cpp | 11 +- tests/unit/feed/TransactionFeedTests.cpp | 180 +- tests/unit/rpc/AmendmentsTests.cpp | 2 +- tests/unit/rpc/BaseTests.cpp | 14 +- tests/unit/rpc/RPCHelpersTests.cpp | 229 +-- tests/unit/rpc/handlers/AMMInfoTests.cpp | 171 +- .../rpc/handlers/AccountChannelsTests.cpp | 120 +- .../rpc/handlers/AccountCurrenciesTests.cpp | 28 +- tests/unit/rpc/handlers/AccountInfoTests.cpp | 54 +- tests/unit/rpc/handlers/AccountLinesTests.cpp | 126 +- .../handlers/AccountMPTokenIssuancesTests.cpp | 169 +- .../rpc/handlers/AccountMPTokensTests.cpp | 109 +- tests/unit/rpc/handlers/AccountNFTsTests.cpp | 38 +- .../unit/rpc/handlers/AccountObjectsTests.cpp | 308 ++- .../unit/rpc/handlers/AccountOffersTests.cpp | 82 +- tests/unit/rpc/handlers/AccountTxTests.cpp | 12 +- tests/unit/rpc/handlers/AllHandlerTests.cpp | 8 +- tests/unit/rpc/handlers/BookChangesTests.cpp | 15 +- tests/unit/rpc/handlers/BookOffersTests.cpp | 342 ++-- .../rpc/handlers/CredentialHelpersTests.cpp | 37 +- .../rpc/handlers/DepositAuthorizedTests.cpp | 128 +- tests/unit/rpc/handlers/FeatureTests.cpp | 6 +- .../rpc/handlers/GatewayBalancesTests.cpp | 74 +- .../rpc/handlers/GetAggregatePriceTests.cpp | 54 +- tests/unit/rpc/handlers/LedgerDataTests.cpp | 44 +- tests/unit/rpc/handlers/LedgerEntryTests.cpp | 306 ++- tests/unit/rpc/handlers/LedgerTests.cpp | 40 +- tests/unit/rpc/handlers/MPTHoldersTests.cpp | 60 +- tests/unit/rpc/handlers/NFTBuyOffersTests.cpp | 58 +- tests/unit/rpc/handlers/NFTHistoryTests.cpp | 12 +- tests/unit/rpc/handlers/NFTInfoTests.cpp | 26 +- .../unit/rpc/handlers/NFTSellOffersTests.cpp | 58 +- tests/unit/rpc/handlers/NFTsByIssuerTest.cpp | 28 +- .../unit/rpc/handlers/NoRippleCheckTests.cpp | 118 +- tests/unit/rpc/handlers/SubscribeTests.cpp | 94 +- .../rpc/handlers/TransactionEntryTests.cpp | 14 +- tests/unit/rpc/handlers/TxTests.cpp | 32 +- tests/unit/rpc/handlers/UnsubscribeTests.cpp | 2 +- tests/unit/rpc/handlers/VaultInfoTests.cpp | 28 +- tests/unit/util/AccountUtilsTests.cpp | 12 +- tests/unit/util/LedgerUtilsTests.cpp | 166 +- tests/unit/util/ShasumTests.cpp | 8 +- tests/unit/util/TimeUtilsTests.cpp | 4 +- tests/unit/util/TxUtilTests.cpp | 6 +- tests/unit/web/AdminVerificationTests.cpp | 2 +- tests/unit/web/ServerTests.cpp | 2 +- 221 files changed, 4759 insertions(+), 4945 deletions(-) diff --git a/cmake/deps/OpenSSL.cmake b/cmake/deps/OpenSSL.cmake index c1831611f..b60ef32f5 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 REQUIRED CONFIG) set_target_properties( OpenSSL::SSL diff --git a/conan.lock b/conan.lock index 4c2c81221..153e43b10 100644 --- a/conan.lock +++ b/conan.lock @@ -1,17 +1,19 @@ { "version": "0.5", "requires": [ - "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075", + "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809", "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987", - "xrpl/3.1.0#3d408ab8c8020014fa7dd52bc7cc7ea8%1769706825.165", - "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1765850149.926", + "xrpl/3.2.0-b0@peter/confidentialmpts#03aad709ac8e01a6c38068ccc86c2d8f%1775752957.332", + "sqlite3/3.51.0#66aa11eabd0e34954c5c1c061ad44abe%1774467355.988", "spdlog/1.17.0#bcbaaf7147bda6ad24ffbd1ac3d7142c%1768312128.781", - "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1765850149.46", - "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1765850148.103", + "soci/4.0.3#fe32b9ad5eb47e79ab9e45a68f363945%1774450067.231", + "secp256k1/0.7.1#481881709eb0bdd0185a12b912bbe8ad%1770910500.329", + "re2/20251105#8579cfd0bda4daf0683f9e3898f964b4%1774398111.888", "rapidjson/cci.20220822#1b9d8c2256876a154172dc5cfbe447c6%1754325007.656", - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88%1764175361.456", - "openssl/1.1.1w#a8f0792d7c5121b954578a7149d23e03%1756223730.729", - "nudb/2.0.9#0432758a24204da08fee953ec9ea03cb%1769436073.32", + "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12", + "openssl/3.6.1#e6399de266349245a4542fc5f6c71552%1774458290.139", + "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1775040983.408", + "mpt-crypto/0.2.0-rc1#ed3f241f69d8b9ebf80069d1923d93a8%1773853481.755", "minizip/1.2.13#9e87d57804bd372d6d1e32b1871517a3%1754325004.374", "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914", "libuv/1.46.0#dc28c1f653fa197f00db5b577a6f6011%1754325003.592", @@ -20,42 +22,56 @@ "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1765850144.736", "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.5#5581c2b62a608b40bb85d965ab3ec7c8%1765850144.336", + "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1774439234.681", "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837", - "boost/1.83.0#91d8b1572534d2c334d6790e3c34d0c1%1764175359.61", + "boost/1.90.0#d5e8defe7355494953be18524a7f135b%1769454080.269", "benchmark/1.9.4#ce4403f7a24d3e1f907cd9da4b678be4%1754578869.672", - "abseil/20230802.1#90ba607d4ee8fb5fb157c3db540671fc%1764175359.429" + "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196" ], "build_requires": [ - "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075", - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88%1764175361.456", - "cmake/4.2.0#ae0a44f44a1ef9ab68fd4b3e9a1f8671%1765850153.937", - "cmake/3.31.10#313d16a1aa16bbdb2ca0792467214b76%1765850153.479", - "b2/5.3.3#107c15377719889654eb9a162a673975%1765850144.355" + "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809", + "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12", + "cmake/4.3.0#b939a42e98f593fb34d3a8c5cc860359%1774439249.183", + "cmake/3.31.11#f325c933f618a1fcebc1e1c0babfd1ba%1774439246.719", + "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1774439233.447", + "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196" ], "python_requires": [], "overrides": { - "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88": [ + "protobuf/6.33.5": [ null, - "protobuf/3.21.12" + "protobuf/6.33.5" ], - "boost/1.83.0#91d8b1572534d2c334d6790e3c34d0c1": [ + "boost/1.90.0#d5e8defe7355494953be18524a7f135b": [ null, - "boost/1.83.0#91d8b1572534d2c334d6790e3c34d0c1" + "boost/1.90.0#d5e8defe7355494953be18524a7f135b" + ], + "openssl/3.6.1#e6399de266349245a4542fc5f6c71552": [ + null, + "openssl/3.6.1#e6399de266349245a4542fc5f6c71552" + ], + "openssl/[>=1.1 <4]": [ + "openssl/3.6.1" ], "lz4/1.9.4": [ "lz4/1.10.0" ], - "boost/1.90.0": [ - "boost/1.83.0" + "openssl/3.5.5": [ + "openssl/3.6.1#e6399de266349245a4542fc5f6c71552" + ], + "boost/[>=1.83.0 <1.91.0]": [ + "boost/1.90.0" + ], + "sqlite3/[>=3.44 <4]": [ + "sqlite3/3.51.0" ], - "sqlite3/3.44.2": [ - "sqlite3/3.49.1" + "boost/1.83.0": [ + "boost/1.90.0" ] }, "config_requires": [] diff --git a/conanfile.py b/conanfile.py index bbfce6e81..750cc210e 100644 --- a/conanfile.py +++ b/conanfile.py @@ -14,16 +14,16 @@ class ClioConan(ConanFile): requires = [ "cassandra-cpp-driver/2.17.0", "fmt/12.1.0", - "grpc/1.50.1", + "grpc/1.78.1", "libbacktrace/cci.20210118", - "openssl/1.1.1w", - "protobuf/3.21.12", + "protobuf/6.33.5", "spdlog/1.17.0", - "xrpl/3.1.0", + "xrpl/3.2.0-b0@peter/confidentialmpts", "zlib/1.3.1", ] default_options = { + "boost/*:without_coroutine": False, "cassandra-cpp-driver/*:shared": False, "date/*:header_only": True, "grpc/*:secure": True, @@ -42,9 +42,10 @@ class ClioConan(ConanFile): exports_sources = ("CMakeLists.txt", "cmake/*", "src/*") def requirements(self): - self.requires("boost/1.83.0", force=True) + self.requires("boost/1.90.0", force=True) self.requires("gtest/1.17.0") self.requires("benchmark/1.9.4") + self.requires("openssl/3.6.1", force=True) def configure(self): if self.settings.compiler == "apple-clang": diff --git a/docs/examples/config/example-config.json b/docs/examples/config/example-config.json index b25067452..3347996ae 100644 --- a/docs/examples/config/example-config.json +++ b/docs/examples/config/example-config.json @@ -7,7 +7,7 @@ "cassandra": { "contact_points": "127.0.0.1", "port": 9042, - "keyspace": "clio", + "keyspace": "clio_5", "replication_factor": 1, "table_prefix": "", "max_write_requests_outstanding": 25000, @@ -31,8 +31,8 @@ "etl_sources": [ { "ip": "127.0.0.1", - "ws_port": "6006", - "grpc_port": "50051" + "ws_port": "6007", + "grpc_port": "50052" } ], "forwarding": { diff --git a/src/data/AmendmentCenter.cpp b/src/data/AmendmentCenter.cpp index 2a3051c81..160321fd0 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 744c71c5f..fed3fbb8f 100644 --- a/src/data/AmendmentCenter.hpp +++ b/src/data/AmendmentCenter.hpp @@ -134,12 +134,17 @@ struct Amendments { REGISTER(fixIncludeKeyletFields); REGISTER(fixTokenEscrowV1); REGISTER(LendingProtocol); + REGISTER(ConfidentialTransfer); + REGISTER(PermissionDelegationV1_1); // Obsolete but supported by libxrpl REGISTER(CryptoConditionsSuite); REGISTER(NonFungibleTokensV1); REGISTER(fixNFTokenDirV1); REGISTER(fixNFTokenNegOffer); + REGISTER(fixExpiredNFTokenOfferRemoval); + REGISTER(fixPermissionedDomainInvariant); + REGISTER(fixSecurity3_1_3); // Retired amendments REGISTER(OwnerPaysFee); // Removed in xrpl 2.6.0 (https://github.com/XRPLF/rippled/pull/5435) @@ -262,7 +267,7 @@ class AmendmentCenter : public AmendmentCenterInterface { 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 f734012b0..06555b829 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"); offerDir->blob = *nextDir; @@ -217,8 +217,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({keys[i], objs[i]}); @@ -234,7 +234,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; } @@ -293,7 +293,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, @@ -302,11 +302,11 @@ BackendInterface::fetchLedgerPage( { LedgerPage page; - std::vector keys; + std::vector keys; bool reachedEnd = false; while (keys.size() < limit && !reachedEnd) { - ripple::uint256 const& curCursor = [&]() { + xrpl::uint256 const& curCursor = [&]() { if (!keys.empty()) return keys.back(); return (cursor ? *cursor : kFIRST_KEY); @@ -328,10 +328,10 @@ BackendInterface::fetchLedgerPage( page.objects.push_back({keys[i], std::move(objects[i])}); } else if (!outOfOrder) { LOG(log_.error()) << "Deleted or non-existent object in successor table. key = " - << ripple::strHex(keys[i]) << " - 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(); @@ -345,12 +345,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) { @@ -358,17 +358,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(); @@ -384,9 +384,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 fbb5d15f5..e77534b3b 100644 --- a/src/data/BackendInterface.hpp +++ b/src/data/BackendInterface.hpp @@ -178,9 +178,9 @@ class BackendInterface { * * @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 @@ class BackendInterface { * * @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 @@ class BackendInterface { * @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 @@ class BackendInterface { * @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 @@ class BackendInterface { * @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 @@ class BackendInterface { */ virtual std::vector fetchTransactions( - std::vector const& hashes, + std::vector const& hashes, boost::asio::yield_context yield ) const = 0; @@ -300,7 +300,7 @@ class BackendInterface { */ 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 @@ class BackendInterface { * * @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 @@ class BackendInterface { */ 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 @@ class BackendInterface { */ 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 @@ class BackendInterface { */ 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 @@ class BackendInterface { */ 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; @@ -421,7 +421,7 @@ class BackendInterface { */ std::optional fetchLedgerObject( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const; @@ -438,7 +438,7 @@ class BackendInterface { */ std::optional fetchLedgerObjectSeq( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const; @@ -457,7 +457,7 @@ class BackendInterface { */ std::vector fetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t sequence, boost::asio::yield_context yield ) const; @@ -472,7 +472,7 @@ class BackendInterface { */ virtual std::optional doFetchLedgerObject( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const = 0; @@ -487,7 +487,7 @@ class BackendInterface { */ virtual std::optional doFetchLedgerObjectSeq( - ripple::uint256 const& key, + xrpl::uint256 const& key, std::uint32_t sequence, boost::asio::yield_context yield ) const = 0; @@ -502,7 +502,7 @@ class BackendInterface { */ virtual std::vector doFetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t sequence, boost::asio::yield_context yield ) const = 0; @@ -529,7 +529,7 @@ class BackendInterface { */ LedgerPage fetchLedgerPage( - std::optional const& cursor, + std::optional const& cursor, std::uint32_t ledgerSequence, std::uint32_t limit, bool outOfOrder, @@ -546,7 +546,7 @@ class BackendInterface { */ std::optional fetchSuccessorObject( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield ) const; @@ -563,9 +563,9 @@ class BackendInterface { * @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; @@ -578,9 +578,9 @@ class BackendInterface { * @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; @@ -596,7 +596,7 @@ class BackendInterface { */ BookOffersPage fetchBookOffers( - ripple::uint256 const& book, + xrpl::uint256 const& book, std::uint32_t ledgerSequence, std::uint32_t limit, boost::asio::yield_context yield @@ -663,7 +663,7 @@ class BackendInterface { * @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 a5b0bfea7..f82a52b41 100644 --- a/src/data/CassandraBackend.hpp +++ b/src/data/CassandraBackend.hpp @@ -101,11 +101,11 @@ class BasicCassandraBackend : public CassandraBackendFamily< 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 @@ class BasicCassandraBackend : public CassandraBackendFamily< 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 @@ class BasicCassandraBackend : public CassandraBackendFamily< 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 @@ class BasicCassandraBackend : public CassandraBackendFamily< 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 @@ class BasicCassandraBackend : public CassandraBackendFamily< 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 @@ class BasicCassandraBackend : public CassandraBackendFamily< return ret; } - std::vector + std::vector fetchAccountRoots( std::uint32_t number, std::uint32_t pageSize, @@ -198,8 +197,8 @@ class BasicCassandraBackend : public CassandraBackendFamily< 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 @@ class BasicCassandraBackend : public CassandraBackendFamily< 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 ee5c71c5f..23395e1dc 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; }; /** @@ -232,25 +232,25 @@ isBookDir(T const& key, R const& object) if (!isDirNode(object)) return false; - ripple::STLedgerEntry const sle{ripple::SerialIter{object.data(), object.size()}, key}; - return !sle[~ripple::sfOwner].has_value(); + xrpl::STLedgerEntry const sle{xrpl::SerialIter{object.data(), object.size()}, key}; + return !sle[~xrpl::sfOwner].has_value(); } /** * @brief Get the book base. * * @param key The key to get the book base out of - * @return Book base as ripple::uint256 + * @return Book base as xrpl::uint256 */ template -inline ripple::uint256 +inline xrpl::uint256 getBookBase(T const& key) { static constexpr size_t kEY_SIZE = 24; - ASSERT(key.size() == ripple::uint256::size(), "Invalid key size {}", key.size()); + ASSERT(key.size() == xrpl::uint256::size(), "Invalid key size {}", key.size()); - ripple::uint256 ret; + xrpl::uint256 ret; for (size_t i = 0; i < kEY_SIZE; ++i) ret.data()[i] = key.data()[i]; @@ -258,15 +258,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 76681cbf9..5df3eb4dc 100644 --- a/src/data/KeyspaceBackend.hpp +++ b/src/data/KeyspaceBackend.hpp @@ -104,23 +104,23 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< 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 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< 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 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< 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 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< * @param pageSize The maximum number of accounts per page. * @param seq The accounts need to exist at this ledger sequence. * @param yield The coroutine context. - * @return A vector of ripple::uint256 representing the account root hashes. + * @return A vector of xrpl::uint256 representing the account root hashes. */ - std::vector + std::vector fetchAccountRoots( [[maybe_unused]] std::uint32_t number, [[maybe_unused]] std::uint32_t pageSize, @@ -175,42 +175,42 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< } private: - std::vector + std::vector fetchNFTIDsByTaxon( - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, std::uint32_t const taxon, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield ) const { - std::vector nftIDs; + std::vector nftIDs; Statement const statement = schema_->selectNFTIDsByIssuerTaxon.bind(issuer); statement.bindAt(1, taxon); - statement.bindAt(2, cursorIn.value_or(ripple::uint256(0))); + statement.bindAt(2, cursorIn.value_or(xrpl::uint256(0))); statement.bindAt(3, Limit{limit}); auto const res = executor_.read(yield, statement); if (res.has_value() && res->hasRows()) { - for (auto const [nftID] : extract(*res)) + for (auto const [nftID] : extract(*res)) nftIDs.push_back(nftID); } return nftIDs; } - std::vector + std::vector fetchNFTIDsWithoutTaxon( - ripple::AccountID const& issuer, + xrpl::AccountID const& issuer, std::uint32_t const limit, - std::optional const& cursorIn, + std::optional const& cursorIn, boost::asio::yield_context yield ) const { - std::vector nftIDs; + std::vector nftIDs; auto const startTaxon = - cursorIn.has_value() ? ripple::nft::toUInt32(ripple::nft::getTaxon(*cursorIn)) : 0; - auto const startTokenID = cursorIn.value_or(ripple::uint256(0)); + 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 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< 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 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< 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 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< */ 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 @@ class BasicKeyspaceBackend : public CassandraBackendFamily< // 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..38cd70cfa 100644 --- a/src/data/LedgerCache.hpp +++ b/src/data/LedgerCache.hpp @@ -35,7 +35,7 @@ class LedgerCache : public LedgerCacheInterface { Blob blob; }; - using CacheMap = std::map; + using CacheMap = std::map; private: // counters for fetchLedgerObject(s) hit rate @@ -95,7 +95,7 @@ class LedgerCache : public LedgerCacheInterface { // 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 @@ class LedgerCache : public LedgerCacheInterface { 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 45b542d30..9fdc482a7 100644 --- a/src/data/LedgerCacheInterface.hpp +++ b/src/data/LedgerCacheInterface.hpp @@ -56,7 +56,7 @@ class LedgerCacheInterface { * @return If found in cache, will return the cached Blob; otherwise nullopt is returned */ virtual std::optional - get(ripple::uint256 const& key, uint32_t seq) const = 0; + get(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Fetch a recently deleted object by its key and sequence number. @@ -66,7 +66,7 @@ class LedgerCacheInterface { * @return If found in deleted cache, will return the cached Blob; otherwise nullopt is returned */ virtual std::optional - getDeleted(ripple::uint256 const& key, uint32_t seq) const = 0; + getDeleted(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Gets a cached successor. @@ -78,7 +78,7 @@ class LedgerCacheInterface { * @return If found in cache, will return the cached successor; otherwise nullopt is returned */ virtual std::optional - getSuccessor(ripple::uint256 const& key, uint32_t seq) const = 0; + getSuccessor(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Gets a cached predcessor. @@ -90,7 +90,7 @@ class LedgerCacheInterface { * @return If found in cache, will return the cached predcessor; otherwise nullopt is returned */ virtual std::optional - getPredecessor(ripple::uint256 const& key, uint32_t seq) const = 0; + getPredecessor(xrpl::uint256 const& key, uint32_t seq) const = 0; /** * @brief Disables the cache. diff --git a/src/data/LedgerHeaderCache.hpp b/src/data/LedgerHeaderCache.hpp index 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 @@ class FetchLedgerCache { * @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 fa3ad7b7f..a240e3c6b 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 kFIRST_KEY{ +constexpr xrpl::uint256 kFIRST_KEY{ "0000000000000000000000000000000000000000000000000000000000000000" }; -constexpr ripple::uint256 kLAST_KEY{ +constexpr xrpl::uint256 kLAST_KEY{ "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 1583548d2..353088e46 100644 --- a/src/data/cassandra/CassandraBackendFamily.hpp +++ b/src/data/cassandra/CassandraBackendFamily.hpp @@ -134,7 +134,7 @@ class CassandraBackendFamily : public BackendInterface { TransactionsAndCursor fetchAccountTransactions( - ripple::AccountID const& account, + xrpl::AccountID const& account, std::uint32_t const limit, bool forward, std::optional const& txnCursor, @@ -155,14 +155,14 @@ class CassandraBackendFamily : public BackendInterface { auto cursor = txnCursor; if (cursor) { statement.bindAt(1, 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; auto const placeHolder = forward ? 0u : std::numeric_limits::max(); statement.bindAt(1, std::make_tuple(placeHolder, placeHolder)); - LOG(log_.debug()) << "account = " << ripple::strHex(account) << " idx = " << seq + LOG(log_.debug()) << "account = " << xrpl::strHex(account) << " idx = " << seq << " tuple = " << placeHolder; } @@ -177,12 +177,11 @@ class CassandraBackendFamily : public BackendInterface { 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"; @@ -208,7 +207,7 @@ class CassandraBackendFamily : public BackendInterface { } 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)); @@ -237,7 +236,7 @@ class CassandraBackendFamily : public BackendInterface { return std::nullopt; } - std::optional + std::optional fetchLedgerBySequence( std::uint32_t const sequence, boost::asio::yield_context yield @@ -251,7 +250,7 @@ class CassandraBackendFamily : public BackendInterface { 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; } @@ -268,8 +267,8 @@ class CassandraBackendFamily : public BackendInterface { 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) { @@ -336,7 +335,7 @@ class CassandraBackendFamily : public BackendInterface { return fetchTransactions(hashes, yield); } - std::vector + std::vector fetchAllTransactionHashesInLedger( std::uint32_t const ledgerSequence, boost::asio::yield_context yield @@ -358,8 +357,8 @@ class CassandraBackendFamily : public BackendInterface { 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(); @@ -375,7 +374,7 @@ class CassandraBackendFamily : public BackendInterface { std::optional fetchNFT( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const override @@ -384,8 +383,7 @@ class CassandraBackendFamily : public BackendInterface { 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); @@ -402,7 +400,7 @@ class CassandraBackendFamily : public BackendInterface { // 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; } @@ -415,7 +413,7 @@ class CassandraBackendFamily : public BackendInterface { TransactionsAndCursor fetchNFTTransactions( - ripple::uint256 const& tokenID, + xrpl::uint256 const& tokenID, std::uint32_t const limit, bool const forward, std::optional const& cursorIn, @@ -436,14 +434,14 @@ class CassandraBackendFamily : public BackendInterface { auto cursor = cursorIn; if (cursor) { statement.bindAt(1, 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; auto const placeHolder = forward ? 0 : std::numeric_limits::max(); statement.bindAt(1, std::make_tuple(placeHolder, placeHolder)); - LOG(log_.debug()) << "token_id = " << ripple::strHex(tokenID) << " idx = " << seq + LOG(log_.debug()) << "token_id = " << xrpl::strHex(tokenID) << " idx = " << seq << " tuple = " << placeHolder; } @@ -456,12 +454,11 @@ class CassandraBackendFamily : public BackendInterface { return {}; } - std::vector hashes = {}; + std::vector hashes = {}; auto numRows = results.numRows(); LOG(log_.info()) << "num_rows = " << numRows; - for (auto [hash, data] : - extract>(results)) { + for (auto [hash, data] : extract>(results)) { hashes.push_back(hash); if (--numRows == 0) { LOG(log_.debug()) << "Setting cursor"; @@ -487,9 +484,9 @@ class CassandraBackendFamily : public BackendInterface { 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 @@ -498,7 +495,7 @@ class CassandraBackendFamily : public BackendInterface { yield, schema_->selectMPTHolders, mptID, - cursorIn.value_or(ripple::AccountID(0)), + cursorIn.value_or(xrpl::AccountID(0)), Limit{limit} ); @@ -508,10 +505,10 @@ class CassandraBackendFamily : public BackendInterface { 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; } @@ -532,13 +529,13 @@ class CassandraBackendFamily : public BackendInterface { 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()) @@ -555,13 +552,13 @@ class CassandraBackendFamily : public BackendInterface { 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.value(); @@ -576,7 +573,7 @@ class CassandraBackendFamily : public BackendInterface { } 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(); @@ -593,16 +590,16 @@ class CassandraBackendFamily : public BackendInterface { return std::nullopt; } - std::optional + std::optional doFetchSuccessorKey( - ripple::uint256 key, + xrpl::uint256 key, std::uint32_t const ledgerSequence, boost::asio::yield_context yield ) const override { if (auto const res = executor_.read(yield, schema_->selectSuccessor, key, ledgerSequence); res) { - if (auto const result = res->template get(); result) { + if (auto const result = res->template get(); result) { if (*result == kLAST_KEY) return std::nullopt; return result; @@ -618,7 +615,7 @@ class CassandraBackendFamily : public BackendInterface { std::vector fetchTransactions( - std::vector const& hashes, + std::vector const& hashes, boost::asio::yield_context yield ) const override { @@ -664,7 +661,7 @@ class CassandraBackendFamily : public BackendInterface { std::vector doFetchLedgerObjects( - std::vector const& keys, + std::vector const& keys, std::uint32_t const sequence, boost::asio::yield_context yield ) const override @@ -713,7 +710,7 @@ class CassandraBackendFamily : public BackendInterface { ) 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() @@ -728,8 +725,8 @@ class CassandraBackendFamily : public BackendInterface { return {}; } - std::vector resultKeys; - for (auto [key] : extract(results)) + std::vector resultKeys; + for (auto [key] : extract(results)) resultKeys.push_back(key); return resultKeys; @@ -918,8 +915,8 @@ class CassandraBackendFamily : public BackendInterface { // 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( diff --git a/src/data/cassandra/impl/Collection.hpp b/src/data/cassandra/impl/Collection.hpp index 8ee404dbb..db4e84208 100644 --- a/src/data/cassandra/impl/Collection.hpp +++ b/src/data/cassandra/impl/Collection.hpp @@ -58,14 +58,14 @@ class Collection : public ManagedObject { } 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 5c177d6ab..47c3262ee 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 481614354..92625d7e0 100644 --- a/src/data/cassandra/impl/Statement.hpp +++ b/src/data/cassandra/impl/Statement.hpp @@ -93,18 +93,17 @@ class Statement : public ManagedObject { 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 @@ class Statement : public ManagedObject { 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 98928d21e..be386bdf9 100644 --- a/src/data/cassandra/impl/Tuple.hpp +++ b/src/data/cassandra/impl/Tuple.hpp @@ -62,14 +62,14 @@ class Tuple : public ManagedObject { 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 @@ class InputFile { 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 3abfe045a..378b4a128 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::base_uint<256>::bytes)) { return std::unexpected(fmt::format("Failed to read key at index {}", i)); } @@ -185,7 +185,7 @@ 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 )) { 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 @@ class OutputFile { 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 @@ class ThreadSafeQueue { * @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 be7bfc93a..86a39ff22 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 b56daf457..3d90ae3d3 100644 --- a/src/etl/MPTHelpers.cpp +++ b/src/etl/MPTHelpers.cpp @@ -1,17 +1,17 @@ #include "data/DBHelpers.hpp" #include "util/Assert.hpp" -#include -#include -#include #include #include #include +#include #include #include +#include #include #include #include +#include #include #include @@ -25,17 +25,17 @@ namespace etl { * @return MPT and holder account pair */ std::optional -getMPTokenAuthorize(ripple::TxMeta const& txMeta) +getMPTokenAuthorize(xrpl::TxMeta const& txMeta) { - for (ripple::STObject const& node : txMeta.getNodes()) { - if (node.getFieldU16(ripple::sfLedgerEntryType) != ripple::ltMPTOKEN) + for (xrpl::STObject const& node : txMeta.getNodes()) { + if (node.getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltMPTOKEN) continue; - if (node.getFName() == ripple::sfCreatedNode) { - auto const& newMPT = node.peekAtField(ripple::sfNewFields).downcast(); + if (node.getFName() == xrpl::sfCreatedNode) { + auto const& newMPT = node.peekAtField(xrpl::sfNewFields).downcast(); return MPTHolderData{ - .mptID = newMPT[ripple::sfMPTokenIssuanceID], - .holder = newMPT.getAccountID(ripple::sfAccount) + .mptID = newMPT[xrpl::sfMPTokenIssuanceID], + .holder = newMPT.getAccountID(xrpl::sfAccount) }; } } @@ -43,10 +43,10 @@ getMPTokenAuthorize(ripple::TxMeta const& txMeta) } std::optional -getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx) +getMPTHolderFromTx(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx) { - if (txMeta.getResultTER() != ripple::tesSUCCESS || - sttx.getTxnType() != ripple::TxType::ttMPTOKEN_AUTHORIZE) + if (txMeta.getResultTER() != xrpl::tesSUCCESS || + sttx.getTxnType() != xrpl::TxType::ttMPTOKEN_AUTHORIZE) return {}; return getMPTokenAuthorize(txMeta); @@ -57,19 +57,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 dc9e30a0a..1873b16e3 100644 --- a/src/etl/MPTHelpers.hpp +++ b/src/etl/MPTHelpers.hpp @@ -3,8 +3,8 @@ #include "data/DBHelpers.hpp" -#include -#include +#include +#include namespace etl { @@ -16,7 +16,7 @@ namespace etl { * @return The MPTIssuanceID and holder pair as a optional */ std::optional -getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx); +getMPTHolderFromTx(xrpl::TxMeta const& txMeta, xrpl::STTx const& sttx); /** * @brief Pull MPT data from ledger object via loadInitialLedger. diff --git a/src/etl/Models.hpp b/src/etl/Models.hpp index 401181ecf..4c433ce6b 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 kSPEC_TAG = 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; - - 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); + std::optional prevNFTs; + + 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 @@ class AsyncGrpcCall { 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 dadb234ef..65801260a 100644 --- a/src/etl/impl/CacheLoader.hpp +++ b/src/etl/impl/CacheLoader.hpp @@ -105,7 +105,7 @@ class CacheLoaderImpl { } auto [start, end] = cursor.value(); - LOG(log_.debug()) << "Starting a cursor: " << ripple::strHex(start); + LOG(log_.debug()) << "Starting a cursor: " << xrpl::strHex(start); while (not token.isStopRequested() and not cache_.get().isDisabled()) { auto res = diff --git a/src/etl/impl/CursorFromAccountProvider.hpp b/src/etl/impl/CursorFromAccountProvider.hpp index 19eed1475..4d56e6b53 100644 --- a/src/etl/impl/CursorFromAccountProvider.hpp +++ b/src/etl/impl/CursorFromAccountProvider.hpp @@ -43,7 +43,7 @@ class CursorFromAccountProvider : public BaseCursorProvider { }(); rg::sort(accountRoots); - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFIRST_KEY}; rg::copy(accountRoots.begin(), accountRoots.end(), std::back_inserter(cursors)); rg::sort(cursors); cursors.push_back(data::kLAST_KEY); diff --git a/src/etl/impl/CursorFromDiffProvider.hpp b/src/etl/impl/CursorFromDiffProvider.hpp index 5de0e098a..ca830b391 100644 --- a/src/etl/impl/CursorFromDiffProvider.hpp +++ b/src/etl/impl/CursorFromDiffProvider.hpp @@ -43,8 +43,8 @@ class CursorFromDiffProvider : public BaseCursorProvider { auto const range = backend_->fetchLedgerRange(); ASSERT(range.has_value(), "Ledger range is not available when cache is loading"); - std::set liveCursors; - std::set deletedCursors; + std::set liveCursors; + std::set deletedCursors; auto i = 0; while (liveCursors.size() < numCursors_ and seq - i >= range->minSequence) { auto diffs = fetchDiff(i++); @@ -66,7 +66,7 @@ class CursorFromDiffProvider : public BaseCursorProvider { ); } - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFIRST_KEY}; rg::copy( liveCursors | vs::take(std::min(liveCursors.size(), numCursors_)), std::back_inserter(cursors) diff --git a/src/etl/impl/CursorFromFixDiffNumProvider.hpp b/src/etl/impl/CursorFromFixDiffNumProvider.hpp index f3cdcac1c..cfc81625d 100644 --- a/src/etl/impl/CursorFromFixDiffNumProvider.hpp +++ b/src/etl/impl/CursorFromFixDiffNumProvider.hpp @@ -57,7 +57,7 @@ class CursorFromFixDiffNumProvider : public BaseCursorProvider { rg::unique(diffs, [](auto const& a, auto const& b) { return a.key == b.key; }); diffs.erase(removalCursor, last); - std::vector cursors{data::kFIRST_KEY}; + std::vector cursors{data::kFIRST_KEY}; rg::copy( diffs // | vs::filter([](auto const& obj) { return not obj.blob.empty(); }) // diff --git a/src/etl/impl/Extraction.cpp b/src/etl/impl/Extraction.cpp index 929d51059..f96d07816 100644 --- a/src/etl/impl/Extraction.cpp +++ b/src/etl/impl/Extraction.cpp @@ -57,9 +57,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), @@ -92,7 +93,7 @@ extractTxs(PBTxListType transactions, uint32_t seq) model::Object extractObj(PBObjType obj) { - auto const key = ripple::uint256::fromVoidChecked(obj.key()); + auto const key = xrpl::uint256::fromVoidChecked(obj.key()); ASSERT(key.has_value(), "Failed to deserialize key from void"); auto const valueOr = [](std::string const& maybe, std::string fallback) -> std::string { @@ -162,7 +163,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 a750358ae..714b31cff 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( @@ -155,7 +155,7 @@ class LedgerPublisher : public LedgerPublisherInterface { * @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); @@ -167,7 +167,7 @@ class LedgerPublisher : public LedgerPublisherInterface { // and don't publish static constexpr std::uint32_t kMAX_LEDGER_AGE_SECONDS = 600; if (age < kMAX_LEDGER_AGE_SECONDS) { - std::optional fees = + std::optional fees = data::synchronousAndRetryOnTimeout([&](auto yield) { return backend_->fetchFees(lgrInfo.seq, yield); }); @@ -186,12 +186,12 @@ class LedgerPublisher : public LedgerPublisherInterface { // 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) @@ -273,7 +273,7 @@ class LedgerPublisher : public LedgerPublisherInterface { 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 74738b127..3a8ab444c 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 @@ class Loader : public LoaderInterface, public InitialLoadObserverInterface { 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 343afca9f..dff833944 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 880bf1838..e5c9675e6 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); } 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::kFIRST_KEY; + xrpl::uint256 prev = data::kFIRST_KEY; while (auto cur = cache_.get().getSuccessor(prev, seq)) { if (prev == data::kFIRST_KEY) backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(cur->key)); @@ -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) backend_->writeSuccessor(uint256ToString(base), seq, uint256ToString(cur->key)); @@ -206,7 +204,7 @@ void SuccessorExt::writeEdgeKeys(std::uint32_t seq, auto const& edgeKeys) const { for (auto const& key : edgeKeys) { - auto succ = cache_.get().getSuccessor(*ripple::uint256::fromVoidChecked(key), seq); + auto succ = cache_.get().getSuccessor(*xrpl::uint256::fromVoidChecked(key), seq); if (succ) backend_->writeSuccessor(auto{key}, seq, uint256ToString(succ->key)); } diff --git a/src/etl/impl/ext/Successor.hpp b/src/etl/impl/ext/Successor.hpp index 7cc317af9..dbac88587 100644 --- a/src/etl/impl/ext/Successor.hpp +++ b/src/etl/impl/ext/Successor.hpp @@ -54,7 +54,7 @@ class SuccessorExt { 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 @@ class SubscriptionManager : public SubscriptionManagerInterface { */ void pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) final; @@ -168,10 +168,7 @@ class SubscriptionManager : public SubscriptionManagerInterface { * @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 @@ class SubscriptionManager : public SubscriptionManagerInterface { */ void unsubProposedAccount( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) final; @@ -216,8 +213,8 @@ class SubscriptionManager : public SubscriptionManagerInterface { */ 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 @@ class SubscriptionManager : public SubscriptionManagerInterface { * @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 @@ class SubscriptionManager : public SubscriptionManagerInterface { * @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 @@ class SubscriptionManager : public SubscriptionManagerInterface { * @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 @@ class SubscriptionManager : public SubscriptionManagerInterface { * @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 @@ class SubscriptionManager : public SubscriptionManagerInterface { 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 85d8e0de4..92aa61519 100644 --- a/src/feed/SubscriptionManagerInterface.hpp +++ b/src/feed/SubscriptionManagerInterface.hpp @@ -53,7 +53,7 @@ class SubscriptionManagerInterface { */ virtual void pubBookChanges( - ripple::LedgerHeader const& lgrInfo, + xrpl::LedgerHeader const& lgrInfo, std::vector const& transactions ) = 0; @@ -78,7 +78,7 @@ class SubscriptionManagerInterface { * @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 @@ class SubscriptionManagerInterface { * @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 @@ class SubscriptionManagerInterface { */ 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 @@ class SubscriptionManagerInterface { * @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 @@ class SubscriptionManagerInterface { * @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 @@ class SubscriptionManagerInterface { * @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 @@ class SubscriptionManagerInterface { * @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 @@ class SubscriptionManagerInterface { 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 810c4c853..a0ca678ef 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 @@ -75,8 +75,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 @@ class LedgerFeed : public SingleFeedBase { * @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 @@ class LedgerFeed : public SingleFeedBase { 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 @@ class ProposedTransactionFeed { * @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 @@ class ProposedTransactionFeed { * @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 @@ class ProposedTransactionFeed { 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 5b48f15a9..7593e5ab0 100644 --- a/src/feed/impl/TransactionFeed.cpp +++ b/src/feed/impl/TransactionFeed.cpp @@ -68,7 +68,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 +95,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 +108,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 +128,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 +141,7 @@ TransactionFeed::unsubProposed(SubscriberSharedPtr const& subscriber) void TransactionFeed::unsubProposed( - ripple::AccountID const& account, + xrpl::AccountID const& account, SubscriberSharedPtr const& subscriber ) { @@ -152,7 +149,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 +175,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,11 +183,11 @@ 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 (tx->getTxnType() == xrpl::ttOFFER_CREATE) { + auto const account = tx->getAccountID(xrpl::sfAccount); + auto const amount = tx->getFieldAmount(xrpl::sfTakerGets); if (account != amount.issue().account) { auto fetchFundsSynchronous = [&]() { data::synchronous([&](boost::asio::yield_context yield) { @@ -216,7 +213,7 @@ TransactionFeed::pub( rpc::insertMPTIssuanceID(txnPubobj, tx, metaPubobj, meta); Json::Value nftJson; - ripple::RPC::insertNFTSyntheticInJson(nftJson, tx, *meta); + 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 +237,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::to_string_iso(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 +252,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 +267,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).issue(), + data->getFieldAmount(xrpl::sfTakerPays).issue(), + (*data)[~xrpl::sfDomainID] }; if (!affectedBooks.contains(book)) { affectedBooks.insert(book); @@ -345,7 +342,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 +357,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 @@ class TransactionFeed { * @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 @@ class TransactionFeed { * @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 @@ class TransactionFeed { * @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 @@ class TransactionFeed { * @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 @@ class TransactionFeed { * @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 @@ class TransactionFeed { * @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 @@ class TransactionFeed { */ 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 @@ class TransactionFeed { 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 c8db88e66..ff9b92e26 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* kPARTITION_KEY = "key"; static constexpr char const* kTABLE_NAME = "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 928e25862..e88fbb07c 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* kPARTITION_KEY = "hash"; static constexpr char const* kTABLE_NAME = "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..8d9f9032b 100644 --- a/src/rpc/AMMHelpers.cpp +++ b/src/rpc/AMMHelpers.cpp @@ -17,14 +17,14 @@ namespace rpc { -std::pair +std::pair getAmmPoolHolds( BackendInterface const& backend, data::AmendmentCenterInterface const& amendmentCenter, std::uint32_t sequence, - ripple::AccountID const& ammAccountID, - ripple::Issue const& issue1, - ripple::Issue const& issue2, + xrpl::AccountID const& ammAccountID, + xrpl::Issue const& issue1, + xrpl::Issue const& issue2, bool freezeHandling, boost::asio::yield_context yield ) @@ -52,14 +52,14 @@ 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::Currency const& cur1, + xrpl::Currency const& cur2, + xrpl::AccountID const& ammAccount, + xrpl::AccountID const& lpAccount, boost::asio::yield_context yield ) { @@ -70,21 +70,21 @@ getAmmLpHolds( 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().currency, + ammSle[xrpl::sfAsset2].get().currency, + ammSle[xrpl::sfAccount], lpAccount, yield ); diff --git a/src/rpc/AMMHelpers.hpp b/src/rpc/AMMHelpers.hpp index 11857200c..644a6ff08 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 ); @@ -52,14 +52,14 @@ getAmmPoolHolds( * @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::Currency const& cur1, + xrpl::Currency const& cur2, + 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..fb7d100cd 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,55 +90,55 @@ class BookChanges final { 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()); @@ -157,7 +157,7 @@ class BookChanges final { if (second == beast::zero) return; - auto const rate = divide(first, second, ripple::noIssue()); + auto const rate = divide(first, second, xrpl::noIssue()); if (first < beast::zero) first = -first; @@ -197,24 +197,24 @@ class BookChanges final { 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,11 +232,11 @@ class BookChanges final { 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 { + auto currencyStr = [](xrpl::STAmount const& amount) -> std::string { return isXRP(amount) ? "XRP_drops" : to_string(amount.issue()); }; @@ -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 a112bfe4d..97f95a028 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,32 +77,32 @@ 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); - credential.setAccountID(ripple::sfIssuer, *issuer); - credential.setFieldVL(ripple::sfCredentialType, *credentialType); + auto credential = xrpl::STObject::makeInnerObject(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, *issuer); + credential.setFieldVL(xrpl::sfCredentialType, *credentialType); arr.push_back(std::move(credential)); } return arr; } -std::expected +std::expected fetchCredentialArray( std::optional const& credID, - ripple::AccountID const& srcAcc, + xrpl::AccountID const& srcAcc, BackendInterface const& backend, - ripple::LedgerHeader const& info, + xrpl::LedgerHeader const& info, boost::asio::yield_context const& yield ) { - ripple::STArray authCreds; + xrpl::STArray authCreds; std::unordered_set elems; for (auto const& elem : credID.value()) { ASSERT( @@ -113,38 +113,36 @@ fetchCredentialArray( return Error{Status{RippledError::rpcBAD_CREDENTIALS, "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."}}; - 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)) + if ((sleCred.getType() != xrpl::ltCREDENTIAL) || + ((sleCred.getFieldU32(xrpl::sfFlags) & xrpl::lsfAccepted) == 0u)) return Error{Status{RippledError::rpcBAD_CREDENTIALS, "credentials aren't accepted"}}; if (credentials::checkExpired(sleCred, info)) return Error{Status{RippledError::rpcBAD_CREDENTIALS, "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" }}; } - 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 bf4d888c4..ec8575730 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::get_error_info(err).message; } }, [&stream, &status](ClioError err) { @@ -164,7 +164,7 @@ makeError( ) { boost::json::object json; - auto const& info = ripple::RPC::get_error_info(err); + auto const& info = xrpl::RPC::get_error_info(err); json["error"] = customError.value_or(info.token.c_str()).data(); json["error_code"] = static_cast(err); @@ -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 7acfe4116..993dc7076 100644 --- a/src/rpc/Errors.hpp +++ b/src/rpc/Errors.hpp @@ -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::error_code_i; /** * @brief Clio operates on a combination of Rippled and Custom Clio error codes. @@ -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)) { } diff --git a/src/rpc/JS.hpp b/src/rpc/JS.hpp index ceb733d18..277c7604d 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.c_str() /** @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.c_str() diff --git a/src/rpc/RPCHelpers.cpp b/src/rpc/RPCHelpers.cpp index 0e48d800f..1ba92bba8 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::zero; 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 amount = meta->getDeliveredAmount()) + return amount; + 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. @@ -139,7 +139,7 @@ getDeliveredAmount( static constexpr std::uint32_t kDELIVERED_AMOUNT_LIVE_DATE = 446000000; if (ledgerSequence >= kFIRST_LEDGER_WITH_DELIVERED_AMOUNT || date > kDELIVERED_AMOUNT_LIVE_DATE) { - return txn->getFieldAmount(ripple::sfAmount); + return txn->getFieldAmount(xrpl::sfAmount); } } return {}; @@ -147,55 +147,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) { @@ -211,22 +210,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::none).toStyledString()); return value.as_object(); } @@ -248,7 +247,7 @@ toExpandedJson( if (nftEnabled == NFTokenjson::ENABLE) { Json::Value nftJson; - ripple::RPC::insertNFTSyntheticInJson(nftJson, txn, *meta); + 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()) { @@ -287,15 +286,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::include_date)); } else { metaJson["delivered_amount"] = "unavailable"; } @@ -310,18 +309,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 {}; @@ -336,22 +335,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)) @@ -364,9 +363,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; @@ -384,10 +383,10 @@ 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::none).toStyledString()); return value.as_object(); } @@ -401,13 +400,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::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"] = @@ -418,23 +417,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::to_string_iso(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); @@ -459,7 +458,7 @@ parseStringAsUInt(std::string const& value) return index; } -std::expected +std::expected ledgerHeaderFromRequest( std::shared_ptr const& backend, web::Context const& ctx @@ -471,7 +470,7 @@ ledgerHeaderFromRequest( if (!hashValue.is_string()) return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "ledgerHashNotString"}}; - ripple::uint256 ledgerHash; + xrpl::uint256 ledgerHash; if (!ledgerHash.parseHex(boost::json::value_to(hashValue))) return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "ledgerHashMalformed"}}; @@ -513,7 +512,7 @@ ledgerHeaderFromRequest( } // extract ledgerHeaderFromRequest's parameter from context -std::expected +std::expected getLedgerHeaderFromHashOrSeq( BackendInterface const& backend, boost::asio::yield_context yield, @@ -522,12 +521,12 @@ getLedgerHeaderFromHashOrSeq( uint32_t maxSeq ) { - std::optional lgrInfo; + std::optional lgrInfo; auto const err = std::unexpected{Status{RippledError::rpcLGR_NOT_FOUND, "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; @@ -547,9 +546,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); @@ -565,20 +564,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 @@ -588,22 +587,22 @@ 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::nftpage_min(accountID); + auto const lastNFTPage = xrpl::keylet::nftpage_max(accountID); // check if nextPage is valid - if (nextPage != beast::zero and firstNFTPage.key != (nextPage & ~ripple::nft::pageMask)) + if (nextPage != beast::zero and firstNFTPage.key != (nextPage & ~xrpl::nft::pageMask)) return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "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::zero ? lastNFTPage.key : nextPage; // read the current page auto page = backend.fetchLedgerObject(currentPage, sequence, yield); @@ -617,12 +616,12 @@ traverseNFTObjects( } // 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++; @@ -630,7 +629,7 @@ traverseNFTObjects( return AccountCursor{.index = nftPreviousPage, .hint = count}; page = backend.fetchLedgerObject(nftPreviousPage, sequence, yield); - pageSLE = ripple::SLE{ripple::SerialIter{page->data(), page->size()}, nftPreviousPage}; + pageSLE = xrpl::SLE{xrpl::SerialIter{page->data(), page->size()}, nftPreviousPage}; } return AccountCursor{.index = beast::zero, .hint = 0}; @@ -639,12 +638,12 @@ traverseNFTObjects( 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 ) { @@ -694,7 +693,7 @@ traverseOwnedNodes( return traverseOwnedNodes( backend, - ripple::keylet::ownerDir(accountID), + xrpl::keylet::ownerDir(accountID), hexCursor, startHint, sequence, @@ -707,13 +706,13 @@ 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}); @@ -723,7 +722,7 @@ traverseOwnedNodes( // 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. @@ -734,19 +733,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::rpcINVALID_PARAMS, "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::rpcINVALID_PARAMS, "Invalid marker.")}; } currentIndex = hintIndex; @@ -756,14 +755,14 @@ traverseOwnedNodes( if (!ownerDir) { return std::unexpected{ - Status(ripple::rpcINVALID_PARAMS, "Owner directory not found.") + Status(xrpl::rpcINVALID_PARAMS, "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; @@ -781,11 +780,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 { @@ -795,10 +794,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) @@ -810,11 +809,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; } } @@ -834,8 +833,8 @@ 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) @@ -844,25 +843,25 @@ traverseOwnedNodes( return AccountCursor({.index = beast::zero, .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 @@ -871,29 +870,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 kSEED_SIZE = 18; static constexpr std::array kSEED_PREFIX = {0xE1, 0x4B}; if (result.size() == kSEED_SIZE && static_cast(result[0]) == kSEED_PREFIX[0] && static_cast(result[1]) == kSEED_PREFIX[1]) - return ripple::Seed(ripple::makeSlice(result.substr(2))); + return xrpl::Seed(xrpl::makeSlice(result.substr(2))); return {}; } -std::vector +std::vector getAccountsFromTransaction(boost::json::object const& transaction) { - std::vector accounts = {}; + std::vector accounts = {}; for (auto const& [key, value] : transaction) { if (value.is_object()) { auto inObject = getAccountsFromTransaction(value.as_object()); accounts.insert(accounts.end(), inObject.begin(), inObject.end()); } else if (value.is_string()) { - auto const account = util::parseBase58Wrapper( + auto const account = util::parseBase58Wrapper( boost::json::value_to(value) ); if (account) { @@ -909,30 +907,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 ) @@ -942,8 +940,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); }); } @@ -952,27 +950,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 ); } @@ -981,26 +979,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 ); } @@ -1008,9 +1002,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 ) { @@ -1018,33 +1012,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; - 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; @@ -1053,13 +1047,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 ) { @@ -1079,41 +1073,41 @@ accountFunds( ); } -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(); @@ -1124,27 +1118,27 @@ ammAccountHolds( 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; } @@ -1160,35 +1154,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 ); } @@ -1198,50 +1192,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); } 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::parityRate; } 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, @@ -1250,7 +1244,7 @@ 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); @@ -1259,14 +1253,14 @@ postProcessOrderBook( 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); - - auto const uOfferOwnerID = offer.getAccountID(ripple::sfAccount); - auto const& saTakerGets = offer.getFieldAmount(ripple::sfTakerGets); - auto const& saTakerPays = offer.getFieldAmount(ripple::sfTakerPays); - ripple::STAmount saOwnerFunds; + 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(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) { @@ -1303,12 +1297,12 @@ postProcessOrderBook( 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::parityRate; + xrpl::STAmount const dirRate = xrpl::amountFromQuality(getQuality(bookDir)); - if (rate != ripple::parityRate + if (rate != xrpl::parityRate // Have a transfer fee. && takerID != book.out.account // Not taking offers of own IOUs. @@ -1317,7 +1311,7 @@ postProcessOrderBook( { // Need to charge a transfer fee to offer owner. offerRate = rate; - saOwnerFundsLimit = ripple::divide(saOwnerFunds, offerRate); + saOwnerFundsLimit = xrpl::divide(saOwnerFunds, offerRate); } if (saOwnerFundsLimit >= saTakerGets) { @@ -1326,19 +1320,18 @@ postProcessOrderBook( } else { saTakerGetsFunded = saOwnerFundsLimit; offerJson["taker_gets_funded"] = - toBoostJson(saTakerGetsFunded.getJson(ripple::JsonOptions::none)); + toBoostJson(saTakerGetsFunded.getJson(xrpl::JsonOptions::none)); offerJson["taker_pays_funded"] = toBoostJson( std::min( - saTakerPays, - ripple::multiply(saTakerGetsFunded, dirRate, saTakerPays.issue()) + saTakerPays, xrpl::multiply(saTakerGetsFunded, dirRate, saTakerPays.issue()) ) - .getJson(ripple::JsonOptions::none) + .getJson(xrpl::JsonOptions::none) ); } - ripple::STAmount const saOwnerPays = (ripple::parityRate == offerRate) + xrpl::STAmount const saOwnerPays = (xrpl::parityRate == offerRate) ? saTakerGetsFunded - : std::min(saOwnerFunds, ripple::multiply(saTakerGetsFunded, offerRate)); + : std::min(saOwnerFunds, xrpl::multiply(saTakerGetsFunded, offerRate)); umBalance[uOfferOwnerID] = saOwnerFunds - saOwnerPays; @@ -1357,12 +1350,12 @@ 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 ) { @@ -1380,14 +1373,14 @@ parseBook( }}; } - if (ripple::isXRP(gets) && !ripple::isXRP(getIssuer)) { + if (xrpl::isXRP(gets) && !xrpl::isXRP(getIssuer)) { return std::unexpected{Status{ RippledError::rpcDST_ISR_MALFORMED, "Unneeded field 'taker_gets.issuer' for XRP currency specification." }}; } - if (!ripple::isXRP(gets) && ripple::isXRP(getIssuer)) { + if (!xrpl::isXRP(gets) && xrpl::isXRP(getIssuer)) { return std::unexpected{Status{ RippledError::rpcDST_ISR_MALFORMED, "Invalid field 'taker_gets.issuer', expected non-XRP issuer." @@ -1397,18 +1390,18 @@ parseBook( if (pays == gets && payIssuer == getIssuer) return std::unexpected{Status{RippledError::rpcBAD_MARKET, "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}}; domainID = dom; } - return ripple::Book{{pays, payIssuer}, {gets, getIssuer}, domainID}; + return xrpl::Book{{pays, payIssuer}, {gets, getIssuer}, domainID}; } -std::expected +std::expected parseBook(boost::json::object const& request) { if (!request.contains("taker_pays")) { @@ -1455,19 +1448,17 @@ parseBook(boost::json::object const& request) if (request.contains("domain") && !request.at("domain").is_string()) return std::unexpected{Status{RippledError::rpcDOMAIN_MALFORMED}}; - ripple::Currency payCurrency; - if (!ripple::to_currency( + xrpl::Currency payCurrency; + if (!xrpl::to_currency( payCurrency, boost::json::value_to(takerPays.at("currency")) )) return std::unexpected{Status{RippledError::rpcSRC_CUR_MALFORMED}}; - ripple::Currency getCurrency; - if (!ripple::to_currency( - getCurrency, boost::json::value_to(takerGets["currency"]) - )) + xrpl::Currency getCurrency; + if (!xrpl::to_currency(getCurrency, boost::json::value_to(takerGets["currency"]))) return std::unexpected{Status{RippledError::rpcDST_AMT_MALFORMED}}; - ripple::AccountID payIssuer; + xrpl::AccountID payIssuer; if (takerPays.contains("issuer")) { if (!takerPays.at("issuer").is_string()) { return std::unexpected{ @@ -1475,15 +1466,13 @@ parseBook(boost::json::object const& request) }; } - if (!ripple::to_issuer( - payIssuer, boost::json::value_to(takerPays.at("issuer")) - )) + if (!xrpl::to_issuer(payIssuer, boost::json::value_to(takerPays.at("issuer")))) return std::unexpected{Status{RippledError::rpcSRC_ISR_MALFORMED}}; - if (payIssuer == ripple::noAccount()) + if (payIssuer == xrpl::noAccount()) return std::unexpected{Status{RippledError::rpcSRC_ISR_MALFORMED}}; } else { - payIssuer = ripple::xrpAccount(); + payIssuer = xrpl::xrpAccount(); } if (isXRP(payCurrency) && !isXRP(payIssuer)) { @@ -1506,7 +1495,7 @@ parseBook(boost::json::object const& request) }; } - ripple::AccountID getIssuer; + xrpl::AccountID getIssuer; if (takerGets.contains("issuer")) { if (!takerGets["issuer"].is_string()) { @@ -1515,7 +1504,7 @@ parseBook(boost::json::object const& request) }; } - if (!ripple::to_issuer( + if (!xrpl::to_issuer( getIssuer, boost::json::value_to(takerGets.at("issuer")) )) { return std::unexpected{Status{ @@ -1523,24 +1512,24 @@ parseBook(boost::json::object const& request) }}; } - if (getIssuer == ripple::noAccount()) { + if (getIssuer == xrpl::noAccount()) { return std::unexpected{Status{ RippledError::rpcDST_ISR_MALFORMED, "Invalid field 'taker_gets.issuer', bad issuer account one." }}; } } else { - getIssuer = ripple::xrpAccount(); + getIssuer = xrpl::xrpAccount(); } - if (ripple::isXRP(getCurrency) && !ripple::isXRP(getIssuer)) { + if (xrpl::isXRP(getCurrency) && !xrpl::isXRP(getIssuer)) { return std::unexpected{Status{ RippledError::rpcDST_ISR_MALFORMED, "Unneeded field 'taker_gets.issuer' for XRP currency specification." }}; } - if (!ripple::isXRP(getCurrency) && ripple::isXRP(getIssuer)) { + if (!xrpl::isXRP(getCurrency) && xrpl::isXRP(getIssuer)) { return std::unexpected{Status{ RippledError::rpcDST_ISR_MALFORMED, "Invalid field 'taker_gets.issuer', expected non-XRP issuer." @@ -1550,21 +1539,21 @@ parseBook(boost::json::object const& request) if (payCurrency == getCurrency && payIssuer == getIssuer) return std::unexpected{Status{RippledError::rpcBAD_MARKET, "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}}; domainID = dom; } - return ripple::Book{{payCurrency, payIssuer}, {getCurrency, getIssuer}, domainID}; + return xrpl::Book{{payCurrency, payIssuer}, {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"}}; @@ -1575,7 +1564,7 @@ parseTaker(boost::json::value const& taker) return *takerID; } -ripple::Issue +xrpl::Issue parseIssue(boost::json::object const& issue) { Json::Value jv; @@ -1584,7 +1573,7 @@ parseIssue(boost::json::object const& issue) 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 @@ -1627,7 +1616,7 @@ 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))) @@ -1636,7 +1625,7 @@ getNFTID(boost::json::object const& request) if (!request.at(JS(nft_id)).is_string()) return std::unexpected{Status{RippledError::rpcINVALID_PARAMS, "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"}}; @@ -1648,8 +1637,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 231513c35..006d916a1 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,7 +236,7 @@ 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; @@ -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. + * @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/Types.hpp b/src/rpc/common/Types.hpp index fbf190de1..dd666e389 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 { 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 a745bf342..27d625a94 100644 --- a/src/rpc/common/Validators.cpp +++ b/src/rpc/common/Validators.cpp @@ -80,17 +80,17 @@ 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 = @@ -117,7 +117,7 @@ CustomValidator CustomValidators::ledgerTypeValidator = 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)} }; @@ -145,7 +145,7 @@ CustomValidator CustomValidators::accountBase58Validator = return Error{Status{RippledError::rpcINVALID_PARAMS, 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}}; @@ -178,7 +178,7 @@ CustomValidator CustomValidators::accountTypeValidator = 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)} }; @@ -196,8 +196,8 @@ CustomValidator CustomValidators::currencyValidator = if (currencyStr.empty()) return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "IsEmpty"}}; - ripple::Currency currency; - if (!ripple::to_currency(currency, currencyStr)) + xrpl::Currency currency; + if (!xrpl::to_currency(currency, currencyStr)) return Error{Status{ClioError::RpcMalformedCurrency, "malformedCurrency"}}; return MaybeError{}; @@ -208,16 +208,16 @@ CustomValidator CustomValidators::issuerValidator = if (!value.is_string()) return Error{Status{RippledError::rpcINVALID_PARAMS, 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::to_issuer(issuer, boost::json::value_to(value))) { return Error{Status{ RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}', bad issuer.", key) }}; } - if (issuer == ripple::noAccount()) { + if (issuer == xrpl::noAccount()) { return Error{Status{ RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}', bad issuer account one.", key) @@ -301,7 +301,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" @@ -314,7 +314,7 @@ CustomValidator CustomValidators::credentialTypeValidator = }; } - if (credTypeHex->size() > ripple::maxCredentialTypeLength) { + if (credTypeHex->size() > xrpl::maxCredentialTypeLength) { return Error{Status{ ClioError::RpcMalformedAuthorizedCredentials, std::string(key) + " greater than max length" @@ -337,12 +337,12 @@ CustomValidator CustomValidators::authorizeCredentialValidator = }}; } - if (authCred.size() > ripple::maxCredentialsArraySize) { + if (authCred.size() > xrpl::maxCredentialsArraySize) { return Error{Status{ ClioError::RpcMalformedAuthorizedCredentials, fmt::format( "Max {} number of credentials in authorized_credentials array", - ripple::maxCredentialsArraySize + xrpl::maxCredentialsArraySize ) }}; } diff --git a/src/rpc/common/Validators.hpp b/src/rpc/common/Validators.hpp index c4e053d88..82864b690 100644 --- a/src/rpc/common/Validators.hpp +++ b/src/rpc/common/Validators.hpp @@ -460,8 +460,8 @@ 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) @@ -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. */ @@ -618,7 +618,7 @@ 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."} diff --git a/src/rpc/handlers/AMMInfo.cpp b/src/rpc/handlers/AMMInfo.cpp index 6e7169e2b..f4c76b74d 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 kRIPPLE_EPOCH_OFFSET = seconds{kRIPPLE_EPOCH_START}; @@ -63,15 +63,15 @@ 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) @@ -95,20 +95,20 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; } - 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()}, + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{accountLedgerObject->data(), accountLedgerObject->size()}, accountKeylet.key }; - if (not sle.isFieldPresent(ripple::sfAMMID)) + if (not sle.isFieldPresent(xrpl::sfAMMID)) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; - ammID = sle.getFieldH256(ripple::sfAMMID); + ammID = sle.getFieldH256(xrpl::sfAMMID); } auto issue1 = input.issue1; @@ -131,7 +131,7 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) // 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(); } @@ -152,7 +152,7 @@ AMMInfoHandler::process(AMMInfoHandler::Input const& input, Context const& ctx) Output response; response.ledgerIndex = lgrInfo.seq; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.amount1 = toBoostJson(asset1Balance.getJson(JsonOptions::none)); response.amount2 = toBoostJson(asset2Balance.getJson(JsonOptions::none)); response.lpToken = toBoostJson(lptAMMBalance.getJson(JsonOptions::none)); @@ -235,7 +235,7 @@ AMMInfoHandler::spec([[maybe_unused]] uint32_t apiVersion) } 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}}; } diff --git a/src/rpc/handlers/AMMInfo.hpp b/src/rpc/handlers/AMMInfo.hpp index 760c42aa5..14598f3d5 100644 --- a/src/rpc/handlers/AMMInfo.hpp +++ b/src/rpc/handlers/AMMInfo.hpp @@ -51,10 +51,10 @@ class AMMInfoHandler { * @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 e0bd79e7c..30e7c69a3 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]; - - if (publicKeyType(channelSle[ripple::sfPublicKey])) { - ripple::PublicKey const pk(channelSle[ripple::sfPublicKey]); - channel.publicKey = toBase58(ripple::TokenType::AccountPublic, pk); + 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[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); @@ -84,7 +84,7 @@ AccountChannelsHandler::process( auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) @@ -92,13 +92,12 @@ AccountChannelsHandler::process( auto const destAccountID = input.destinationAccount ? accountFromStringStrict(input.destinationAccount.value()) - : std::optional{}; + : std::optional{}; Output response; - auto const addToResponse = [&](ripple::SLE const sle) { - if (sle.getType() == ripple::ltPAYCHAN && - sle.getAccountID(ripple::sfAccount) == accountID && - (!destAccountID || *destAccountID == sle.getAccountID(ripple::sfDestination))) { + auto const addToResponse = [&](xrpl::SLE const sle) { + if (sle.getType() == xrpl::ltPAYCHAN && sle.getAccountID(xrpl::sfAccount) == accountID && + (!destAccountID || *destAccountID == sle.getAccountID(xrpl::sfDestination))) { addChannel(response.channels, sle); } @@ -120,7 +119,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.value(); diff --git a/src/rpc/handlers/AccountChannels.hpp b/src/rpc/handlers/AccountChannels.hpp index f74d4ba0f..e91d960d9 100644 --- a/src/rpc/handlers/AccountChannels.hpp +++ b/src/rpc/handlers/AccountChannels.hpp @@ -132,7 +132,7 @@ class AccountChannelsHandler { 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 e023e2856..086a6cc4d 100644 --- a/src/rpc/handlers/AccountCurrencies.cpp +++ b/src/rpc/handlers/AccountCurrencies.cpp @@ -43,17 +43,17 @@ AccountCurrenciesHandler::process( auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; 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; @@ -62,10 +62,10 @@ AccountCurrenciesHandler::process( balance.negate(); if (balance < lineLimit) - response.receiveCurrencies.insert(ripple::to_string(balance.getCurrency())); + response.receiveCurrencies.insert(xrpl::to_string(balance.getCurrency())); if ((-balance) < lineLimitPeer) - response.sendCurrencies.insert(ripple::to_string(balance.getCurrency())); + response.sendCurrencies.insert(xrpl::to_string(balance.getCurrency())); } return true; @@ -82,7 +82,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 f0535c173..1f801dda5 100644 --- a/src/rpc/handlers/AccountInfo.cpp +++ b/src/rpc/handlers/AccountInfo.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include #include @@ -40,7 +41,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::rpcINVALID_PARAMS, xrpl::RPC::missing_field_message(JS(account))} }; } @@ -56,15 +57,15 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons auto const& lgrInfo = expectedLgrInfo.value(); auto const accountStr = input.account.value_or(input.ident.value_or("")); auto const accountID = accountFromStringStrict(accountStr); - auto const accountKeylet = ripple::keylet::account(*accountID); + auto const accountKeylet = xrpl::keylet::account(*accountID); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject(accountKeylet.key, lgrInfo.seq, ctx.yield); if (!accountLedgerObject) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{accountLedgerObject->data(), accountLedgerObject->size()}, + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{accountLedgerObject->data(), accountLedgerObject->size()}, accountKeylet.key }; @@ -81,7 +82,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, @@ -94,17 +95,17 @@ AccountInfoHandler::process(AccountInfoHandler::Input const& input, Context cons if (input.signerLists) { // We put the SignerList in an array because of an anticipated // future when we support multiple signer lists on one account. - auto const signersKey = ripple::keylet::signers(*accountID); + auto const signersKey = xrpl::keylet::signers(*accountID); // This code will need to be revisited if in the future we // support multiple SignerLists on one account. auto const signers = sharedPtrBackend_->fetchLedgerObject(signersKey.key, lgrInfo.seq, ctx.yield); - out.signerLists = std::vector(); + out.signerLists = std::vector(); if (signers) { - ripple::STLedgerEntry const sleSigners{ - ripple::SerialIter{signers->data(), signers->size()}, signersKey.key + xrpl::STLedgerEntry const sleSigners{ + xrpl::SerialIter{signers->data(), signers->size()}, signersKey.key }; if (!signersKey.check(sleSigners)) @@ -131,34 +132,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) @@ -166,7 +167,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 3f98ead45..2cd87c8f7 100644 --- a/src/rpc/handlers/AccountInfo.hpp +++ b/src/rpc/handlers/AccountInfo.hpp @@ -39,12 +39,12 @@ class AccountInfoHandler { 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 92091b594..a3aa50b15 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.issue().currency); line.limit = saLimit.getText(); line.limitPeer = saLimitPeer.getText(); line.qualityIn = lineQualityIn; @@ -133,26 +132,26 @@ AccountLinesHandler::process(AccountLinesHandler::Input const& input, Context co auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (not accountLedgerObject) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; 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); } } @@ -179,7 +178,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 3a59d0b7c..a50787c44 100644 --- a/src/rpc/handlers/AccountLines.hpp +++ b/src/rpc/handlers/AccountLines.hpp @@ -150,9 +150,9 @@ class AccountLinesHandler { 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 2b07de771..f20b219a4 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); } @@ -115,7 +115,7 @@ AccountMPTokenIssuancesHandler::process( auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (not accountLedgerObject.has_value()) @@ -124,8 +124,8 @@ AccountMPTokenIssuancesHandler::process( 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); } }; @@ -148,7 +148,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 3c3ca069d..d86103d40 100644 --- a/src/rpc/handlers/AccountMPTokenIssuances.hpp +++ b/src/rpc/handlers/AccountMPTokenIssuances.hpp @@ -152,8 +152,8 @@ class AccountMPTokenIssuancesHandler { 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 19768a235..81d32d165 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); } @@ -72,7 +72,7 @@ AccountMPTokensHandler::process( auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (not accountLedgerObject.has_value()) @@ -81,8 +81,8 @@ AccountMPTokensHandler::process( 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); } }; @@ -105,7 +105,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 aef576238..8ce06ddd7 100644 --- a/src/rpc/handlers/AccountMPTokens.hpp +++ b/src/rpc/handlers/AccountMPTokens.hpp @@ -128,7 +128,7 @@ class AccountMPTokensHandler { 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 c85cf95b2..7db00bab3 100644 --- a/src/rpc/handlers/AccountNFTs.cpp +++ b/src/rpc/handlers/AccountNFTs.cpp @@ -45,7 +45,7 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) @@ -54,12 +54,12 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons auto response = Output{}; response.account = input.account; response.limit = input.limit; - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; // if a marker was passed, start at the page specified in marker. Else, start at the max page - auto const pageKey = input.marker ? ripple::uint256{input.marker->c_str()} - : ripple::keylet::nftpage_max(*accountID).key; + auto const pageKey = input.marker ? xrpl::uint256{input.marker->c_str()} + : xrpl::keylet::nftpage_max(*accountID).key; auto const blob = sharedPtrBackend_->fetchLedgerObject(pageKey, lgrInfo.seq, ctx.yield); if (!blob) { @@ -71,11 +71,11 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons 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"} }; @@ -84,27 +84,27 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons 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::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; @@ -113,7 +113,7 @@ AccountNFTsHandler::process(AccountNFTsHandler::Input const& input, Context cons auto const nextBlob = sharedPtrBackend_->fetchLedgerObject(nextKey.key, lgrInfo.seq, ctx.yield); page.emplace( - 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 8a29eb9e3..42d6f66e3 100644 --- a/src/rpc/handlers/AccountObjects.cpp +++ b/src/rpc/handlers/AccountObjects.cpp @@ -46,13 +46,13 @@ AccountObjectsHandler::process(AccountObjectsHandler::Input const& input, Contex auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; - auto typeFilter = std::optional>{}; + auto typeFilter = std::optional>{}; if (input.deletionBlockersOnly) { typeFilter.emplace(); @@ -66,12 +66,12 @@ AccountObjectsHandler::process(AccountObjectsHandler::Input const& input, Contex typeFilter->push_back(type); } } else { - if (input.type && input.type != ripple::ltANY) + if (input.type && input.type != xrpl::ltANY) typeFilter = {*input.type}; } Output response; - auto const addToResponse = [&](ripple::SLE&& sle) { + auto const addToResponse = [&](xrpl::SLE&& sle) { if (not typeFilter or std::find( std::begin(typeFilter.value()), std::end(typeFilter.value()), sle.getType() @@ -95,7 +95,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 d88f672e5..f2ca2484a 100644 --- a/src/rpc/handlers/AccountObjects.hpp +++ b/src/rpc/handlers/AccountObjects.hpp @@ -47,7 +47,7 @@ class AccountObjectsHandler { uint32_t ledgerIndex{}; std::optional marker; uint32_t limit{}; - std::vector accountObjects; + std::vector accountObjects; bool validated = true; }; @@ -60,7 +60,7 @@ class AccountObjectsHandler { std::optional ledgerIndex; uint32_t limit = kLIMIT_DEFAULT; // [10,400] std::optional marker; - std::optional type; + std::optional type; bool deletionBlockersOnly = false; }; diff --git a/src/rpc/handlers/AccountOffers.cpp b/src/rpc/handlers/AccountOffers.cpp index 5b39e105a..0b6fdd7fa 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); }; @@ -62,19 +62,19 @@ AccountOffersHandler::process(AccountOffersHandler::Input const& input, Context auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; Output response; - response.account = ripple::to_string(*accountID); - response.ledgerHash = ripple::strHex(lgrInfo.hash); + response.account = xrpl::to_string(*accountID); + response.ledgerHash = xrpl::strHex(lgrInfo.hash); response.ledgerIndex = lgrInfo.seq; - auto const addToResponse = [&](ripple::SLE const sle) { - if (sle.getType() == ripple::ltOFFER) + auto const addToResponse = [&](xrpl::SLE const sle) { + if (sle.getType() == xrpl::ltOFFER) addOffer(response.offers, sle); return true; @@ -138,13 +138,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.getCurrency())}, + {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 aad4f0be5..26ab7e76e 100644 --- a/src/rpc/handlers/AccountOffers.hpp +++ b/src/rpc/handlers/AccountOffers.hpp @@ -41,8 +41,8 @@ class AccountOffersHandler { 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 @@ class AccountOffersHandler { 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 985e1d06f..f76f56331 100644 --- a/src/rpc/handlers/AccountTx.cpp +++ b/src/rpc/handlers/AccountTx.cpp @@ -184,8 +184,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::to_string_iso(ledgerHeader->closeTime); } } obj[JS(validated)] = true; @@ -201,7 +201,7 @@ AccountTxHandler::process(AccountTxHandler::Input const& input, Context const& c } response.limit = input.limit; - response.account = ripple::to_string(*accountID); + response.account = xrpl::to_string(*accountID); response.ledgerIndexMin = minIndex; response.ledgerIndexMax = maxIndex; diff --git a/src/rpc/handlers/BookChanges.cpp b/src/rpc/handlers/BookChanges.cpp index 933f831a7..2c08e1244 100644 --- a/src/rpc/handlers/BookChanges.cpp +++ b/src/rpc/handlers/BookChanges.cpp @@ -41,7 +41,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(); @@ -87,7 +87,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 452309629..194c6da5e 100644 --- a/src/rpc/handlers/BookOffers.cpp +++ b/src/rpc/handlers/BookOffers.cpp @@ -52,7 +52,7 @@ 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, @@ -87,24 +87,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::to_currency( input.getsCurrency, boost::json::value_to(jv.at(JS(taker_gets)).as_object().at(JS(currency))) ); - ripple::to_currency( + xrpl::to_currency( 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::to_issuer( 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::to_issuer( 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 e5c7f313f..5b50ce07a 100644 --- a/src/rpc/handlers/BookOffers.hpp +++ b/src/rpc/handlers/BookOffers.hpp @@ -61,12 +61,12 @@ class BookOffersHandler { std::optional ledgerHash; std::optional ledgerIndex; uint32_t limit = kLIMIT_DEFAULT; - std::optional taker; - ripple::Currency paysCurrency; - ripple::Currency getsCurrency; + std::optional taker; + xrpl::Currency paysCurrency; + xrpl::Currency getsCurrency; // accountID will be filled by input converter, if no issuer is given, will use XRP issuer - ripple::AccountID paysID = ripple::xrpAccount(); - ripple::AccountID getsID = ripple::xrpAccount(); + xrpl::AccountID paysID = xrpl::xrpAccount(); + xrpl::AccountID getsID = xrpl::xrpAccount(); std::optional domain; }; diff --git a/src/rpc/handlers/DepositAuthorized.cpp b/src/rpc/handlers/DepositAuthorized.cpp index e80f55539..47ce7a4a4 100644 --- a/src/rpc/handlers/DepositAuthorized.cpp +++ b/src/rpc/handlers/DepositAuthorized.cpp @@ -51,13 +51,13 @@ DepositAuthorizedHandler::process( auto const destinationAccountID = accountFromStringStrict(input.destinationAccount); auto const srcAccountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*sourceAccountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*sourceAccountID).key, lgrInfo.seq, ctx.yield ); if (!srcAccountLedgerObject) return Error{Status{RippledError::rpcSRC_ACT_NOT_FOUND, "source_accountNotFound"}}; - auto const dstKeylet = ripple::keylet::account(*destinationAccountID).key; + auto const dstKeylet = xrpl::keylet::account(*destinationAccountID).key; auto const dstAccountLedgerObject = sharedPtrBackend_->fetchLedgerObject(dstKeylet, lgrInfo.seq, ctx.yield); @@ -66,21 +66,21 @@ DepositAuthorizedHandler::process( 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.value().empty()) { return Error{ Status{RippledError::rpcINVALID_PARAMS, "credential array has no elements."} }; } - if (creds.value().size() > ripple::maxCredentialsArraySize) { + if (creds.value().size() > xrpl::maxCredentialsArraySize) { return Error{Status{RippledError::rpcINVALID_PARAMS, "credential array too long."}}; } auto const credArray = credentials::fetchCredentialArray( @@ -96,7 +96,7 @@ DepositAuthorizedHandler::process( bool depositAuthorized = true; if (reqAuth) { - ripple::uint256 hashKey; + xrpl::uint256 hashKey; if (credentialsPresent) { auto const sortedAuthCreds = credentials::createAuthCredentials(authCreds); ASSERT( @@ -104,9 +104,9 @@ DepositAuthorizedHandler::process( "should already be checked above that there is no duplicate" ); - hashKey = ripple::keylet::depositPreauth(*destinationAccountID, sortedAuthCreds).key; + hashKey = xrpl::keylet::depositPreauth(*destinationAccountID, sortedAuthCreds).key; } else { - hashKey = ripple::keylet::depositPreauth(*destinationAccountID, *sourceAccountID).key; + hashKey = xrpl::keylet::depositPreauth(*destinationAccountID, *sourceAccountID).key; } depositAuthorized = @@ -115,7 +115,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 663593a26..42e98e64d 100644 --- a/src/rpc/handlers/Feature.cpp +++ b/src/rpc/handlers/Feature.cpp @@ -52,7 +52,7 @@ FeatureHandler::process(FeatureHandler::Input const& input, Context const& ctx) auto searchPredicate = [search = input.feature](auto const& feature) { if (search) { - return ripple::to_string(feature.feature) == search.value() or + return xrpl::to_string(feature.feature) == search.value() or feature.name == search.value(); } return true; @@ -63,7 +63,7 @@ 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, }; } @@ -90,7 +90,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() }; diff --git a/src/rpc/handlers/GatewayBalances.cpp b/src/rpc/handlers/GatewayBalances.cpp index 665c1224c..50be45a06 100644 --- a/src/rpc/handlers/GatewayBalances.cpp +++ b/src/rpc/handlers/GatewayBalances.cpp @@ -57,7 +57,7 @@ GatewayBalancesHandler::process( auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) @@ -65,9 +65,9 @@ GatewayBalancesHandler::process( auto output = GatewayBalancesHandler::Output{}; - auto addEscrow = [&](ripple::SLE const& sle) { - if (sle.getType() == ripple::ltESCROW) { - auto const& escrow = sle.getFieldAmount(ripple::sfAmount); + auto addEscrow = [&](xrpl::SLE const& sle) { + if (sle.getType() == xrpl::ltESCROW) { + auto const& escrow = sle.getFieldAmount(xrpl::sfAmount); auto& lockedBalance = output.locked[escrow.getCurrency()]; if (lockedBalance == beast::zero) { // This is needed to set the currency code correctly @@ -80,28 +80,26 @@ 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.issue(), xrpl::STAmount::cMaxValue, xrpl::STAmount::cMaxOffset ); } } } }; - 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(); @@ -134,8 +132,8 @@ GatewayBalancesHandler::process( try { bal -= balance; } catch (std::runtime_error const& e) { - bal = ripple::STAmount( - bal.issue(), ripple::STAmount::cMaxValue, ripple::STAmount::cMaxOffset + bal = xrpl::STAmount( + bal.issue(), xrpl::STAmount::cMaxValue, xrpl::STAmount::cMaxOffset ); } } @@ -160,7 +158,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; @@ -177,31 +175,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; - - 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); + 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)] = xrpl::to_string(balance.issue().currency); + entry[JS(value)] = balance.getText(); + arr.push_back(std::move(entry)); } + + balancesObj[xrpl::to_string(accId)] = std::move(arr); } + } - return balancesObj; - }; + return balancesObj; + }; if (auto balances = toJson(output.hotBalances); !balances.empty()) obj[JS(balances)] = balances; @@ -217,7 +214,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 13ebc6a6a..5bf855631 100644 --- a/src/rpc/handlers/GatewayBalances.hpp +++ b/src/rpc/handlers/GatewayBalances.hpp @@ -50,11 +50,11 @@ class GatewayBalancesHandler { 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 @@ class GatewayBalancesHandler { */ struct Input { std::string account; - std::set hotWallets; + std::set hotWallets; std::optional ledgerHash; std::optional ledgerIndex; }; @@ -99,18 +99,17 @@ class GatewayBalancesHandler { // 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,10 +134,10 @@ class GatewayBalancesHandler { }; static auto const kSPEC_V1 = RpcSpec{ - kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_HOTWALLET)}} + kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(xrpl::rpcINVALID_HOTWALLET)}} }; static auto const kSPEC_V2 = RpcSpec{ - kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(ripple::rpcINVALID_PARAMS)}} + kSPEC_COMMON, {{JS(hotwallet), getHotWalletValidator(xrpl::rpcINVALID_PARAMS)}} }; return apiVersion == 1 ? kSPEC_V1 : kSPEC_V2; diff --git a/src/rpc/handlers/GetAggregatePrice.cpp b/src/rpc/handlers/GetAggregatePrice.cpp index 0f5422371..6da017e3f 100644 --- a/src/rpc/handlers/GetAggregatePrice.cpp +++ b/src/rpc/handlers/GetAggregatePrice.cpp @@ -60,47 +60,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; @@ -110,14 +109,14 @@ GetAggregatePriceHandler::process( } if (timestampPricesBiMap.empty()) - return Error{Status{ripple::rpcOBJECT_NOT_FOUND}}; + return Error{Status{xrpl::rpcOBJECT_NOT_FOUND}}; 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 = "" }; @@ -137,15 +136,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)); @@ -174,11 +173,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; }(); @@ -190,14 +189,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 kHISTORY_MAX = 3; - std::optional optOracleObject = oracleObject; - std::optional optCurrentObject = optOracleObject; + std::optional optOracleObject = oracleObject; + std::optional optCurrentObject = optOracleObject; bool isNew = false; bool noOracleFound = false; @@ -215,7 +214,7 @@ GetAggregatePriceHandler::tracebackOracleObject( if (++history > kHISTORY_MAX) return; - auto const prevTxIndex = optCurrentObject->getFieldH256(ripple::sfPreviousTxnID); + auto const prevTxIndex = optCurrentObject->getFieldH256(xrpl::sfPreviousTxnID); auto const prevTx = sharedPtrBackend_->fetchTransaction(prevTxIndex, yield); if (not prevTx) @@ -224,13 +223,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 @@ -239,8 +238,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; } @@ -268,7 +267,7 @@ tag_invoke(boost::json::value_to_tag, boost::js .documentId = boost::json::value_to( oracle.as_object().at(JS(oracle_document_id)) ), - .account = *util::parseBase58Wrapper( + .account = *util::parseBase58Wrapper( boost::json::value_to(oracle.as_object().at(JS(account))) ) } @@ -301,7 +300,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} @@ -310,7 +309,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 1ef04222c..49a0fca49 100644 --- a/src/rpc/handlers/GetAggregatePrice.hpp +++ b/src/rpc/handlers/GetAggregatePrice.hpp @@ -39,9 +39,9 @@ class GetAggregatePriceHandler { * @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 @@ class GetAggregatePriceHandler { */ struct Oracle { std::uint32_t documentId{0}; - ripple::AccountID account; + xrpl::AccountID account; }; /** @@ -187,8 +187,8 @@ class GetAggregatePriceHandler { 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 522720661..d9e11f926 100644 --- a/src/rpc/handlers/Ledger.cpp +++ b/src/rpc/handlers/Ledger.cpp @@ -63,7 +63,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::to_string_iso(lgrInfo.closeTime); auto const expandTxJsonV2 = [&](data::TransactionAndMetadata const& tx) { auto [txn, meta] = toExpandedJson(tx, ctx.apiVersion); @@ -78,7 +78,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)); @@ -105,10 +105,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 @@ -137,7 +137,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)); } ); } } @@ -150,13 +150,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 { @@ -167,7 +167,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 6fefa5ac8..4fb18c303 100644 --- a/src/rpc/handlers/LedgerData.cpp +++ b/src/rpc/handlers/LedgerData.cpp @@ -66,7 +66,7 @@ LedgerDataHandler::process(Input const& input, Context const& ctx) const return Error{Status{RippledError::rpcINVALID_PARAMS, "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(); @@ -75,7 +75,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()) @@ -105,7 +105,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; } @@ -119,14 +119,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)); @@ -194,9 +194,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 31be17bea..78a99dc0f 100644 --- a/src/rpc/handlers/LedgerData.hpp +++ b/src/rpc/handlers/LedgerData.hpp @@ -65,10 +65,10 @@ class LedgerDataHandler { std::optional ledgerIndex; bool binary = false; uint32_t limit = LedgerDataHandler::kLIMIT_JSON; // max 256 for json ; 2048 for binary - std::optional marker; + std::optional marker; std::optional diffMarker; bool outOfOrder = false; - ripple::LedgerEntryType type = ripple::LedgerEntryType::ltANY; + xrpl::LedgerEntryType type = xrpl::LedgerEntryType::ltANY; }; using Result = HandlerReturnType; diff --git a/src/rpc/handlers/LedgerEntry.cpp b/src/rpc/handlers/LedgerEntry.cpp index 6a172e4a7..bab0843d5 100644 --- a/src/rpc/handlers/LedgerEntry.cpp +++ b/src/rpc/handlers/LedgerEntry.cpp @@ -42,19 +42,18 @@ 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}}; } else if (input.accountRoot) { - key = ripple::keylet::account( - *util::parseBase58Wrapper(*(input.accountRoot)) - ) - .key; + key = + xrpl::keylet::account(*util::parseBase58Wrapper(*(input.accountRoot))) + .key; } else if (input.did) { - key = ripple::keylet::did(*util::parseBase58Wrapper(*(input.did))).key; + key = xrpl::keylet::did(*util::parseBase58Wrapper(*(input.did))).key; } else if (input.directory) { auto const expectedkey = composeKeyFromDirectory(*input.directory); if (!expectedkey.has_value()) @@ -62,36 +61,34 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons key = expectedkey.value(); } else if (input.offer) { - auto const id = util::parseBase58Wrapper( + auto const id = util::parseBase58Wrapper( boost::json::value_to(input.offer->at(JS(account))) ); - key = ripple::keylet::offer( - *id, boost::json::value_to(input.offer->at(JS(seq))) - ) - .key; + key = + xrpl::keylet::offer(*id, boost::json::value_to(input.offer->at(JS(seq)))) + .key; } 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::to_currency( boost::json::value_to(input.rippleStateAccount->at(JS(currency))) ); - key = ripple::keylet::line(*id1, *id2, currency).key; + key = xrpl::keylet::line(*id1, *id2, currency).key; } else if (input.escrow) { - auto const id = util::parseBase58Wrapper( + auto const id = util::parseBase58Wrapper( boost::json::value_to(input.escrow->at(JS(owner))) ); - key = - ripple::keylet::escrow(*id, util::integralValueAs(input.escrow->at(JS(seq)))) - .key; + key = xrpl::keylet::escrow(*id, util::integralValueAs(input.escrow->at(JS(seq)))) + .key; } else if (input.depositPreauth) { - auto const owner = util::parseBase58Wrapper( + auto const owner = util::parseBase58Wrapper( boost::json::value_to(input.depositPreauth->at(JS(owner))) ); // Only one of authorize or authorized_credentials MUST exist; @@ -104,10 +101,10 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons } if (input.depositPreauth->contains(JS(authorized))) { - auto const authorized = util::parseBase58Wrapper( + auto const authorized = util::parseBase58Wrapper( boost::json::value_to(input.depositPreauth->at(JS(authorized))) ); - key = ripple::keylet::depositPreauth(*owner, *authorized).key; + key = xrpl::keylet::depositPreauth(*owner, *authorized).key; } else { auto const authorizedCredentials = rpc::credentials::parseAuthorizeCredentials( input.depositPreauth->at(JS(authorized_credentials)).as_array() @@ -120,31 +117,31 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons }}; } - key = ripple::keylet::depositPreauth(owner.value(), authCreds).key; + key = xrpl::keylet::depositPreauth(owner.value(), authCreds).key; } } else if (input.ticket) { - auto const id = util::parseBase58Wrapper( + auto const id = util::parseBase58Wrapper( boost::json::value_to(input.ticket->at(JS(account))) ); - key = ripple::getTicketIndex( + key = xrpl::getTicketIndex( *id, util::integralValueAs(input.ticket->at(JS(ticket_seq))) ); } else if (input.amm) { auto const getIssuerFromJson = [](auto const& assetJson) { // the field check has been done in validator auto const currency = - ripple::to_currency(boost::json::value_to(assetJson.at(JS(currency)))); - if (ripple::isXRP(currency)) { - return ripple::xrpIssue(); + xrpl::to_currency(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))) ) @@ -155,19 +152,19 @@ 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.value()) - .key; + key = + xrpl::keylet::xChainClaimID(input.bridge->value(), input.chainClaimId.value()).key; } else { - key = ripple::keylet::xChainCreateAccountClaimID( + key = xrpl::keylet::xChainCreateAccountClaimID( input.bridge->value(), input.createAccountClaimId.value() ) .key; @@ -177,48 +174,48 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons } else if (input.credential) { key = input.credential.value(); } else if (input.mptIssuance) { - auto const mptIssuanceID = ripple::uint192{std::string_view(*(input.mptIssuance))}; - key = ripple::keylet::mptIssuance(mptIssuanceID).key; + auto const mptIssuanceID = xrpl::uint192{std::string_view(*(input.mptIssuance))}; + key = xrpl::keylet::mptIssuance(mptIssuanceID).key; } else if (input.mptoken) { - auto const holder = ripple::parseBase58( + 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))) )}; - 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))); - 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))); - 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))); - 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))) ); - 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) @@ -253,19 +250,19 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input const& input, Context cons 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) + if (input.expectedType != xrpl::ltANY && sle.getType() != input.expectedType) return Error{Status{RippledError::rpcUNEXPECTED_LEDGER_TYPE}}; - 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); } @@ -273,7 +270,7 @@ 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. @@ -292,16 +289,16 @@ LedgerEntryHandler::composeKeyFromDirectory(boost::json::object const& directory : 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))) ); - return ripple::keylet::page(ripple::keylet::ownerDir(*ownerID), subIndex).key; + return xrpl::keylet::page(xrpl::keylet::ownerDir(*ownerID), subIndex).key; } void @@ -350,76 +347,74 @@ tag_invoke(boost::json::value_to_tag, boost::json::va // check all the potential index static auto const kINDEX_FIELD_TYPE_MAP = - std::unordered_map{ - {JS(index), ripple::ltANY}, - {JS(directory), ripple::ltDIR_NODE}, - {JS(offer), ripple::ltOFFER}, - {JS(check), ripple::ltCHECK}, - {JS(escrow), ripple::ltESCROW}, - {JS(payment_channel), ripple::ltPAYCHAN}, - {JS(deposit_preauth), ripple::ltDEPOSIT_PREAUTH}, - {JS(ticket), ripple::ltTICKET}, - {JS(nft_page), ripple::ltNFTOKEN_PAGE}, - {JS(amm), ripple::ltAMM}, + 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), - 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}, + 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().c_str()) )); 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().c_str()) )); - 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().c_str()).as_object()); + auto const issuingIssue = + parseIssue(bridgeJson.at(xrpl::sfIssuingChainIssue.getJsonName().c_str()).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 0e71ca126..61b009de7 100644 --- a/src/rpc/handlers/LedgerEntry.hpp +++ b/src/rpc/handlers/LedgerEntry.hpp @@ -69,7 +69,7 @@ class LedgerEntryHandler { 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 @@ class LedgerEntryHandler { 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; }; @@ -131,10 +131,10 @@ class LedgerEntryHandler { return Error{Status{RippledError::rpcINVALID_PARAMS, "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 @@ class LedgerEntryHandler { static auto const kBRIDGE_JSON_VALIDATOR = meta::WithCustomError{ meta::IfType{meta::Section{ - {ripple::sfLockingChainDoor.getJsonName().c_str(), + {xrpl::sfLockingChainDoor.getJsonName().c_str(), validation::Required{}, validation::CustomValidators::accountBase58Validator}, - {ripple::sfIssuingChainDoor.getJsonName().c_str(), + {xrpl::sfIssuingChainDoor.getJsonName().c_str(), validation::Required{}, validation::CustomValidators::accountBase58Validator}, - {ripple::sfLockingChainIssue.getJsonName().c_str(), + {xrpl::sfLockingChainIssue.getJsonName().c_str(), validation::Required{}, validation::CustomValidators::currencyIssueValidator}, - {ripple::sfIssuingChainIssue.getJsonName().c_str(), + {xrpl::sfIssuingChainIssue.getJsonName().c_str(), validation::Required{}, validation::CustomValidators::currencyIssueValidator}, }}, @@ -566,7 +566,7 @@ class LedgerEntryHandler { 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 f957d7397..5aef779b6 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::to_string_iso(ledger->closeTime) }; }; diff --git a/src/rpc/handlers/MPTHolders.cpp b/src/rpc/handlers/MPTHolders.cpp index 5e1cba23f..04c8dd088 100644 --- a/src/rpc/handlers/MPTHolders.cpp +++ b/src/rpc/handlers/MPTHolders.cpp @@ -11,20 +11,23 @@ #include #include #include -#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 { @@ -42,17 +45,17 @@ MPTHoldersHandler::process(MPTHoldersHandler::Input const& input, Context const& auto const& lgrInfo = expectedLgrInfo.value(); auto const limit = input.limit.value_or(MPTHoldersHandler::kLIMIT_DEFAULT); - auto const mptID = ripple::uint192{input.mptID.c_str()}; + auto const mptID = xrpl::uint192{input.mptID.c_str()}; auto const issuanceLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::mptIssuance(mptID).key, lgrInfo.seq, ctx.yield + xrpl::keylet::mptIssuance(mptID).key, lgrInfo.seq, ctx.yield ); if (!issuanceLedgerObject) return Error{Status{RippledError::rpcOBJECT_NOT_FOUND, "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); @@ -63,20 +66,18 @@ 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::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..cc297a4b1 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 { diff --git a/src/rpc/handlers/NFTHistory.cpp b/src/rpc/handlers/NFTHistory.cpp index e2842cc82..91787f627 100644 --- a/src/rpc/handlers/NFTHistory.cpp +++ b/src/rpc/handlers/NFTHistory.cpp @@ -88,7 +88,7 @@ NFTHistoryHandler::process(NFTHistoryHandler::Input const& input, Context const& } auto const limit = input.limit.value_or(kLIMIT_DEFAULT); - auto const tokenID = ripple::uint256{input.nftID.c_str()}; + auto const tokenID = xrpl::uint256{input.nftID.c_str()}; auto const [txnsAndCursor, timeDiff] = util::timed([&]() { return sharedPtrBackend_->fetchNFTTransactions( @@ -135,8 +135,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::to_string_iso(lgrInfo->closeTime); + obj[JS(ledger_hash)] = xrpl::strHex(lgrInfo->hash); } } } else { @@ -150,7 +150,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/NFTInfo.cpp b/src/rpc/handlers/NFTInfo.cpp index cac3a8856..1092d181c 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"); diff --git a/src/rpc/handlers/NFTOffersCommon.cpp b/src/rpc/handlers/NFTOffersCommon.cpp index 46815b616..bd7aef4e6 100644 --- a/src/rpc/handlers/NFTOffersCommon.cpp +++ b/src/rpc/handlers/NFTOffersCommon.cpp @@ -32,10 +32,10 @@ #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 @@ -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 { @@ -88,7 +88,7 @@ NFTOffersHandlerBase::iterateOfferDirectory( return Error{Status{RippledError::rpcOBJECT_NOT_FOUND, "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}; @@ -108,12 +108,12 @@ NFTOffersHandlerBase::iterateOfferDirectory( return nullptr; }(); - if (!sle || sle->getFieldU16(ripple::sfLedgerEntryType) != ripple::ltNFTOKEN_OFFER || - tokenID != sle->getFieldH256(ripple::sfNFTokenID)) { + if (!sle || sle->getFieldU16(xrpl::sfLedgerEntryType) != xrpl::ltNFTOKEN_OFFER || + tokenID != sle->getFieldH256(xrpl::sfNFTokenID)) { return Error{Status{RippledError::rpcINVALID_PARAMS}}; } - startHint = sle->getFieldU64(ripple::sfNFTokenOfferNode); + startHint = sle->getFieldU64(xrpl::sfNFTokenOfferNode); output.offers.push_back(*sle); offers.reserve(reserve); } else { @@ -129,8 +129,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 743a04794..0bc54c654 100644 --- a/src/rpc/handlers/NFTOffersCommon.hpp +++ b/src/rpc/handlers/NFTOffersCommon.hpp @@ -39,7 +39,7 @@ class NFTOffersHandlerBase { */ struct Output { std::string nftID; - std::vector offers; + std::vector offers; // validated should be sent via framework bool validated = true; @@ -108,8 +108,8 @@ class NFTOffersHandlerBase { 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..1e959c8d1 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 { diff --git a/src/rpc/handlers/NFTsByIssuer.cpp b/src/rpc/handlers/NFTsByIssuer.cpp index f9bc9a2a1..e11017c16 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 { @@ -45,7 +45,7 @@ NFTsByIssuerHandler::process(NFTsByIssuerHandler::Input const& input, Context co auto const issuer = accountFromStringStrict(input.issuer); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject( - ripple::keylet::account(*issuer).key, lgrInfo.seq, ctx.yield + xrpl::keylet::account(*issuer).key, lgrInfo.seq, ctx.yield ); if (!accountLedgerObject) diff --git a/src/rpc/handlers/NoRippleCheck.cpp b/src/rpc/handlers/NoRippleCheck.cpp index 00a592c9b..a3da61f58 100644 --- a/src/rpc/handlers/NoRippleCheck.cpp +++ b/src/rpc/handlers/NoRippleCheck.cpp @@ -51,16 +51,16 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context auto const& lgrInfo = expectedLgrInfo.value(); auto const accountID = accountFromStringStrict(input.account); - auto const keylet = ripple::keylet::account(*accountID).key; + auto const keylet = xrpl::keylet::account(*accountID).key; auto const accountObj = sharedPtrBackend_->fetchLedgerObject(keylet, lgrInfo.seq, ctx.yield); if (!accountObj) return Error{Status{RippledError::rpcACT_NOT_FOUND}}; - 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; @@ -69,10 +69,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; @@ -90,7 +90,7 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context if (input.transactions) { auto tx = getBaseTx(*accountID, accountSeq++); tx[JS(TransactionType)] = "AccountSet"; - tx[JS(SetFlag)] = ripple::asfDefaultRipple; + tx[JS(SetFlag)] = xrpl::asfDefaultRipple; output.transactions->push_back(tx); } } @@ -104,15 +104,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; @@ -126,11 +126,11 @@ 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 {}", @@ -140,17 +140,17 @@ NoRippleCheckHandler::process(NoRippleCheckHandler::Input const& input, Context output.problems.emplace_back(problem); if (input.transactions) { - ripple::STAmount limitAmount(ownedItem.getFieldAmount( - bLow ? ripple::sfLowLimit : ripple::sfHighLimit - )); + xrpl::STAmount limitAmount( + ownedItem.getFieldAmount(bLow ? xrpl::sfLowLimit : xrpl::sfHighLimit) + ); limitAmount.setIssuer(peer); 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::none)); + tx[JS(Flags)] = bNoRipple ? xrpl::tfClearNoRipple : xrpl::tfSetNoRipple; output.transactions->push_back(tx); } @@ -162,7 +162,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/Random.cpp b/src/rpc/handlers/Random.cpp index b35400208..55b5e9699 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::crypto_prng()); - 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 653984591..cea8faf6e 100644 --- a/src/rpc/handlers/ServerInfo.hpp +++ b/src/rpc/handlers/ServerInfo.hpp @@ -77,8 +77,8 @@ class BaseServerInfoHandler { 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 @@ class BaseServerInfoHandler { 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 @@ class BaseServerInfoHandler { 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 = {}; @@ -216,7 +216,7 @@ class BaseServerInfoHandler { } 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(); @@ -248,7 +248,7 @@ class BaseServerInfoHandler { 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 cb8098863..20b6e30d9 100644 --- a/src/rpc/handlers/Subscribe.cpp +++ b/src/rpc/handlers/Subscribe.cpp @@ -231,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(); @@ -242,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 5f9c0083b..2eb4354c1 100644 --- a/src/rpc/handlers/Subscribe.hpp +++ b/src/rpc/handlers/Subscribe.hpp @@ -60,7 +60,7 @@ class SubscribeHandler { * @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 ce7ec4a27..800b6fa64 100644 --- a/src/rpc/handlers/TransactionEntry.cpp +++ b/src/rpc/handlers/TransactionEntry.cpp @@ -41,7 +41,7 @@ TransactionEntryHandler::process( output.ledgerHeader = expectedLgrInfo.value(); 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 @@ -78,11 +78,11 @@ 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)}, }; if (output.apiVersion > 1u) { - jv.as_object()[JS(close_time_iso)] = ripple::to_string_iso(output.ledgerHeader->closeTime); + jv.as_object()[JS(close_time_iso)] = xrpl::to_string_iso(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 76d662be1..498e379c4 100644 --- a/src/rpc/handlers/TransactionEntry.hpp +++ b/src/rpc/handlers/TransactionEntry.hpp @@ -35,7 +35,7 @@ class TransactionEntryHandler { * @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 8fd4e11f3..d988eccf9 100644 --- a/src/rpc/handlers/Tx.hpp +++ b/src/rpc/handlers/Tx.hpp @@ -61,7 +61,7 @@ class TxHandler { 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; @@ -171,7 +171,7 @@ class TxHandler { 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 ); } @@ -201,8 +201,8 @@ class TxHandler { 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))) @@ -296,8 +296,8 @@ class TxHandler { 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::to_string_iso(output.ledgerHeader->closeTime); } return obj; }; diff --git a/src/rpc/handlers/Unsubscribe.cpp b/src/rpc/handlers/Unsubscribe.cpp index 9fcf1a5d4..317e24a0e 100644 --- a/src/rpc/handlers/Unsubscribe.cpp +++ b/src/rpc/handlers/Unsubscribe.cpp @@ -151,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 a16b20549..1c7a67f15 100644 --- a/src/rpc/handlers/Unsubscribe.hpp +++ b/src/rpc/handlers/Unsubscribe.hpp @@ -36,7 +36,7 @@ class UnsubscribeHandler { * @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 6fc959535..c4085db75 100644 --- a/src/rpc/handlers/VaultInfo.cpp +++ b/src/rpc/handlers/VaultInfo.cpp @@ -77,14 +77,14 @@ VaultInfoHandler::process(VaultInfoHandler::Input const& input, Context const& c auto const& lgrInfo = *expectedLgrInfo; // Extract the vault keylet based on input - auto const vaultKeylet = [&]() -> std::expected { + auto const vaultKeylet = [&]() -> std::expected { if (input.owner && input.tnxSequence) { auto const accountStr = *input.owner; auto const accountID = accountFromStringStrict(accountStr); // checks that account exists { - auto const accountKeylet = ripple::keylet::account(*accountID); + auto const accountKeylet = xrpl::keylet::account(*accountID); auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject(accountKeylet.key, lgrInfo.seq, ctx.yield); @@ -92,11 +92,11 @@ VaultInfoHandler::process(VaultInfoHandler::Input const& input, Context const& c return std::unexpected{Status{RippledError::rpcENTRY_NOT_FOUND}}; } - 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}}; }(); @@ -111,29 +111,29 @@ VaultInfoHandler::process(VaultInfoHandler::Input const& input, Context const& c if (not vaultLedgerObject) return Error{Status{RippledError::rpcENTRY_NOT_FOUND, "vault object not found."}}; - ripple::STLedgerEntry const vaultSle{ - ripple::SerialIter{vaultLedgerObject->data(), vaultLedgerObject->size()}, + xrpl::STLedgerEntry const vaultSle{ + xrpl::SerialIter{vaultLedgerObject->data(), vaultLedgerObject->size()}, vaultKeylet.value().key }; - auto const issuanceKeylet = ripple::keylet::mptIssuance(vaultSle[ripple::sfShareMPTID]).key; + auto const issuanceKeylet = xrpl::keylet::mptIssuance(vaultSle[xrpl::sfShareMPTID]).key; auto const issuanceObject = sharedPtrBackend_->fetchLedgerObject(issuanceKeylet, lgrInfo.seq, ctx.yield); if (not issuanceObject) return Error{Status{RippledError::rpcENTRY_NOT_FOUND, "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::none)); response.vault.as_object()[JS(shares)] = - toBoostJson(issuanceSle.getJson(ripple::JsonOptions::none)); + toBoostJson(issuanceSle.getJson(xrpl::JsonOptions::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/LedgerUtils.cpp b/src/util/LedgerUtils.cpp index 8ce8b9623..7eaef0e26 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 4a0c7f016..365172b9c 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 @@ class LedgerTypes { constexpr auto kDELETION_BLOCKERS_COUNT = std::count_if(std::begin(kLEDGER_TYPES), std::end(kLEDGER_TYPES), kFILTER); - std::array res{}; + std::array res{}; auto it = std::begin(res); std::ranges::for_each(kLEDGER_TYPES, [&](auto const& item) { if (kFILTER(item)) { @@ -199,23 +199,23 @@ class LedgerTypes { } /** - * @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 @@ class LedgerTypes { }; /** - * @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 @@ class Sha256sum { } /** - * @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..3d998d32c 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::epoch_offset}; } } // 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 6a4c91581..31d9697ac 100644 --- a/src/util/TxUtils.cpp +++ b/src/util/TxUtils.cpp @@ -20,8 +20,8 @@ getTxTypesInLowercase() static std::unordered_set const kTYPES_KEYS_IN_LOWERCASE = []() { std::unordered_set keys; std::transform( - ripple::TxFormats::getInstance().begin(), - ripple::TxFormats::getInstance().end(), + xrpl::TxFormats::getInstance().begin(), + xrpl::TxFormats::getInstance().end(), std::inserter(keys, keys.begin()), [](auto const& pair) { return util::toLower(pair.getName()); } ); diff --git a/src/web/ProxyIpResolver.hpp b/src/web/ProxyIpResolver.hpp index fc9effbbc..4336bd30f 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/tests/common/etl/FakeDiffProvider.hpp b/tests/common/etl/FakeDiffProvider.hpp index eefb9429c..a239bfbfc 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 4f53bb897..7284fc909 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 }; @@ -91,8 +91,8 @@ createObject(etl::model::Object::ModType modType, std::string key) return { .key = binaryStringToUint256(hexStringToBinaryString(key)), .keyRaw = hexStringToBinaryString(key), - .data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{} - : *ripple::strUnHex(kOBJ_BLOB), + .data = modType == etl::model::Object::ModType::Deleted ? xrpl::Blob{} + : *xrpl::strUnHex(kOBJ_BLOB), .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" : hexStringToBinaryString(kOBJ_BLOB), @@ -120,8 +120,8 @@ createObjectWithBookBase(etl::model::Object::ModType modType, std::string key) return { .key = binaryStringToUint256(hexStringToBinaryString(key)), .keyRaw = hexStringToBinaryString(key), - .data = modType == etl::model::Object::ModType::Deleted ? ripple::Blob{} - : *ripple::strUnHex(kOBJ_BLOB), + .data = modType == etl::model::Object::ModType::Deleted ? xrpl::Blob{} + : *xrpl::strUnHex(kOBJ_BLOB), .dataRaw = modType == etl::model::Object::ModType::Deleted ? "" : hexStringToBinaryString(kOBJ_BLOB), @@ -136,8 +136,8 @@ createObjectWithTwoNFTs() { std::string const url1 = "abcd1"; std::string const url2 = "abcd2"; - ripple::Blob const uri1Blob(url1.begin(), url1.end()); - ripple::Blob const uri2Blob(url2.begin(), url2.end()); + xrpl::Blob const uri1Blob(url1.begin(), url1.end()); + xrpl::Blob const uri2Blob(url2.begin(), url2.end()); constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; constexpr auto kNFT_ID = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000"; @@ -173,13 +173,13 @@ createObjectWithMPT() constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q"; auto const account = getAccountIdWithString(kACCOUNT); - auto const mptID = ripple::makeMptID(2, getAccountIdWithString(kACCOUNT)); + auto const mptID = xrpl::makeMptID(2, getAccountIdWithString(kACCOUNT)); auto const mptokenObject = createMpTokenObject(kACCOUNT, mptID); // key is a token made up from several fields described here: // https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0033-multi-purpose-tokens#2121-mptoken-ledger-identifier constexpr auto kSPACE_KEY = 0x007F; - auto const keySha512Half = ripple::sha512Half(kSPACE_KEY, mptID, account); + auto const keySha512Half = xrpl::sha512Half(kSPACE_KEY, mptID, account); return { .key = {}, @@ -200,10 +200,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 44d9dbdfc..77b954064 100644 --- a/tests/common/util/BinaryTestObject.hpp +++ b/tests/common/util/BinaryTestObject.hpp @@ -132,7 +132,7 @@ createTxAndMetaBlobs( std::string txnStr = kDEFAULT_TXN_HEX ); -[[maybe_unused, nodiscard]] std::pair +[[maybe_unused, nodiscard]] std::pair createTxAndMeta( std::string hashStr = kDEFAULT_HASH, std::string metaStr = kDEFAULT_TXN_META, @@ -141,7 +141,7 @@ createTxAndMeta( [[maybe_unused, nodiscard]] etl::model::Transaction createTransaction( - ripple::TxType type, + xrpl::TxType type, std::string hashStr = kDEFAULT_HASH, std::string metaStr = kDEFAULT_TXN_META, std::string txnStr = kDEFAULT_TXN_HEX diff --git a/tests/common/util/MockBackend.hpp b/tests/common/util/MockBackend.hpp index 111af2bc2..d9a6d7747 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,11 +106,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) ); @@ -118,12 +118,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) @@ -132,14 +132,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) ); @@ -151,9 +151,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) ); @@ -180,7 +180,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, @@ -240,9 +240,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 5586dde11..1e4cf8779 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) @@ -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 71d1f71ad..7e3c6dd6f 100644 --- a/tests/common/util/TestObject.cpp +++ b/tests/common/util/TestObject.cpp @@ -41,38 +41,34 @@ namespace { constexpr auto kINDEX1 = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"; -ripple::Slice const kSLICE("test", 4); +xrpl::Slice const kSLICE("test", 4); } // namespace -ripple::AccountID +xrpl::AccountID getAccountIdWithString(std::string_view id) { - return util::parseBase58Wrapper(std::string(id)).value(); + return util::parseBase58Wrapper(std::string(id)).value(); } -ripple::uint256 +xrpl::uint256 getAccountKey(std::string_view id) { - return ripple::keylet::account(getAccountIdWithString(id)).key; + return xrpl::keylet::account(getAccountIdWithString(id)).key; } -ripple::uint256 -getAccountKey(ripple::AccountID const& acc) +xrpl::uint256 +getAccountKey(xrpl::AccountID const& acc) { - return ripple::keylet::account(acc).key; + return xrpl::keylet::account(acc).key; } -ripple::LedgerHeader -createLedgerHeader( - std::string_view ledgerHash, - ripple::LedgerIndex seq, - std::optional age -) +xrpl::LedgerHeader +createLedgerHeader(std::string_view ledgerHash, xrpl::LedgerIndex seq, std::optional age) { using namespace std::chrono; - auto ledgerHeader = ripple::LedgerHeader(); - ledgerHeader.hash = ripple::uint256{ledgerHash}; + auto ledgerHeader = xrpl::LedgerHeader(); + ledgerHeader.hash = xrpl::uint256{ledgerHash}; ledgerHeader.seq = seq; if (age) { @@ -80,32 +76,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.value()}).count() - kRIPPLE_EPOCH_START; - ledgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + ledgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; } return ledgerHeader; } -ripple::LedgerHeader +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{kRIPPLE_EPOCH_START}.count(); - ledgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + ledgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; return ledgerHeader; } -ripple::STObject +xrpl::STObject createLegacyFeeSettingLedgerObject( uint64_t base, uint32_t reserveInc, @@ -114,34 +110,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, @@ -154,11 +150,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 ) { @@ -166,7 +162,7 @@ createFeeSettingBlob( return lo.getSerializer().peekData(); } -ripple::STObject +xrpl::STObject createPaymentTransactionObject( std::string_view accountId1, std::string_view accountId2, @@ -175,20 +171,20 @@ createPaymentTransactionObject( uint32_t seq ) { - ripple::STObject obj(ripple::sfTransaction); - obj.setFieldU16(ripple::sfTransactionType, ripple::ttPAYMENT); - auto account = util::parseBase58Wrapper(std::string(accountId1)); - obj.setAccountID(ripple::sfAccount, account.value()); - obj.setFieldAmount(ripple::sfAmount, ripple::STAmount(amount, false)); - obj.setFieldAmount(ripple::sfFee, ripple::STAmount(fee, false)); - auto account2 = util::parseBase58Wrapper(std::string(accountId2)); - obj.setAccountID(ripple::sfDestination, account2.value()); - obj.setFieldU32(ripple::sfSequence, seq); - obj.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject obj(xrpl::sfTransaction); + obj.setFieldU16(xrpl::sfTransactionType, xrpl::ttPAYMENT); + auto account = util::parseBase58Wrapper(std::string(accountId1)); + obj.setAccountID(xrpl::sfAccount, account.value()); + obj.setFieldAmount(xrpl::sfAmount, xrpl::STAmount(amount, false)); + obj.setFieldAmount(xrpl::sfFee, xrpl::STAmount(fee, false)); + auto account2 = util::parseBase58Wrapper(std::string(accountId2)); + obj.setAccountID(xrpl::sfDestination, account2.value()); + obj.setFieldU32(xrpl::sfSequence, seq); + obj.setFieldVL(xrpl::sfSigningPubKey, kSLICE); return obj; } -ripple::STObject +xrpl::STObject createPaymentTransactionMetaObject( std::string_view accountId1, std::string_view accountId2, @@ -197,31 +193,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); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{2}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltACCOUNT_ROOT); node.emplace_back(std::move(finalFields)); metaArray.push_back(node); - ripple::STObject node2(ripple::sfModifiedNode); - node2.setFieldU16(ripple::sfLedgerEntryType, ripple::ltACCOUNT_ROOT); + xrpl::STObject node2(xrpl::sfModifiedNode); + node2.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltACCOUNT_ROOT); node2.emplace_back(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, @@ -229,23 +225,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, @@ -255,27 +251,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, @@ -287,49 +283,49 @@ createCreateOfferTransactionObject( bool reverse ) { - ripple::STObject obj(ripple::sfTransaction); - obj.setFieldU16(ripple::sfTransactionType, ripple::ttOFFER_CREATE); - auto account = util::parseBase58Wrapper(std::string(accountId)); - obj.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - obj.setFieldAmount(ripple::sfFee, amount); - obj.setFieldU32(ripple::sfSequence, seq); + xrpl::STObject obj(xrpl::sfTransaction); + obj.setFieldU16(xrpl::sfTransactionType, xrpl::ttOFFER_CREATE); + auto account = util::parseBase58Wrapper(std::string(accountId)); + obj.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + obj.setFieldAmount(xrpl::sfFee, amount); + obj.setFieldU32(xrpl::sfSequence, seq); // add amount - ripple::Issue const issue1( - ripple::Currency{currency}, - util::parseBase58Wrapper(std::string(issuer)).value() + xrpl::Issue const issue1( + xrpl::Currency{currency}, + util::parseBase58Wrapper(std::string(issuer)).value() ); if (reverse) { - obj.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(issue1, takerGets)); - obj.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(takerPays, false)); + obj.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(issue1, takerGets)); + obj.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(takerPays, false)); } else { - obj.setFieldAmount(ripple::sfTakerGets, ripple::STAmount(issue1, takerGets)); - obj.setFieldAmount(ripple::sfTakerPays, ripple::STAmount(takerPays, false)); + obj.setFieldAmount(xrpl::sfTakerGets, xrpl::STAmount(issue1, takerGets)); + obj.setFieldAmount(xrpl::sfTakerPays, xrpl::STAmount(takerPays, false)); } auto key = "test"; - ripple::Slice const slice(key, 4); - obj.setFieldVL(ripple::sfSigningPubKey, slice); + xrpl::Slice const slice(key, 4); + obj.setFieldVL(xrpl::sfSigningPubKey, slice); return obj; } -ripple::Issue +xrpl::Issue getIssue(std::string_view currency, std::string_view issuerId) { // standard currency if (currency.size() == 3) { - return ripple::Issue( - ripple::to_currency(std::string(currency)), - util::parseBase58Wrapper(std::string(issuerId)).value() + return xrpl::Issue( + xrpl::to_currency(std::string(currency)), + util::parseBase58Wrapper(std::string(issuerId)).value() ); } - return ripple::Issue( - ripple::Currency{currency}, - util::parseBase58Wrapper(std::string(issuerId)).value() + return xrpl::Issue( + xrpl::Currency{currency}, + util::parseBase58Wrapper(std::string(issuerId)).value() ); } -ripple::STObject +xrpl::STObject createMetaDataForBookChange( std::string_view currency, std::string_view issueId, @@ -341,29 +337,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); + 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.emplace_back(std::move(finalFields)); node.emplace_back(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, @@ -373,28 +369,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); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfCreatedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltOFFER); node.emplace_back(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, @@ -403,34 +399,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); + 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.emplace_back(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, @@ -441,25 +437,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, @@ -473,22 +469,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, @@ -501,106 +497,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; } @@ -608,91 +604,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; } @@ -706,50 +702,50 @@ createMintNftTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_MINT); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_MINT); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); // required field for ttNFTOKEN_MINT - tx.setFieldU32(ripple::sfNFTokenTaxon, nfTokenTaxon); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldU32(xrpl::sfNFTokenTaxon, nfTokenTaxon); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::STArray nftArray1{2}; + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::STArray nftArray1{2}; // finalFields contain new NFT while previousFields does not - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); char const* url = "testurl"; - entry.setFieldVL(ripple::sfURI, ripple::Slice(url, 7)); + entry.setFieldVL(xrpl::sfURI, xrpl::Slice(url, 7)); nftArray1.push_back(entry); - auto entry2 = ripple::STObject(ripple::sfNFToken); - entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{kINDEX1}); - entry2.setFieldVL(ripple::sfURI, ripple::Slice(url, 7)); + auto entry2 = xrpl::STObject(xrpl::sfNFToken); + entry2.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{kINDEX1}); + entry2.setFieldVL(xrpl::sfURI, xrpl::Slice(url, 7)); nftArray1.push_back(entry2); - finalFields.setFieldArray(ripple::sfNFTokens, nftArray1); + finalFields.setFieldArray(xrpl::sfNFTokens, nftArray1); nftArray1.erase(nftArray1.begin()); - ripple::STObject previousFields(ripple::sfPreviousFields); - previousFields.setFieldArray(ripple::sfNFTokens, nftArray1); + xrpl::STObject previousFields(xrpl::sfPreviousFields); + previousFields.setFieldArray(xrpl::sfNFTokens, nftArray1); node.emplace_back(std::move(finalFields)); node.emplace_back(std::move(previousFields)); 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(); @@ -769,52 +765,52 @@ createMintNftTxWithMetadataOfCreatedNode( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_MINT); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_MINT); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); // required field for ttNFTOKEN_MINT - tx.setFieldU32(ripple::sfNFTokenTaxon, nfTokenTaxon); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + tx.setFieldU32(xrpl::sfNFTokenTaxon, nfTokenTaxon); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); if (uri) - tx.setFieldVL(ripple::sfURI, ripple::Slice(uri->data(), uri->size())); + tx.setFieldVL(xrpl::sfURI, xrpl::Slice(uri->data(), uri->size())); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfCreatedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfCreatedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject newFields(ripple::sfNewFields); - ripple::STArray nftArray1{1}; + xrpl::STObject newFields(xrpl::sfNewFields); + xrpl::STArray nftArray1{1}; if (nftID) { // finalFields contain new NFT while previousFields does not - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{*nftID}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{*nftID}); if (uri) - entry.setFieldVL(ripple::sfURI, ripple::Slice(uri->data(), uri->size())); + entry.setFieldVL(xrpl::sfURI, xrpl::Slice(uri->data(), uri->size())); nftArray1.push_back(entry); } - newFields.setFieldArray(ripple::sfNFTokens, nftArray1); + newFields.setFieldArray(xrpl::sfNFTokens, nftArray1); node.emplace_back(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(); @@ -823,56 +819,56 @@ createMintNftTxWithMetadataOfCreatedNode( } data::TransactionAndMetadata -createNftModifyTxWithMetadata(std::string_view accountId, std::string_view nftID, ripple::Blob uri) +createNftModifyTxWithMetadata(std::string_view accountId, std::string_view nftID, xrpl::Blob uri) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_MODIFY); - auto account = ripple::parseBase58(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(10, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); - tx.setFieldU32(ripple::sfSequence, 100); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_MODIFY); + auto account = xrpl::parseBase58(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(10, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); + tx.setFieldU32(xrpl::sfSequence, 100); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); if (!uri.empty()) // sfURI should be absent if empty - tx.setFieldVL(ripple::sfURI, uri); + tx.setFieldVL(xrpl::sfURI, uri); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfModifiedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_PAGE); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); - ripple::STObject finalFields(ripple::sfFinalFields); - ripple::STArray nftArray1{1}; - ripple::STArray nftArray2{1}; + xrpl::STObject finalFields(xrpl::sfFinalFields); + xrpl::STArray nftArray1{1}; + xrpl::STArray nftArray2{1}; // finalFields contain new NFT while previousFields does not - auto entry = ripple::STObject(ripple::sfNFToken); - entry.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + auto entry = xrpl::STObject(xrpl::sfNFToken); + entry.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); if (!uri.empty()) - entry.setFieldVL(ripple::sfURI, uri); + entry.setFieldVL(xrpl::sfURI, uri); nftArray1.push_back(entry); - auto entry2 = ripple::STObject(ripple::sfNFToken); - entry2.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftID}); + auto entry2 = xrpl::STObject(xrpl::sfNFToken); + entry2.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftID}); char const* url = "previous"; - entry2.setFieldVL(ripple::sfURI, ripple::Slice(url, 7)); + entry2.setFieldVL(xrpl::sfURI, xrpl::Slice(url, 7)); nftArray2.push_back(entry2); - finalFields.setFieldArray(ripple::sfNFTokens, nftArray1); + finalFields.setFieldArray(xrpl::sfNFTokens, nftArray1); - ripple::STObject previousFields(ripple::sfPreviousFields); - previousFields.setFieldArray(ripple::sfNFTokens, nftArray2); + xrpl::STObject previousFields(xrpl::sfPreviousFields); + previousFields.setFieldArray(xrpl::sfNFTokens, nftArray2); node.emplace_back(std::move(finalFields)); node.emplace_back(std::move(previousFields)); 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(); @@ -884,40 +880,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)); // 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(); @@ -929,36 +925,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); - - 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 metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfModifiedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_PAGE); + + 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)); 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(); @@ -976,34 +972,34 @@ createAcceptNftBuyerOfferTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_ACCEPT_OFFER); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldH256(ripple::sfNFTokenBuyOffer, ripple::uint256{offerId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_ACCEPT_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldH256(xrpl::sfNFTokenBuyOffer, xrpl::uint256{offerId}); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta // create deletedNode with ltNFTOKEN_OFFER - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfDeletedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfDeletedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); - ripple::STObject finalFields(ripple::sfFinalFields); - finalFields.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); + xrpl::STObject finalFields(xrpl::sfFinalFields); + finalFields.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); // for buyer offer, the offer owner is the nft's new owner - finalFields.setAccountID(ripple::sfOwner, account.value()); + finalFields.setAccountID(xrpl::sfOwner, account.value()); node.emplace_back(std::move(finalFields)); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{offerId}); + node.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(); @@ -1023,79 +1019,79 @@ createAcceptNftSellerOfferTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_ACCEPT_OFFER); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldH256(ripple::sfNFTokenSellOffer, ripple::uint256{offerId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_ACCEPT_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldH256(xrpl::sfNFTokenSellOffer, xrpl::uint256{offerId}); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta // create deletedNode with ltNFTOKEN_OFFER - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - ripple::STObject node(ripple::sfDeletedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + xrpl::STObject node(xrpl::sfDeletedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); - ripple::STObject finalFields(ripple::sfFinalFields); - finalFields.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); + xrpl::STObject finalFields(xrpl::sfFinalFields); + finalFields.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); // offer owner is not the nft's new owner for seller offer, we need to create other nodes for // processing new owner - finalFields.setAccountID(ripple::sfOwner, account.value()); + finalFields.setAccountID(xrpl::sfOwner, account.value()); node.emplace_back(finalFields); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{offerId}); + node.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); + newFields.setFieldArray(xrpl::sfNFTokens, nftArray1); node2.emplace_back(std::move(newFields)); - node2.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{pageIndex}); + 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.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(); @@ -1113,40 +1109,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.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfSequence, seq); - ripple::STVector256 offers; + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_CANCEL_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfSequence, seq); + xrpl::STVector256 offers; offers.resize(nftOffers.size()); std::ranges::transform(nftOffers, offers.begin(), [&](auto const& nftId) { - return ripple::uint256{nftId.c_str()}; + 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)); 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(); @@ -1165,31 +1161,31 @@ createCreateNftOfferTxWithMetadata( ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttNFTOKEN_CREATE_OFFER); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - auto price = ripple::STAmount(offerPrice, false); - tx.setFieldAmount(ripple::sfAmount, price); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldH256(ripple::sfNFTokenID, ripple::uint256{nftId}); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttNFTOKEN_CREATE_OFFER); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + auto price = xrpl::STAmount(offerPrice, false); + tx.setFieldAmount(xrpl::sfAmount, price); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldH256(xrpl::sfNFTokenID, xrpl::uint256{nftId}); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); // meta // create createdNode with LedgerIndex - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; - ripple::STObject node(ripple::sfCreatedNode); - node.setFieldU16(ripple::sfLedgerEntryType, ripple::ltNFTOKEN_OFFER); - node.setFieldH256(ripple::sfLedgerIndex, ripple::uint256{offerId}); + xrpl::STObject node(xrpl::sfCreatedNode); + node.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltNFTOKEN_OFFER); + node.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{offerId}); metaArray.push_back(node); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 0); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 0); data::TransactionAndMetadata ret; ret.transaction = tx.getSerializer().peekData(); @@ -1204,43 +1200,43 @@ createOracleSetTxWithMetadata( uint32_t fee, uint32_t docId, std::uint32_t lastUpdateTime, - ripple::STArray priceDataSeries, + xrpl::STArray priceDataSeries, std::string_view oracleIndex, bool created, std::string_view previousTxnId ) { // tx - ripple::STObject tx(ripple::sfTransaction); - tx.setFieldU16(ripple::sfTransactionType, ripple::ttORACLE_SET); - auto account = util::parseBase58Wrapper(std::string(accountId)); - tx.setAccountID(ripple::sfAccount, account.value()); - auto amount = ripple::STAmount(fee, false); - tx.setFieldAmount(ripple::sfFee, amount); - tx.setFieldU32(ripple::sfLastUpdateTime, lastUpdateTime); - tx.setFieldU32(ripple::sfOracleDocumentID, docId); - tx.setFieldU32(ripple::sfSequence, seq); - tx.setFieldVL(ripple::sfSigningPubKey, kSLICE); - tx.setFieldArray(ripple::sfPriceDataSeries, priceDataSeries); + xrpl::STObject tx(xrpl::sfTransaction); + tx.setFieldU16(xrpl::sfTransactionType, xrpl::ttORACLE_SET); + auto account = util::parseBase58Wrapper(std::string(accountId)); + tx.setAccountID(xrpl::sfAccount, account.value()); + auto amount = xrpl::STAmount(fee, false); + tx.setFieldAmount(xrpl::sfFee, amount); + tx.setFieldU32(xrpl::sfLastUpdateTime, lastUpdateTime); + tx.setFieldU32(xrpl::sfOracleDocumentID, docId); + tx.setFieldU32(xrpl::sfSequence, seq); + tx.setFieldVL(xrpl::sfSigningPubKey, kSLICE); + tx.setFieldArray(xrpl::sfPriceDataSeries, priceDataSeries); // meta - ripple::STObject metaObj(ripple::sfTransactionMetaData); - ripple::STArray metaArray{1}; - - 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); + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + xrpl::STArray metaArray{1}; + + 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.emplace_back(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(); @@ -1248,28 +1244,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, @@ -1282,29 +1278,27 @@ 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)} - ); - ripple::Issue const issue1( - ripple::Currency{lpTokenBalanceIssueCurrency}, - util::parseBase58Wrapper(std::string(accountId)).value() + xrpl::sfAsset2, xrpl::STIssue{xrpl::sfAsset2, getIssue(asset2Currency, asset2Issuer)} ); - amm.setFieldAmount( - ripple::sfLPTokenBalance, ripple::STAmount(issue1, lpTokenBalanceIssueAmount) + xrpl::Issue const issue1( + xrpl::Currency{lpTokenBalanceIssueCurrency}, + util::parseBase58Wrapper(std::string(accountId)).value() ); - 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, @@ -1313,34 +1307,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); + 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; 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, @@ -1350,36 +1344,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); + 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; 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, @@ -1388,100 +1382,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); + 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; 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::to_currency(std::string(assetCurrency)), + xrpl::to_currency(std::string(asset2Currency)) ); } -ripple::STObject +xrpl::STObject createMptIssuanceObject( std::string_view accountId, std::uint32_t seq, @@ -1496,105 +1488,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); - - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::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 const tx = createMPTIssuanceCreateTx(accountId, fee, seq); + + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 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{}); + xrpl::STObject createdNode(xrpl::sfCreatedNode); + createdNode.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN_ISSUANCE); + createdNode.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{}); createdNode.emplace_back(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(); @@ -1602,28 +1594,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; } @@ -1631,30 +1623,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{}); + xrpl::STObject modifiedNode(xrpl::sfModifiedNode); + modifiedNode.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltMPTOKEN); + modifiedNode.setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256{}); modifiedNode.emplace_back(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(); @@ -1662,113 +1654,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, @@ -1777,145 +1769,143 @@ createCredentialObject( std::optional expiration ) { - ripple::STObject credObj(ripple::sfCredential); - credObj.setFieldU16(ripple::sfLedgerEntryType, ripple::ltCREDENTIAL); - credObj.setFieldVL(ripple::sfCredentialType, ripple::Blob{credType.begin(), credType.end()}); - credObj.setAccountID(ripple::sfSubject, getAccountIdWithString(acc1)); - credObj.setAccountID(ripple::sfIssuer, getAccountIdWithString(acc2)); + xrpl::STObject credObj(xrpl::sfCredential); + credObj.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltCREDENTIAL); + credObj.setFieldVL(xrpl::sfCredentialType, xrpl::Blob{credType.begin(), credType.end()}); + credObj.setAccountID(xrpl::sfSubject, getAccountIdWithString(acc1)); + credObj.setAccountID(xrpl::sfIssuer, getAccountIdWithString(acc2)); if (expiration.has_value()) - credObj.setFieldU32(ripple::sfExpiration, expiration.value()); + credObj.setFieldU32(xrpl::sfExpiration, expiration.value()); if (accept) { - credObj.setFieldU32(ripple::sfFlags, ripple::lsfAccepted); + credObj.setFieldU32(xrpl::sfFlags, xrpl::lsfAccepted); } else { - credObj.setFieldU32(ripple::sfFlags, 0); + credObj.setFieldU32(xrpl::sfFlags, 0); } - credObj.setFieldU64(ripple::sfSubjectNode, 0); - credObj.setFieldU64(ripple::sfIssuerNode, 0); - credObj.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{}); - credObj.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0); + credObj.setFieldU64(xrpl::sfSubjectNode, 0); + credObj.setFieldU64(xrpl::sfIssuerNode, 0); + credObj.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{}); + credObj.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 0); return credObj; } -ripple::STArray +xrpl::STArray createAuthCredentialArray( std::vector issuer, std::vector credType ) { - ripple::STArray arr; + xrpl::STArray arr; ASSERT(issuer.size() == credType.size(), "issuer and credtype vector must be same length"); for (std::size_t i = 0; i < issuer.size(); ++i) { - auto credential = ripple::STObject::makeInnerObject(ripple::sfCredential); - credential.setAccountID(ripple::sfIssuer, getAccountIdWithString(issuer[i])); + auto credential = xrpl::STObject::makeInnerObject(xrpl::sfCredential); + credential.setAccountID(xrpl::sfIssuer, getAccountIdWithString(issuer[i])); credential.setFieldVL( - ripple::sfCredentialType, ripple::strUnHex(std::string(credType[i])).value() + xrpl::sfCredentialType, xrpl::strUnHex(std::string(credType[i])).value() ); arr.push_back(credential); } return arr; } -ripple::STObject +xrpl::STObject createVault( std::string_view owner, std::string_view account, - ripple::LedgerIndex seq, + xrpl::LedgerIndex seq, std::string_view assetCurrency, std::string_view assetIssuer, - ripple::uint192 shareMPTID, + xrpl::uint192 shareMPTID, uint64_t ownerNode, - ripple::uint256 previousTxId, + xrpl::uint256 previousTxId, uint32_t previousTxSeq ) { - auto vault = ripple::STObject(ripple::sfLedgerEntry); - vault.setAccountID(ripple::sfOwner, getAccountIdWithString(owner)); - vault.setAccountID(ripple::sfAccount, getAccountIdWithString(account)); - vault.setFieldU32(ripple::sfSequence, seq); - vault.setFieldU64(ripple::sfOwnerNode, ownerNode); - vault.setFieldH256(ripple::sfPreviousTxnID, previousTxId); - vault.setFieldU32(ripple::sfPreviousTxnLgrSeq, previousTxSeq); + auto vault = xrpl::STObject(xrpl::sfLedgerEntry); + vault.setAccountID(xrpl::sfOwner, getAccountIdWithString(owner)); + vault.setAccountID(xrpl::sfAccount, getAccountIdWithString(account)); + vault.setFieldU32(xrpl::sfSequence, seq); + vault.setFieldU64(xrpl::sfOwnerNode, ownerNode); + vault.setFieldH256(xrpl::sfPreviousTxnID, previousTxId); + vault.setFieldU32(xrpl::sfPreviousTxnLgrSeq, previousTxSeq); vault.setFieldIssue( - ripple::sfAsset, ripple::STIssue{ripple::sfAsset, getIssue(assetCurrency, assetIssuer)} - ); - vault[ripple::sfShareMPTID] = shareMPTID; - vault.setFieldNumber(ripple::sfAssetsTotal, ripple::STNumber{ripple::sfAssetsTotal, 300}); - vault.setFieldNumber( - ripple::sfAssetsAvailable, ripple::STNumber{ripple::sfAssetsAvailable, 300} + xrpl::sfAsset, xrpl::STIssue{xrpl::sfAsset, getIssue(assetCurrency, assetIssuer)} ); - 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 2309c6fd3..662bca699 100644 --- a/tests/integration/data/cassandra/BackendTests.cpp +++ b/tests/integration/data/cassandra/BackendTests.cpp @@ -148,8 +148,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( @@ -387,7 +386,7 @@ TEST_F(BackendCassandraTest, Basic) std::string const nftTxnHashHex = "6C7F69A6D25A13AC4A2E9145999F45D4674F939900017A96885FDC2757" "E9284E"; - ripple::uint256 nftID; + xrpl::uint256 nftID; EXPECT_TRUE(nftID.parseHex( "000800006203F49C21D5D6E022CB16DE3538F248662" "FC73CEF7FF5C60000002C" @@ -398,7 +397,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); @@ -410,9 +409,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); @@ -420,11 +421,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; @@ -480,7 +485,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); @@ -495,7 +500,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); @@ -540,7 +545,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); @@ -591,7 +596,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); @@ -609,13 +614,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; @@ -630,12 +635,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; @@ -644,8 +649,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 +793,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 +838,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 +851,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 +861,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 +892,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 +932,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 +983,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 +1063,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 +1084,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 +1112,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 +1130,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 +1162,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 +1181,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 +1199,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 +1234,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); @@ -1286,7 +1290,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()) { @@ -1329,9 +1333,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)) @@ -1340,7 +1344,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); @@ -1424,8 +1428,7 @@ TEST_F(CacheBackendCassandraTest, CacheFetchLedgerBySeq) { runSpawn([&](boost::asio::yield_context yield) { auto rawHeaderBlob = hexStringToBinaryString(kRAWHEADER); - ripple::LedgerHeader const lgrInfo = - util::deserializeHeader(ripple::makeSlice(rawHeaderBlob)); + xrpl::LedgerHeader const lgrInfo = util::deserializeHeader(xrpl::makeSlice(rawHeaderBlob)); backend_->writeLedger(lgrInfo, std::move(rawHeaderBlob)); auto const testLedgerSeq = lgrInfo.seq; diff --git a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp index b1d291eac..31c6d643e 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp +++ b/tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp @@ -232,26 +232,26 @@ 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") ); EXPECT_TRUE(txType.has_value()); EXPECT_EQ(txType.value(), "OracleSet"); txType = getTxType( - ripple::uint256("35DBFB1A88DE17EBD2BCE37F6E1FD6D3B9887C92B7933ED2FCF2A84E9138B7CA") + xrpl::uint256("35DBFB1A88DE17EBD2BCE37F6E1FD6D3B9887C92B7933ED2FCF2A84E9138B7CA") ); EXPECT_TRUE(txType.has_value()); EXPECT_EQ(txType.value(), "Payment"); txType = getTxType( - ripple::uint256("FCACE9D00625FA3BCC5316078324EA153EC8551243AC1701D496CC1CA2B8A474") + xrpl::uint256("FCACE9D00625FA3BCC5316078324EA153EC8551243AC1701D496CC1CA2B8A474") ); EXPECT_TRUE(txType.has_value()); EXPECT_EQ(txType.value(), "AMMCreate"); @@ -337,15 +337,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 3f353846c..81c7c8008 100644 --- a/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp +++ b/tests/integration/migration/cassandra/CassandraMigrationTestBackend.hpp @@ -184,7 +184,7 @@ class CassandraMigrationTestBackend : public migration::cassandra::CassandraMigr * @param ctx The boost asio context * @return The account hash if found, otherwise std::nullopt */ - std::optional + std::optional fetchAccountHashViaSequence(std::uint64_t sequence, boost::asio::yield_context ctx) { static auto kFETCH_ACCOUNT_HASH = [this]() { @@ -207,7 +207,7 @@ class CassandraMigrationTestBackend : public migration::cassandra::CassandraMigr 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..6081f40c0 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::none); auto const txType = json["TransactionType"].asString(); backend->writeTxIndexExample(uint256ToString(tx.getTransactionID()), txType); } diff --git a/tests/unit/data/AmendmentCenterTests.cpp b/tests/unit/data/AmendmentCenterTests.cpp index 5dd1265a0..bdaf35b5a 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 9d5d25031..180d47a1d 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, kMAX_SEQ, _)) @@ -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, kMAX_SEQ, _)) @@ -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 69d19f59e..a6704fa93 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/impl/LedgerCacheFileTests.cpp b/tests/unit/data/impl/LedgerCacheFileTests.cpp index 60f3b26b2..aadd6148f 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 = kLATEST_SEQUENCE; for (size_t i = 0; i < mapSize; ++i) { - ripple::uint256 key; - std::memset(key.data(), static_cast(i), ripple::uint256::size()); + xrpl::uint256 key; + std::memset(key.data(), static_cast(i), xrpl::uint256::size()); data::LedgerCache::CacheEntry entry; entry.seq = static_cast(1000 + i); @@ -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/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 098b45812..ea967b698 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 kACCOUNT_ROOTS = { - ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, - ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, - ripple::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, - ripple::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, - ripple::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, - ripple::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, - ripple::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, - ripple::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, - ripple::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, +std::vector const kACCOUNT_ROOTS = { + xrpl::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, + xrpl::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, + xrpl::uint256{"3B3A84E850C724E914293271785A31D0BFC8B9DD1B6332E527B149AD72E80E18"}, + xrpl::uint256{"4EC98C5C3F34C44409BC058998CBD64F6AED3FF6C0CAAEC15F7F42DF14EE9F04"}, + xrpl::uint256{"58CEC9F17733EA7BA68C88E6179B8F207D001EE04D4E0366F958CC04FF6AB834"}, + xrpl::uint256{"64FB1712146BA604C274CC335C5DE7ADFE52D1F8C3E904A9F9765FE8158A3E01"}, + xrpl::uint256{"700BE23B1D9EE3E6BF52543D05843D5345B85D9EDB3D33BBD6B4C3A13C54B38E"}, + xrpl::uint256{"82C297FCBCD634C4424F263D17480AA2F13975DF5846A5BB57246022CEEBE441"}, + xrpl::uint256{"A2AA4C212DC2CA2C49BF58805F7C63363BC981018A01AC9609A7CBAB2A02CEDF"}, }; struct CursorFromAccountProviderTests : util::prometheus::WithPrometheus, MockBackendTestNaggy {}; diff --git a/tests/unit/etl/CursorFromDiffProviderTests.cpp b/tests/unit/etl/CursorFromDiffProviderTests.cpp index c0b473b2b..e1c09f20a 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 kDIFFS_FOR_SEQ = { - {.key = ripple::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, + {.key = xrpl::uint256{"05E1EAC2574BE082B00B16F907CE32E6058DEB8F9E81CF34A00E80A5D71FA4FE"}, .blob = Blob{}}, // This object is removed in Seq while it exists in Seq-1 - {.key = ripple::uint256{"110872C7196EE6EF7032952F1852B11BB461A96FF2D7E06A8003B4BB30FD130B"}, + {.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 kDIFFS_FOR_SEQ_MINUS1 = { - {.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 abf6eb266..8999b692a 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/ExtractionTests.cpp b/tests/unit/etl/ExtractionTests.cpp index d24a36f7d..e6da9cd4f 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::kLAST_KEY)); EXPECT_EQ(res.successor, uint256ToString(data::kFIRST_KEY)); 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::kLAST_KEY)); EXPECT_EQ(obj.successor, uint256ToString(data::kFIRST_KEY)); 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 34d9cab5c..c2693be60 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 53ca08840..80382577e 100644 --- a/tests/unit/etl/LedgerPublisherTests.cpp +++ b/tests/unit/etl/LedgerPublisherTests.cpp @@ -82,7 +82,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{})); @@ -128,7 +128,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; @@ -169,13 +169,13 @@ TEST_F(ETLLedgerPublisherTest, PublishLedgerHeaderCloseTimeGreaterThanNow) auto const nowPlus10 = system_clock::now() + seconds(10); auto const closeTime = duration_cast(nowPlus10.time_since_epoch()).count() - kRIPPLE_EPOCH_START; - dummyLedgerHeader.closeTime = ripple::NetClock::time_point{seconds{closeTime}}; + dummyLedgerHeader.closeTime = xrpl::NetClock::time_point{seconds{closeTime}}; backend_->setRange(kSEQ - 1, kSEQ); auto publisher = impl::LedgerPublisher(ctx, backend_, mockSubscriptionManagerPtr, dummyState); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kSEQ, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kSEQ, _)) .WillOnce(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); TransactionAndMetadata t1; @@ -251,7 +251,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 @@ -328,9 +328,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 2950577a4..c12758066 100644 --- a/tests/unit/etl/NFTHelpersTests.cpp +++ b/tests/unit/etl/NFTHelpersTests.cpp @@ -41,12 +41,12 @@ struct NFTHelpersTest : virtual public ::testing::Test { 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,33 +55,33 @@ struct NFTHelpersTest : virtual public ::testing::Test { static void verifyNFTsData( NFTsData const& data, - ripple::STTx const& sttx, - ripple::TxMeta const& txMeta, + xrpl::STTx const& sttx, + xrpl::TxMeta const& txMeta, std::string_view nftId, std::optional const& owner ) { - EXPECT_EQ(data.tokenID, ripple::uint256(nftId)); + EXPECT_EQ(data.tokenID, xrpl::uint256(nftId)); EXPECT_EQ(data.ledgerSequence, txMeta.getLgrSeq()); EXPECT_EQ(data.transactionIndex, txMeta.getIndex()); if (owner) EXPECT_EQ(data.owner, getAccountIdWithString(*owner)); - if (sttx.getTxnType() == ripple::ttNFTOKEN_MINT || - sttx.getTxnType() == ripple::ttNFTOKEN_MODIFY) { + if (sttx.getTxnType() == xrpl::ttNFTOKEN_MINT || + sttx.getTxnType() == xrpl::ttNFTOKEN_MODIFY) { EXPECT_TRUE(data.uri.has_value()); - EXPECT_EQ(*data.uri, sttx.getFieldVL(ripple::sfURI)); + EXPECT_EQ(*data.uri, sttx.getFieldVL(xrpl::sfURI)); } else { EXPECT_FALSE(data.uri.has_value()); } - if (sttx.getTxnType() == ripple::ttNFTOKEN_BURN) { + if (sttx.getTxnType() == xrpl::ttNFTOKEN_BURN) { EXPECT_TRUE(data.isBurned); } else { EXPECT_FALSE(data.isBurned); } - if (sttx.getTxnType() == ripple::ttNFTOKEN_MODIFY) { + if (sttx.getTxnType() == xrpl::ttNFTOKEN_MODIFY) { EXPECT_TRUE(data.onlyUriChanged); } else { EXPECT_FALSE(data.onlyUriChanged); @@ -91,16 +91,16 @@ struct NFTHelpersTest : virtual public ::testing::Test { TEST_F(NFTHelpersTest, NFTDataFromFailedTx) { - auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{}); + auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, xrpl::Blob{}); // Inject a failed result - ripple::SerialIter sitMeta(ripple::makeSlice(tx.metadata)); - ripple::STObject objMeta(sitMeta, ripple::sfMetadata); - objMeta.setFieldU8(ripple::sfTransactionResult, ripple::tecINCOMPLETE); + xrpl::SerialIter sitMeta(xrpl::makeSlice(tx.metadata)); + xrpl::STObject objMeta(sitMeta, xrpl::sfMetadata); + objMeta.setFieldU8(xrpl::sfTransactionResult, xrpl::tecINCOMPLETE); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, objMeta.getSerializer().peekData()); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, objMeta.getSerializer().peekData()); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ); EXPECT_EQ(nftTxs.size(), 0); @@ -116,17 +116,17 @@ TEST_F(NFTHelpersTest, NotNFTTx) 1, 4321u, createPriceDataSeries( - {createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)} + {createOraclePriceData(1e3, xrpl::to_currency("EUR"), xrpl::to_currency("XRP"), 2)} ), kPAGE_INDEX, false, kTX ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ); EXPECT_EQ(nftTxs.size(), 0); @@ -136,15 +136,14 @@ TEST_F(NFTHelpersTest, NotNFTTx) TEST_F(NFTHelpersTest, NFTModifyWithURI) { std::string const uri("1234567890A"); - ripple::Blob const uriBlob(uri.begin(), uri.end()); + xrpl::Blob const uriBlob(uri.begin(), uri.end()); auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, uriBlob); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ); EXPECT_EQ(nftTxs.size(), 1); @@ -154,10 +153,9 @@ TEST_F(NFTHelpersTest, NFTModifyWithURI) TEST_F(NFTHelpersTest, NFTModifyWithoutURI) { - auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{}); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, xrpl::Blob{}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -168,10 +166,9 @@ TEST_F(NFTHelpersTest, NFTModifyWithoutURI) TEST_F(NFTHelpersTest, NFTMintFromModifiedNode) { auto const tx = createMintNftTxWithMetadata(kACCOUNT, 1, 20, 1, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -185,11 +182,11 @@ TEST_F(NFTHelpersTest, NFTMintCantFindNewNFT) auto const tx = createMintNftTxWithMetadataOfCreatedNode( kACCOUNT, 1, 20, 1, std::nullopt, std::nullopt, kPAGE_INDEX ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -198,12 +195,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, kNFT_ID, uri, kPAGE_INDEX); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); @@ -217,9 +213,8 @@ TEST_F(NFTHelpersTest, NFTMintWithoutUriField) auto const tx = createMintNftTxWithMetadataOfCreatedNode( kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); @@ -233,12 +228,12 @@ TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) auto const tx = createMintNftTxWithMetadataOfCreatedNode( kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX ); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -247,10 +242,9 @@ TEST_F(NFTHelpersTest, NFTMintZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode) { auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[1].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[1].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -261,12 +255,12 @@ TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode) TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) { auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -275,11 +269,10 @@ TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode) TEST_F(NFTHelpersTest, NFTBurnFromModifiedNode) { auto const tx = createNftBurnTxWithMetadataOfModifiedNode(kACCOUNT, kNFT_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -292,10 +285,9 @@ TEST_F(NFTHelpersTest, NFTCancelOffer) auto const tx = createCancelNftOffersTxWithMetadata( kACCOUNT, 1, 2, std::vector{kNFT_ID, kNFT_ID2} ); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 2); @@ -309,9 +301,8 @@ TEST_F(NFTHelpersTest, NFTCancelOfferContainsDuplicateNFTs) auto const tx = createCancelNftOffersTxWithMetadata( kACCOUNT, 1, 2, std::vector{kNFT_ID2, kNFT_ID, kNFT_ID2, kNFT_ID} ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 2); @@ -326,13 +317,13 @@ TEST_F(NFTHelpersTest, UniqueNFTDatas) auto const generateNFTsData = [](char const* nftID, std::uint32_t txIndex) { auto const tx = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 50, nftID, 123, kOFFER1); - ripple::SerialIter s{tx.metadata.data(), tx.metadata.size()}; - ripple::STObject meta{s, ripple::sfMetadata}; - meta.setFieldU32(ripple::sfTransactionIndex, txIndex); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, meta.getSerializer().peekData()); + xrpl::SerialIter s{tx.metadata.data(), tx.metadata.size()}; + xrpl::STObject meta{s, xrpl::sfMetadata}; + meta.setFieldU32(xrpl::sfTransactionIndex, txIndex); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, meta.getSerializer().peekData()); auto const account = getAccountIdWithString(kACCOUNT); - return NFTsData{ripple::uint256(nftID), account, ripple::Blob{}, txMeta}; + return NFTsData{xrpl::uint256(nftID), account, xrpl::Blob{}, txMeta}; }; nftDatas.push_back(generateNFTsData(kNFT_ID, 3)); @@ -350,16 +341,15 @@ TEST_F(NFTHelpersTest, UniqueNFTDatas) EXPECT_EQ(uniqueNFTDatas[1].ledgerSequence, 1); EXPECT_EQ(uniqueNFTDatas[0].transactionIndex, 5); EXPECT_EQ(uniqueNFTDatas[1].transactionIndex, 3); - EXPECT_EQ(uniqueNFTDatas[0].tokenID, ripple::uint256(kNFT_ID2)); - EXPECT_EQ(uniqueNFTDatas[1].tokenID, ripple::uint256(kNFT_ID)); + EXPECT_EQ(uniqueNFTDatas[0].tokenID, xrpl::uint256(kNFT_ID2)); + EXPECT_EQ(uniqueNFTDatas[1].tokenID, xrpl::uint256(kNFT_ID)); } TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) { auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -372,13 +362,13 @@ TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer) TEST_F(NFTHelpersTest, NFTAcceptBuyerOfferCheckOfferIDFail) { auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); // inject a different offer id - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -389,9 +379,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromCreatedNode) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -405,9 +394,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromModifiedNode) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, false ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -422,11 +410,11 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferCheckFail) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true ); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 1, tx.metadata); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -437,13 +425,13 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferNotInMeta) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true ); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); // inject a different offer id - txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX)); + txMeta.getNodes()[0].setFieldH256(xrpl::sfLedgerIndex, xrpl::uint256(kPAGE_INDEX)); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -454,12 +442,12 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferZeroMetaNode) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true ); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); txMeta.getNodes().clear(); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -470,16 +458,16 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) auto const tx = createAcceptNftSellerOfferTxWithMetadata( kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true ); - ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata); + xrpl::TxMeta txMeta(xrpl::uint256(kTX), 1, tx.metadata); // The first node is offer, the second is nft page. Change the offer id to something else txMeta.getNodes()[0] - .getField(ripple::sfFinalFields) - .downcast() - .setFieldH256(ripple::sfNFTokenID, ripple::uint256(kNFT_ID2)); + .getField(xrpl::sfFinalFields) + .downcast() + .setFieldH256(xrpl::sfNFTokenID, xrpl::uint256(kNFT_ID2)); EXPECT_THROW( etl::getNFTDataFromTx( - txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}) + txMeta, xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}) ), std::runtime_error ); @@ -488,9 +476,8 @@ TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData) TEST_F(NFTHelpersTest, NFTCreateOffer) { auto const tx = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, 1, kOFFER_ID); - ripple::TxMeta const txMeta(ripple::uint256(kTX), 5, tx.metadata); - auto const sttx = - ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}); + xrpl::TxMeta const txMeta(xrpl::uint256(kTX), 5, tx.metadata); + auto const sttx = xrpl::STTx(xrpl::SerialIter{tx.transaction.data(), tx.transaction.size()}); auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx); EXPECT_EQ(nftTxs.size(), 1); @@ -502,8 +489,8 @@ TEST_F(NFTHelpersTest, NFTDataFromLedgerObject) { std::string const url1 = "abcd1"; std::string const url2 = "abcd2"; - ripple::Blob const uri1Blob(url1.begin(), url1.end()); - ripple::Blob const uri2Blob(url2.begin(), url2.end()); + xrpl::Blob const uri1Blob(url1.begin(), url1.end()); + xrpl::Blob const uri2Blob(url2.begin(), url2.end()); auto const account = getAccountIdWithString(kACCOUNT); auto const nftPage = createNftTokenPage({{kNFT_ID, url1}, {kNFT_ID2, url2}}, std::nullopt); @@ -522,14 +509,14 @@ TEST_F(NFTHelpersTest, NFTDataFromLedgerObject) auto const nftDatas = etl::getNFTDataFromObj(kSEQ, key, blob); EXPECT_EQ(nftDatas.size(), 2); - EXPECT_EQ(nftDatas[0].tokenID, ripple::uint256(kNFT_ID)); + EXPECT_EQ(nftDatas[0].tokenID, xrpl::uint256(kNFT_ID)); EXPECT_EQ(*(nftDatas[0].uri), uri1Blob); EXPECT_FALSE(nftDatas[0].onlyUriChanged); EXPECT_EQ(nftDatas[0].owner, account); EXPECT_EQ(nftDatas[0].ledgerSequence, kSEQ); EXPECT_FALSE(nftDatas[0].isBurned); - EXPECT_EQ(nftDatas[1].tokenID, ripple::uint256(kNFT_ID2)); + EXPECT_EQ(nftDatas[1].tokenID, xrpl::uint256(kNFT_ID2)); EXPECT_EQ(*(nftDatas[1].uri), uri2Blob); EXPECT_FALSE(nftDatas[1].onlyUriChanged); EXPECT_EQ(nftDatas[1].owner, account); diff --git a/tests/unit/etl/RegistryTests.cpp b/tests/unit/etl/RegistryTests.cpp index 7143f953a..4828b4fc1 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 @@ struct RegistryTest : util::prometheus::WithPrometheus { 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 b3a6996ec..47071a997 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 e11a6bc12..e63233d47 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(kLEDGER_HASH, kSEQ); diff --git a/tests/unit/etl/ext/MPTTests.cpp b/tests/unit/etl/ext/MPTTests.cpp index 39c8859e7..4ec4cf580 100644 --- a/tests/unit/etl/ext/MPTTests.cpp +++ b/tests/unit/etl/ext/MPTTests.cpp @@ -59,12 +59,12 @@ createTestData() { auto transactions = std::vector{ util::createTransaction( - ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE + xrpl::TxType::ttMPTOKEN_ISSUANCE_CREATE ), // not AUTHORIZE so will not be written - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttAMM_CREATE), // not MPT - will be filtered + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), + util::createTransaction(xrpl::TxType::ttAMM_CREATE), // not MPT - will be filtered util::createTransaction( - ripple::TxType::ttMPTOKEN_ISSUANCE_CREATE + xrpl::TxType::ttMPTOKEN_ISSUANCE_CREATE ), // not unique - will be filtered }; @@ -84,9 +84,9 @@ auto createMultipleHoldersTestData() { auto transactions = std::vector{ - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH2, kTXN_META, kTXN_HEX), - util::createTransaction(ripple::TxType::ttMPTOKEN_AUTHORIZE, kHASH3, kTXN_META, kTXN_HEX) + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH, kTXN_META, kTXN_HEX), + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH2, kTXN_META, kTXN_HEX), + util::createTransaction(xrpl::TxType::ttMPTOKEN_AUTHORIZE, kHASH3, kTXN_META, kTXN_HEX) }; auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); diff --git a/tests/unit/etl/ext/NFTTests.cpp b/tests/unit/etl/ext/NFTTests.cpp index 15308d0ef..5fb8fa3c9 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, kTXN_META2, kTXN_HEX2), - util::createTransaction(ripple::TxType::ttAMM_CREATE), // not NFT - will be filtered - util::createTransaction(ripple::TxType::ttNFTOKEN_BURN), // not unique - will be filtered + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN, kHASH2, kTXN_META2, kTXN_HEX2), + util::createTransaction(xrpl::TxType::ttAMM_CREATE), // not NFT - will be filtered + util::createTransaction(xrpl::TxType::ttNFTOKEN_BURN), // not unique - will be filtered }; auto const header = createLedgerHeader(kLEDGER_HASH, kSEQ); diff --git a/tests/unit/etl/ext/SuccessorTests.cpp b/tests/unit/etl/ext/SuccessorTests.cpp index 2b12145c4..9bf286ef5 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(kLEDGER_HASH, 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); @@ -456,7 +456,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndNoSuccessor ); for (auto const& key : data.edgeKeys.value()) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*xrpl::uint256::fromVoidChecked(key), kSEQ)) .InSequence(inSeq) .WillOnce(testing::Return(std::nullopt)); } @@ -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); @@ -503,7 +503,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsButNotBookDirAndSuccessorsF ); for (auto const& key : data.edgeKeys.value()) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*xrpl::uint256::fromVoidChecked(key), kSEQ)) .InSequence(inSeq) .WillOnce(testing::Return(data::LedgerObject{.key = firstKey, .blob = {}})); EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSEQ, uint256ToString(firstKey))); @@ -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); @@ -563,7 +563,7 @@ TEST_F(SuccessorExtTests, OnInitialDataWithSuccessorsAndBookDirAndSuccessorsForE ); // Called once because firstKey returned repeatedly above for (auto const& key : data.edgeKeys.value()) { - EXPECT_CALL(cache_, getSuccessor(*ripple::uint256::fromVoidChecked(key), kSEQ)) + EXPECT_CALL(cache_, getSuccessor(*xrpl::uint256::fromVoidChecked(key), kSEQ)) .InSequence(inSeq) .WillOnce(testing::Return(data::LedgerObject{.key = firstKey, .blob = {'1'}})); EXPECT_CALL(*backend_, writeSuccessor(auto{key}, kSEQ, uint256ToString(firstKey))) @@ -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 7731d937b..17ea3515c 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(kLEDGER_HASH, 32); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STObject const metaObj = - createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + xrpl::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); diff --git a/tests/unit/feed/LedgerFeedTests.cpp b/tests/unit/feed/LedgerFeedTests.cpp index f389e74d0..eaf980587 100644 --- a/tests/unit/feed/LedgerFeedTests.cpp +++ b/tests/unit/feed/LedgerFeedTests.cpp @@ -71,7 +71,7 @@ TEST_F(FeedLedgerTest, SubPub) // test publish EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kLEDGER_PUB))).Times(1); auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; testFeedPtr->pub(ledgerHeader2, fee2, "10-31", 8, networkID); @@ -123,7 +123,7 @@ TEST_F(FeedLedgerTest, AutoDisconnect) EXPECT_EQ(testFeedPtr->count(), 0); auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; // no error testFeedPtr->pub(ledgerHeader2, fee2, "10-31", 8, networkID); diff --git a/tests/unit/feed/SubscriptionManagerTests.cpp b/tests/unit/feed/SubscriptionManagerTests.cpp index 3c7f57061..65e5bcd5b 100644 --- a/tests/unit/feed/SubscriptionManagerTests.cpp +++ b/tests/unit/feed/SubscriptionManagerTests.cpp @@ -151,7 +151,7 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber) subscriptionManagerPtr_->subProposedAccount(account, session1); subscriptionManagerPtr_->subProposedAccount(account, session2); auto const issue1 = getIssue(kCURRENCY, kISSUER); - ripple::Book const book{ripple::xrpIssue(), issue1, std::nullopt}; + xrpl::Book const book{xrpl::xrpIssue(), issue1, std::nullopt}; subscriptionManagerPtr_->subBook(book, session1); subscriptionManagerPtr_->subBook(book, session2); EXPECT_EQ(subscriptionManagerPtr_->report(), json::parse(kREPORT_RETURN)); @@ -225,11 +225,10 @@ TEST_F(SubscriptionManagerTest, BookChangesTest) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 32); auto transactions = std::vector{}; auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STObject const metaObj = - createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); + xrpl::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1); trans1.metadata = metaObj.getSerializer().peekData(); transactions.push_back(trans1); static constexpr auto kBOOK_CHANGE_PUBLISH = @@ -296,7 +295,7 @@ TEST_F(SubscriptionManagerTest, LedgerTest) // test publish auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31); - auto fee2 = ripple::Fees(); + auto fee2 = xrpl::Fees(); fee2.reserve = 10; static constexpr auto kLEDGER_PUB = R"JSON({ @@ -323,7 +322,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_); diff --git a/tests/unit/feed/TransactionFeedTests.cpp b/tests/unit/feed/TransactionFeedTests.cpp index 6a0e4ada1..a0c23153a 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(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -244,7 +244,7 @@ TEST_F(FeedTransactionTest, SubTransactionForProposedTx) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -267,7 +267,7 @@ TEST_F(FeedTransactionTest, SubTransactionV2) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -295,7 +295,7 @@ TEST_F(FeedTransactionTest, SubAccountV1) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -323,7 +323,7 @@ TEST_F(FeedTransactionTest, SubForProposedAccount) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -348,7 +348,7 @@ TEST_F(FeedTransactionTest, SubAccountV2) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -377,7 +377,7 @@ TEST_F(FeedTransactionTest, SubBothTransactionAndAccount) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -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(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -720,7 +720,7 @@ TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -756,7 +756,7 @@ TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -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(kLEDGER_HASH, 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{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, 0); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, 0); auto const issue2 = getIssue(kCURRENCY, kISSUER); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(issue2, 100)); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(issue2, 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); auto const issueAccount = getAccountIdWithString(kISSUER); - auto const kk = ripple::keylet::account(issueAccount).key; + auto const kk = xrpl::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); + xrpl::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -984,32 +984,32 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 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{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100)); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, xrpl::lsfHighFreeze); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(getIssue(kCURRENCY, kISSUER), 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); auto const issueAccount = getAccountIdWithString(kISSUER); - auto const kk = ripple::keylet::account(issueAccount).key; + auto const kk = xrpl::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); + xrpl::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -1025,33 +1025,33 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 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{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, xrpl::lsfHighFreeze); auto const issueAccount = getAccountIdWithString(kISSUER); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100)); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(getIssue(kCURRENCY, kISSUER), 100)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); - auto const kk = ripple::keylet::account(issueAccount).key; + auto const kk = xrpl::keylet::account(issueAccount).key; ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .WillByDefault(testing::Return(line.getSerializer().peekData())); - ripple::STObject const accountRoot = - createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + xrpl::STObject const accountRoot = + createAccountRootObject(kISSUER, xrpl::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .WillByDefault(testing::Return(accountRoot.getSerializer().peekData())); @@ -1073,7 +1073,7 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -1102,7 +1102,7 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidated) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -1126,7 +1126,7 @@ TEST_F(FeedTransactionTest, SubProposedDisconnect) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -1151,7 +1151,7 @@ TEST_F(FeedTransactionTest, SubProposedAccountDisconnect) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); + xrpl::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22) @@ -1175,37 +1175,37 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); auto trans1 = TransactionAndMetadata(); - ripple::STObject const obj = + xrpl::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 1, 3); trans1.transaction = obj.getSerializer().peekData(); trans1.ledgerSequence = 32; - ripple::STArray const metaArray{0}; - ripple::STObject metaObj(ripple::sfTransactionMetaData); - metaObj.setFieldArray(ripple::sfAffectedNodes, metaArray); - metaObj.setFieldU8(ripple::sfTransactionResult, ripple::tesSUCCESS); - metaObj.setFieldU32(ripple::sfTransactionIndex, 22); + xrpl::STArray const metaArray{0}; + xrpl::STObject metaObj(xrpl::sfTransactionMetaData); + metaObj.setFieldArray(xrpl::sfAffectedNodes, metaArray); + metaObj.setFieldU8(xrpl::sfTransactionResult, xrpl::tesSUCCESS); + metaObj.setFieldU32(xrpl::sfTransactionIndex, 22); trans1.metadata = metaObj.getSerializer().peekData(); - ripple::STObject line(ripple::sfIndexes); - line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE); - line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false)); - line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false)); - line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID}); - line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3); - line.setFieldU32(ripple::sfFlags, 0); + xrpl::STObject line(xrpl::sfIndexes); + line.setFieldU16(xrpl::sfLedgerEntryType, xrpl::ltRIPPLE_STATE); + line.setFieldAmount(xrpl::sfLowLimit, xrpl::STAmount(10, false)); + line.setFieldAmount(xrpl::sfHighLimit, xrpl::STAmount(100, false)); + line.setFieldH256(xrpl::sfPreviousTxnID, xrpl::uint256{kTXN_ID}); + line.setFieldU32(xrpl::sfPreviousTxnLgrSeq, 3); + line.setFieldU32(xrpl::sfFlags, 0); auto const issue2 = getIssue(kLPTOKEN_CURRENCY, kAMM_ACCOUNT); - line.setFieldAmount(ripple::sfBalance, ripple::STAmount(issue2, 100)); + line.setFieldAmount(xrpl::sfBalance, xrpl::STAmount(issue2, 100)); EXPECT_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_)) .Times(2) .WillRepeatedly(testing::Return(line.getSerializer().peekData())); - auto const ammID = ripple::uint256{54321}; + auto const ammID = xrpl::uint256{54321}; // create an amm account because in `accountHolds` checks for the ammID auto const ammAccount = getAccountIdWithString(kAMM_ACCOUNT); - auto const kk = ripple::keylet::account(ammAccount).key; - ripple::STObject const ammAccountRoot = + auto const kk = xrpl::keylet::account(ammAccount).key; + xrpl::STObject const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 1, 10, 2, kTXN_ID, 3, 0, ammID); EXPECT_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_)) .Times(2) @@ -1256,20 +1256,20 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken) .WillOnce(testing::Return(true)); auto const ammObj = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), kCURRENCY, kISSUER + kAMM_ACCOUNT, "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, kTXN_ID, 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 +1392,7 @@ TEST_F(FeedTransactionTest, PublishesMPTokenAuthorizeTx) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33); // The issuance ID that this transaction is authorizing - auto const mptIssuanceID = ripple::makeMptID(1, getAccountIdWithString(kACCOUNT1)); + auto const mptIssuanceID = xrpl::makeMptID(1, getAccountIdWithString(kACCOUNT1)); auto const trans = createMPTokenAuthorizeTxWithMetadata(kACCOUNT1, mptIssuanceID, 15, 5); EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1)); @@ -1435,7 +1435,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 +1468,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/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..f7d0f4fff 100644 --- a/tests/unit/rpc/BaseTests.cpp +++ b/tests/unit/rpc/BaseTests.cpp @@ -401,11 +401,11 @@ TEST_F(RPCBaseTest, WithCustomError) {"transaction", WithCustomError{ CustomValidators::uint256HexStringValidator, - rpc::Status{ripple::rpcBAD_FEATURE, "MyCustomError"} + rpc::Status{xrpl::rpcBAD_FEATURE, "MyCustomError"} }}, {"other", WithCustomError{ - Type{}, rpc::Status{ripple::rpcALREADY_MULTISIG, "MyCustomError2"} + Type{}, rpc::Status{xrpl::rpcALREADY_MULTISIG, "MyCustomError2"} }} }; @@ -420,13 +420,13 @@ TEST_F(RPCBaseTest, WithCustomError) 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::rpcBAD_FEATURE); failingInput = 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::rpcALREADY_MULTISIG); } TEST_F(RPCBaseTest, TimeFormatValidator) @@ -448,7 +448,7 @@ TEST_F(RPCBaseTest, TimeFormatValidator) auto failingInput = 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::rpcINVALID_PARAMS); failingInput = json::parse(R"JSON({ "date": "01-01-2024T00:00:00" })JSON"); EXPECT_FALSE(spec.process(failingInput)); @@ -462,7 +462,7 @@ TEST_F(RPCBaseTest, TimeFormatValidator) failingInput = 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::rpcINVALID_PARAMS); } TEST_F(RPCBaseTest, CustomValidator) @@ -699,7 +699,7 @@ TEST_F(RPCBaseTest, IssuerValidator) ASSERT_EQ(err.error().message, "issuerNotString"); failingInput = - json::parse(fmt::format(R"JSON({{ "issuer": "{}"}})JSON", toBase58(ripple::noAccount()))); + json::parse(fmt::format(R"JSON({{ "issuer": "{}"}})JSON", toBase58(xrpl::noAccount()))); err = spec.process(failingInput); ASSERT_FALSE(err); } diff --git a/tests/unit/rpc/RPCHelpersTests.cpp b/tests/unit/rpc/RPCHelpersTests.cpp index e00c13481..a66c1eaaa 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::rpcINVALID_PARAMS); 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::rpcINVALID_PARAMS); 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, kTXN_ID, 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, kTXN_ID, 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 kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); std::vector bbs; int objectsCount = 10; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 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, kNEXT_PAGE); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); // first page 's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); // second page's next page is 0 - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); @@ -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 kPAGE_NUM = 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, kTXN_ID, 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 kPAGE_NUM = 99; EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); int objectsCount = 10; - ripple::STObject const channel1 = + xrpl::STObject const channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 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::rpcINVALID_PARAMS); EXPECT_EQ(ret.error().message, "Invalid marker."); }); ctx_.run(); @@ -531,7 +531,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 @@ -560,7 +560,7 @@ TEST_F(RPCHelpersTest, ParseIssue) TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist) { auto const account = getAccountIdWithString(kACCOUNT); - auto const issuerKey = ripple::keylet::account(account); + auto const issuerKey = xrpl::keylet::account(account); // returns empty blob ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) @@ -569,7 +569,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist) runSpawn([&](boost::asio::yield_context yield) { // return false: blob doesn't exist EXPECT_FALSE(fetchAndCheckAnyFlagsExists( - *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {xrpl::lsfHighDeepFreeze}, yield )); }); } @@ -577,11 +577,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, kTXN_ID, 3); + createAccountRootObject(kACCOUNT, xrpl::lsfHighDeepFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -589,7 +589,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_AccountWithCorrectFlag) runSpawn([&](boost::asio::yield_context yield) { // returns true: accountObject has the highDeepFreeze flag EXPECT_TRUE(fetchAndCheckAnyFlagsExists( - *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {xrpl::lsfHighDeepFreeze}, yield )); }); } @@ -597,11 +597,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, kTXN_ID, 3); + createAccountRootObject(kACCOUNT, xrpl::lsfLowDeepFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -609,7 +609,7 @@ TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_TrustLineIsFrozenAndCheckFreez runSpawn([&](boost::asio::yield_context yield) { // returns false: accountObject has the lowDeepFreeze flag EXPECT_FALSE(fetchAndCheckAnyFlagsExists( - *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield + *backend_, kLEDGER_SEQ_OBJECT, issuerKey, {xrpl::lsfHighDeepFreeze}, yield )); }); } @@ -617,10 +617,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, kTXN_ID, 3); + createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); @@ -637,10 +637,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, kLEDGER_SEQ_OBJECT, _)) @@ -648,7 +647,7 @@ TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsDeepFrozen) runSpawn([&](boost::asio::yield_context yield) { EXPECT_TRUE(isDeepFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield + *backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account2, yield )); }); } @@ -659,10 +658,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, kLEDGER_SEQ_OBJECT, _)) @@ -670,7 +668,7 @@ TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsNotDeepFrozen) runSpawn([&](boost::asio::yield_context yield) { EXPECT_FALSE(isDeepFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield + *backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account2, yield )); }); } @@ -680,10 +678,9 @@ TEST_F(RPCHelpersTest, isDeepFrozen_IssuerAndAccountIsSameWillNotBeDeepFrozen) auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - auto const trustLineKey = - ripple::keylet::line(account, issuer, ripple::Currency{kCURRENCY}).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, xrpl::Currency{kCURRENCY}).key; auto const trustlineDeepFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowDeepFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfLowDeepFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -692,7 +689,7 @@ TEST_F(RPCHelpersTest, isDeepFrozen_IssuerAndAccountIsSameWillNotBeDeepFrozen) runSpawn([&](boost::asio::yield_context yield) { // both accounts are same so trustline is not deep frozen EXPECT_FALSE(isDeepFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield + *backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account, yield )); }); } @@ -703,15 +700,15 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerAccountIsGlobalFrozen) auto const issuer = getAccountIdWithString(kACCOUNT2); auto const accountObject = - createAccountRootObject(kACCOUNT2, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); - auto const issuerKey = ripple::keylet::account(issuer).key; + createAccountRootObject(kACCOUNT2, xrpl::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3); + auto const issuerKey = xrpl::keylet::account(issuer).key; ON_CALL(*backend_, doFetchLedgerObject(issuerKey, kLEDGER_SEQ_OBJECT, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); runSpawn([&](boost::asio::yield_context yield) { EXPECT_TRUE(isFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, issuer, yield + *backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, issuer, yield )); }); } @@ -721,10 +718,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, kLEDGER_SEQ_OBJECT, _)) @@ -732,7 +728,7 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerAndAccountIsSameWillNotBeFrozen) runSpawn([&](boost::asio::yield_context yield) { EXPECT_FALSE(isFrozen( - *backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield + *backend_, kLEDGER_SEQ_OBJECT, account, xrpl::Currency{kCURRENCY}, account, yield )); }); } @@ -741,13 +737,13 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerTrustLineIsFrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; // issuer is higher than account, so the correct flag to set is High freeze auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfHighFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfHighFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -762,13 +758,13 @@ TEST_F(RPCHelpersTest, isFrozen_IssuerWithLowFreezeIsNotFrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; // issuer is higher than account, but the flag set here is low freeze auto const trustlineFrozen = createRippleStateLedgerObject( - "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowFreeze + "USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, xrpl::lsfLowFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -783,9 +779,9 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineNotfrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; auto const trustLine = createRippleStateLedgerObject( kCURRENCY, kACCOUNT2, 500, kACCOUNT, 1000, kACCOUNT2, 1000, kTXN_ID, 1, 0 ); @@ -805,7 +801,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)); }); } @@ -813,9 +809,9 @@ TEST_F(RPCHelpersTest, AccountHolds_NoTrustLine) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; - auto const key = ripple::keylet::line(account, issuer, currency).key; + auto const key = xrpl::keylet::line(account, issuer, currency).key; // return no trustline found EXPECT_CALL(*backend_, doFetchLedgerObject(key, kLEDGER_SEQ_OBJECT, _)) @@ -833,7 +829,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)); }); } @@ -841,22 +837,13 @@ TEST_F(RPCHelpersTest, AccountHolds_TrustLineButFrozen) { auto const account = getAccountIdWithString(kACCOUNT); auto const issuer = getAccountIdWithString(kACCOUNT2); - ripple::Currency const currency{kCURRENCY}; + xrpl::Currency const currency{kCURRENCY}; // balance of 500, but trustline is frozen - auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key; + auto const trustLineKey = xrpl::keylet::line(account, issuer, currency).key; auto const trustLine = createRippleStateLedgerObject( - kCURRENCY, - kACCOUNT2, - 500, - kACCOUNT, - 1000, - kACCOUNT2, - 1000, - kTXN_ID, - 1, - ripple::lsfHighFreeze + kCURRENCY, kACCOUNT2, 500, kACCOUNT, 1000, kACCOUNT2, 1000, kTXN_ID, 1, xrpl::lsfHighFreeze ); ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _)) @@ -873,7 +860,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)); }); } @@ -886,15 +873,15 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + xrpl::keylet::line(ammAccount, account, xrpl::to_currency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) .Times(2) .WillRepeatedly(Return(lptRippleState.getSerializer().peekData())); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); @@ -913,7 +900,7 @@ TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::to_currency(kLPTOKEN_CURRENCY), ammAccount, true, yield @@ -932,7 +919,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) "USD", kACCOUNT2, 100, kACCOUNT, 100, kACCOUNT2, 100, kTXN_ID, 3 ); auto const usdRippleStateKk = - ripple::keylet::line(account2, account, ripple::to_currency("USD")).key; + xrpl::keylet::line(account2, account, xrpl::to_currency("USD")).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(usdRippleStateKk, testing::_, testing::_)) @@ -945,7 +932,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::_)) @@ -958,7 +945,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency("USD"), + xrpl::to_currency("USD"), account2, true, yield @@ -978,7 +965,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + xrpl::keylet::line(ammAccount, account, xrpl::to_currency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -991,8 +978,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) ) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); @@ -1001,18 +988,17 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject( - kAMM_ACCOUNT, "USD", kISSUER, "XRP", ripple::toBase58(ripple::xrpAccount()) - ); + auto const amm = + createAmmObject(kAMM_ACCOUNT, "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())); @@ -1022,7 +1008,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::to_currency(kLPTOKEN_CURRENCY), ammAccount, true, yield @@ -1042,7 +1028,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + xrpl::keylet::line(ammAccount, account, xrpl::to_currency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)).Times(2); @@ -1055,8 +1041,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) ) .WillOnce(testing::Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); @@ -1065,17 +1051,16 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER - ); + auto const amm = + createAmmObject(kAMM_ACCOUNT, "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())); @@ -1085,7 +1070,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::to_currency(kLPTOKEN_CURRENCY), ammAccount, true, yield @@ -1105,7 +1090,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3 ); auto const lptRippleStateKk = - ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key; + xrpl::keylet::line(ammAccount, account, xrpl::to_currency(kLPTOKEN_CURRENCY)).key; // trustline fetched twice. once in accountHolds and once in isFrozen EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)) @@ -1118,8 +1103,8 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) ) .WillOnce(Return(true)); - auto const ammID = ripple::uint256{kAMM_ID}; - auto const ammAccountKk = ripple::keylet::account(ammAccount).key; + auto const ammID = xrpl::uint256{kAMM_ID}; + auto const ammAccountKk = xrpl::keylet::account(ammAccount).key; auto const ammAccountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID); @@ -1128,23 +1113,21 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) .Times(2) .WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData())); - auto const amm = createAmmObject( - kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER - ); + auto const amm = + createAmmObject(kAMM_ACCOUNT, "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, kTXN_ID, 3); - auto const usdRippleStateKk = - ripple::keylet::line(issuer, account, ripple::to_currency("USD")).key; + auto const usdRippleStateKk = xrpl::keylet::line(issuer, account, xrpl::to_currency("USD")).key; EXPECT_CALL(*backend_, doFetchLedgerObject(usdRippleStateKk, testing::_, testing::_)) .WillOnce(Return(usdRippleState.getSerializer().peekData())); @@ -1155,7 +1138,7 @@ TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen) *mockAmendmentCenterPtr_, 0, account, - ripple::to_currency(kLPTOKEN_CURRENCY), + xrpl::to_currency(kLPTOKEN_CURRENCY), ammAccount, true, yield diff --git a/tests/unit/rpc/handlers/AMMInfoTests.cpp b/tests/unit/rpc/handlers/AMMInfoTests.cpp index b8c9348d4..9433e52bd 100644 --- a/tests/unit/rpc/handlers/AMMInfoTests.cpp +++ b/tests/unit/rpc/handlers/AMMInfoTests.cpp @@ -267,14 +267,14 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAmmBlobNotFound) { auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); auto const accountKey = getAccountKey(kAMM_ACCOUNT); - auto const ammId = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammId); + auto const ammId = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammId); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( - kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2 + kAMM_ACCOUNT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2 ); - accountRoot.setFieldH256(ripple::sfAMMID, ripple::uint256{kAMM_ID}); + accountRoot.setFieldH256(xrpl::sfAMMID, xrpl::uint256{kAMM_ID}); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) @@ -307,14 +307,14 @@ TEST_F(RPCAMMInfoHandlerTest, AMMAccountAccBlobNotFound) auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, 30); auto const accountKey = getAccountKey(kAMM_ACCOUNT); auto const account2Key = getAccountKey(kAMM_ACCOUNT2); - auto const ammId = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammId); + auto const ammId = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammId); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const ammObj = createAmmObject( - kAMM_ACCOUNT2, "XRP", ripple::toBase58(ripple::xrpAccount()), "JPY", kAMM_ACCOUNT2 + kAMM_ACCOUNT2, "XRP", xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2 ); - accountRoot.setFieldH256(ripple::sfAMMID, ammId); + accountRoot.setFieldH256(xrpl::sfAMMID, ammId); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); ON_CALL(*backend_, doFetchLedgerObject(accountKey, testing::_, testing::_)) @@ -349,22 +349,21 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalFirstXRPNoTrustline) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -432,25 +431,24 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAccount) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = - ripple::keylet::line(account2, account1, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account2, account1, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const account2Root = createAccountRootObject(kAMM_ACCOUNT2, 0, 2, 300, 2, kINDEX1, 2); auto const ammObj = createAmmObject( kAMM_ACCOUNT2, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT, kLP_ISSUE_CURRENCY ); auto const lptCurrency = createLptCurrency("XRP", "JPY"); - auto const accountHoldsKeylet = ripple::keylet::line(account2, account2, lptCurrency); + auto const accountHoldsKeylet = xrpl::keylet::line(account2, account2, lptCurrency); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustline = createRippleStateLedgerObject( kLP_ISSUE_CURRENCY, kAMM_ACCOUNT, 12, kAMM_ACCOUNT2, 1000, kAMM_ACCOUNT, 2000, kINDEX1, 2 @@ -525,11 +523,10 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( @@ -537,10 +534,10 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathMinimalSecondXRPNoTrustline) "JPY", kAMM_ACCOUNT2, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -608,17 +605,16 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathNonXRPNoTrustlines) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -693,19 +689,17 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue1LineKey = - ripple::keylet::line(account1, account1, ripple::to_currency("USD")).key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue1LineKey = xrpl::keylet::line(account1, account1, xrpl::to_currency("USD")).key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); // note: frozen flag will not be used for trustline1 because issuer == account @@ -719,7 +713,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) 2000, kINDEX1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( "JPY", @@ -731,7 +725,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozen) 2000, kINDEX1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -808,21 +802,19 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue1LineKey = - ripple::keylet::line(account1, account1, ripple::to_currency("USD")).key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue1LineKey = xrpl::keylet::line(account1, account1, xrpl::to_currency("USD")).key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; // asset1 will be frozen because flag set here auto accountRoot = - createAccountRootObject(kAMM_ACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2); + createAccountRootObject(kAMM_ACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "USD", kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); // note: frozen flag will not be used for trustline1 because issuer == account @@ -836,7 +828,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) 2000, kINDEX1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); auto const trustline2BalanceFrozen = createRippleStateLedgerObject( "JPY", @@ -848,7 +840,7 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathFrozenIssuer) 2000, kINDEX1, 2, - ripple::lsfGlobalFreeze + xrpl::lsfGlobalFreeze ); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(lgrInfo)); @@ -925,22 +917,21 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithTrustline) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject( "JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0 @@ -1011,24 +1002,23 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithVoteSlots) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); ammAddVoteSlot(ammObj, account1, 2, 4); ammAddVoteSlot(ammObj, account2, 4, 2); - accountRoot.setFieldH256(ripple::sfAMMID, ammKey); + accountRoot.setFieldH256(xrpl::sfAMMID, ammKey); auto const feesObj = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); auto const trustlineBalance = createRippleStateLedgerObject( "JPY", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0 @@ -1113,17 +1103,16 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAuctionSlot) auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); - auto const ammKey = ripple::uint256{kAMM_ID}; - auto const ammKeylet = ripple::keylet::amm(ammKey); - auto const feesKey = ripple::keylet::fees().key; - auto const issue2LineKey = - ripple::keylet::line(account1, account2, ripple::to_currency("JPY")).key; + auto const ammKey = xrpl::uint256{kAMM_ID}; + auto const ammKeylet = xrpl::keylet::amm(ammKey); + auto const feesKey = xrpl::keylet::fees().key; + auto const issue2LineKey = xrpl::keylet::line(account1, account2, xrpl::to_currency("JPY")).key; auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "XRP", - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), "JPY", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY @@ -1131,13 +1120,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", kAMM_ACCOUNT2, -8, kAMM_ACCOUNT, 1000, kAMM_ACCOUNT2, 2000, kINDEX2, 2, 0 @@ -1226,24 +1215,24 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsMatchingInputOrder) auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const issue1 = ripple::Issue(ripple::to_currency("JPY"), account1); - auto const issue2 = ripple::Issue(ripple::to_currency("USD"), account2); - auto const ammKeylet = ripple::keylet::amm(issue1, issue2); + auto const issue1 = xrpl::Issue(xrpl::to_currency("JPY"), account1); + auto const issue2 = xrpl::Issue(xrpl::to_currency("USD"), account2); + auto const ammKeylet = xrpl::keylet::amm(issue1, issue2); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto ammObj = createAmmObject( kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT, "USD", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLP_ISSUE_CURRENCY}, account1}; + auto const auctionIssue = xrpl::Issue{xrpl::Currency{kLP_ISSUE_CURRENCY}, account1}; ammSetAuctionSlot( ammObj, account2, - ripple::amountFromString(auctionIssue, "100"), + 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::_)) @@ -1346,25 +1335,25 @@ TEST_F(RPCAMMInfoHandlerTest, HappyPathWithAssetsPreservesInputOrder) auto const lgrInfo = createLedgerHeader(kLEDGER_HASH, kSEQ); auto const account1 = getAccountIdWithString(kAMM_ACCOUNT); auto const account2 = getAccountIdWithString(kAMM_ACCOUNT2); - auto const issue1 = ripple::Issue(ripple::to_currency("USD"), account1); - auto const issue2 = ripple::Issue(ripple::to_currency("JPY"), account2); - auto const ammKeylet = ripple::keylet::amm(issue1, issue2); + auto const issue1 = xrpl::Issue(xrpl::to_currency("USD"), account1); + auto const issue2 = xrpl::Issue(xrpl::to_currency("JPY"), account2); + auto const ammKeylet = xrpl::keylet::amm(issue1, issue2); // Note: order in the AMM object is different from the input auto ammObj = createAmmObject( kAMM_ACCOUNT, "JPY", kAMM_ACCOUNT, "USD", kAMM_ACCOUNT2, kLP_ISSUE_CURRENCY ); auto accountRoot = createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2); - auto const auctionIssue = ripple::Issue{ripple::Currency{kLP_ISSUE_CURRENCY}, account1}; + auto const auctionIssue = xrpl::Issue{xrpl::Currency{kLP_ISSUE_CURRENCY}, account1}; ammSetAuctionSlot( ammObj, account2, - ripple::amountFromString(auctionIssue, "100"), + 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::_)) diff --git a/tests/unit/rpc/handlers/AccountChannelsTests.cpp b/tests/unit/rpc/handlers/AccountChannelsTests.cpp index db7e2204a..bb4df3580 100644 --- a/tests/unit/rpc/handlers/AccountChannelsTests.cpp +++ b/tests/unit/rpc/handlers/AccountChannelsTests.cpp @@ -278,8 +278,8 @@ TEST_F(RPCAccountChannelsHandlerTest, AccountNotString) TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -308,7 +308,7 @@ 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( fmt::format( @@ -333,7 +333,7 @@ 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( fmt::format( @@ -360,7 +360,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -412,7 +412,7 @@ TEST_F(RPCAccountChannelsHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCAccountChannelsHandlerTest, NonExistAccount) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty @@ -476,16 +476,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,7 +493,7 @@ 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, kTXN_ID, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); @@ -524,27 +524,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, kTXN_ID, 28); bbs.push_back(channel.getSerializer().peekData()); } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); // it should not appear in return marker,marker is the current page - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -612,22 +612,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, kTXN_ID, 28); bbs.push_back(channel.getSerializer().peekData()); } @@ -636,12 +636,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, kTXN_ID, 28); bbs.push_back(channel.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -676,15 +676,15 @@ 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())); @@ -751,16 +751,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,12 +768,12 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) // return two payment channel objects std::vector bbs; - ripple::STObject channel1 = + xrpl::STObject channel1 = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28); - channel1.setFieldU32(ripple::sfExpiration, 100); - channel1.setFieldU32(ripple::sfCancelAfter, 200); - channel1.setFieldU32(ripple::sfSourceTag, 300); - channel1.setFieldU32(ripple::sfDestinationTag, 400); + 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)); @@ -798,11 +798,11 @@ TEST_F(RPCAccountChannelsHandlerTest, OptionalResponseField) TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto ownerDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto ownerDirKk = xrpl::keylet::ownerDir(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -813,11 +813,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, kTXN_ID, 28); // owner dir contains 10 indexes int objectsCount = 10; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -830,14 +830,14 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); // first page 's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); // second page's next page is 0 - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); @@ -870,10 +870,10 @@ TEST_F(RPCAccountChannelsHandlerTest, MarkerOutput) TEST_F(RPCAccountChannelsHandlerTest, MarkerInput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; + auto accountKk = xrpl::keylet::account(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -884,10 +884,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, kTXN_ID, 28); int objectsCount = kLIMIT; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -895,8 +895,8 @@ 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())); @@ -934,16 +934,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,7 +951,7 @@ 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, kTXN_ID, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); @@ -986,16 +986,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,7 +1003,7 @@ 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, kTXN_ID, 28); bbs.push_back(channel1.getSerializer().peekData()); bbs.push_back(channel1.getSerializer().peekData()); diff --git a/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp b/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp index 3c2797ccd..c7a20498a 100644 --- a/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp +++ b/tests/unit/rpc/handlers/AccountCurrenciesTests.cpp @@ -77,7 +77,7 @@ 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( fmt::format( @@ -104,7 +104,7 @@ 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( fmt::format( @@ -130,8 +130,8 @@ TEST_F(RPCAccountCurrenciesHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -174,14 +174,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); @@ -229,15 +229,15 @@ TEST_F(RPCAccountCurrenciesHandlerTest, RequestViaLegderHash) // return valid ledgerHeader auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); // return valid account - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -274,12 +274,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); diff --git a/tests/unit/rpc/handlers/AccountInfoTests.cpp b/tests/unit/rpc/handlers/AccountInfoTests.cpp index cc471dd7d..6fb9f91e1 100644 --- a/tests/unit/rpc/handlers/AccountInfoTests.cpp +++ b/tests/unit/rpc/handlers/AccountInfoTests.cpp @@ -171,7 +171,7 @@ 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( fmt::format( @@ -219,8 +219,8 @@ TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountInfoHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -302,11 +302,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, _)) @@ -404,11 +404,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()) @@ -506,11 +506,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()) @@ -580,12 +580,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, @@ -624,7 +624,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())); @@ -658,7 +658,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,7 +669,7 @@ 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{})); @@ -745,14 +745,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, @@ -828,13 +828,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, diff --git a/tests/unit/rpc/handlers/AccountLinesTests.cpp b/tests/unit/rpc/handlers/AccountLinesTests.cpp index 6202ade1a..b6c1ffd19 100644 --- a/tests/unit/rpc/handlers/AccountLinesTests.cpp +++ b/tests/unit/rpc/handlers/AccountLinesTests.cpp @@ -318,8 +318,8 @@ TEST_F(RPCAccountLinesHandlerTest, LimitZero) TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -348,7 +348,7 @@ 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( fmt::format( @@ -373,7 +373,7 @@ 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( fmt::format( @@ -400,7 +400,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -452,7 +452,7 @@ TEST_F(RPCAccountLinesHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCAccountLinesHandlerTest, NonExistAccount) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty @@ -486,16 +486,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())); @@ -567,15 +567,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 +586,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); @@ -656,15 +656,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 +687,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); @@ -722,15 +722,15 @@ 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())); @@ -794,8 +794,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 +803,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,19 +815,19 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze) auto line1 = createRippleStateLedgerObject( "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0 ); - line1.setFlag(ripple::lsfHighAuth); - line1.setFlag(ripple::lsfHighNoRipple); - line1.setFlag(ripple::lsfHighFreeze); - line1.setFlag(ripple::lsfHighDeepFreeze); + line1.setFlag(xrpl::lsfHighAuth); + line1.setFlag(xrpl::lsfHighNoRipple); + line1.setFlag(xrpl::lsfHighFreeze); + line1.setFlag(xrpl::lsfHighDeepFreeze); bbs.push_back(line1.getSerializer().peekData()); auto line2 = createRippleStateLedgerObject( "USD", kACCOUNT2, 20, kACCOUNT, 200, kACCOUNT2, 400, kTXN_ID, 0 ); - line2.setFlag(ripple::lsfLowAuth); - line2.setFlag(ripple::lsfLowNoRipple); - line2.setFlag(ripple::lsfLowFreeze); - line2.setFlag(ripple::lsfLowDeepFreeze); + line2.setFlag(xrpl::lsfLowAuth); + line2.setFlag(xrpl::lsfLowNoRipple); + line2.setFlag(xrpl::lsfLowFreeze); + line2.setFlag(xrpl::lsfLowDeepFreeze); bbs.push_back(line2.getSerializer().peekData()); ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs)); @@ -887,8 +887,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 +896,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,15 +907,15 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) auto line1 = createRippleStateLedgerObject( "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0 ); - line1.setFlag(ripple::lsfHighAuth); - line1.setFlag(ripple::lsfHighFreeze); + line1.setFlag(xrpl::lsfHighAuth); + line1.setFlag(xrpl::lsfHighFreeze); bbs.push_back(line1.getSerializer().peekData()); auto line2 = createRippleStateLedgerObject( "USD", kACCOUNT2, 20, kACCOUNT, 200, kACCOUNT2, 400, kTXN_ID, 0 ); - line2.setFlag(ripple::lsfLowAuth); - line2.setFlag(ripple::lsfLowFreeze); + line2.setFlag(xrpl::lsfLowAuth); + line2.setFlag(xrpl::lsfLowFreeze); bbs.push_back(line2.getSerializer().peekData()); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); @@ -939,11 +939,11 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse) TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; - auto ownerDirKk = ripple::keylet::ownerDir(account).key; + auto accountKk = xrpl::keylet::account(account).key; + auto ownerDirKk = xrpl::keylet::ownerDir(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -960,7 +960,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,14 +973,14 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) objectsCount--; } - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); // first page's next page is 99 ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1); // second page's next page is 0 - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); @@ -1013,10 +1013,10 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerOutput) TEST_F(RPCAccountLinesHandlerTest, MarkerInput) { auto account = getAccountIdWithString(kACCOUNT); - auto accountKk = ripple::keylet::account(account).key; + auto accountKk = xrpl::keylet::account(account).key; static constexpr auto kNEXT_PAGE = 99; static constexpr auto kLIMIT = 15; - auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key; + auto ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); @@ -1031,7 +1031,7 @@ TEST_F(RPCAccountLinesHandlerTest, MarkerInput) "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 0 ); int objectsCount = kLIMIT; - std::vector indexes; + std::vector indexes; while (objectsCount != 0) { // return owner index indexes.emplace_back(kINDEX1); @@ -1039,8 +1039,8 @@ 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())); @@ -1078,16 +1078,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())); @@ -1162,16 +1162,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())); diff --git a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp index f1f2c447d..25b72476b 100644 --- a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp @@ -210,8 +210,8 @@ TEST_P(AccountMPTokenIssuancesParameterTest, InvalidParams) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); auto const input = json::parse( fmt::format( @@ -239,7 +239,7 @@ 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( fmt::format( @@ -265,7 +265,7 @@ 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( fmt::format( @@ -290,7 +290,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByHash) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const input = json::parse( fmt::format( @@ -339,7 +339,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByIndex) TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistAccount) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); // fetch account object return empty EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); @@ -372,14 +372,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{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -390,8 +390,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, kISSUANCE1_OUTSTANDING_AMOUNT, std::nullopt, kISSUANCE1_ASSET_SCALE, @@ -404,7 +404,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters) kACCOUNT, 2, kISSUANCE2_METADATA, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -453,12 +453,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{kISSUANCE_INDEX1}); + auto const indexes = std::vector(50, xrpl::uint256{kISSUANCE_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); @@ -468,8 +468,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -548,15 +548,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), kNEXT_PAGE).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; + auto const ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const indexes = std::vector(10, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(10, xrpl::uint256{kISSUANCE_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLIMIT); @@ -568,14 +567,14 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerOutput) EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); // mock the first directory page - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ownerDir1.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); // mock the second directory page - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX2); - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX2); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); @@ -611,13 +610,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), kNEXT_PAGE).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); - auto const indexes = std::vector(kLIMIT, ripple::uint256{kISSUANCE_INDEX1}); + auto const indexes = std::vector(kLIMIT, xrpl::uint256{kISSUANCE_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLIMIT); @@ -627,8 +626,8 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -664,13 +663,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{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -680,8 +679,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, kISSUANCE1_OUTSTANDING_AMOUNT, std::nullopt, kISSUANCE1_ASSET_SCALE, @@ -694,7 +693,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin) kACCOUNT, 2, kISSUANCE2_METADATA, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -752,13 +751,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{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -768,8 +767,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, kISSUANCE1_OUTSTANDING_AMOUNT, std::nullopt, kISSUANCE1_ASSET_SCALE, @@ -782,7 +781,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax) kACCOUNT, 2, kISSUANCE2_METADATA, - ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback, + xrpl::lsfMPTLocked | xrpl::lsfMPTCanLock | xrpl::lsfMPTCanClawback, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -840,12 +839,12 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, EmptyResult) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kISSUANCE_INDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kISSUANCE_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -867,25 +866,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(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject( - {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kISSUANCE_INDEX1}, xrpl::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -895,7 +894,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) kACCOUNT, 3, std::nullopt, - ripple::lsfMPTCanTransfer, + xrpl::lsfMPTCanTransfer, kISSUANCE1_OUTSTANDING_AMOUNT, kISSUANCE1_TRANSFER_FEE, std::nullopt, @@ -911,7 +910,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags) kACCOUNT, 5, kISSUANCE2_METADATA, - ripple::lsfMPTCanTransfer, + xrpl::lsfMPTCanTransfer, kISSUANCE2_OUTSTANDING_AMOUNT, kISSUANCE2_TRANSFER_FEE, std::nullopt, @@ -1004,22 +1003,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"}, }; } @@ -1039,13 +1036,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{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -1093,28 +1090,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"}, }; } @@ -1134,13 +1131,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{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); + xrpl::STObject const ownerDir = + createOwnerDirLedgerObject({xrpl::uint256{kISSUANCE_INDEX1}}, kISSUANCE_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); diff --git a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp index 6426a52cb..720136425 100644 --- a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp +++ b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp @@ -178,8 +178,8 @@ TEST_P(AccountMPTokensParameterTest, InvalidParams) TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash to return empty - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); auto const input = json::parse( fmt::format( @@ -206,7 +206,7 @@ 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( fmt::format( @@ -231,7 +231,7 @@ 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( fmt::format( @@ -255,7 +255,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex) TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByHash) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const input = json::parse( @@ -305,7 +305,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByIndex) TEST_F(RPCAccountMPTokensHandlerTest, NonExistAccount) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); // fetch account object return empty EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional{})); @@ -337,13 +337,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{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kTOKEN_INDEX1}, xrpl::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 ); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -351,9 +351,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) auto const bbs = std::vector{ createMpTokenObject( kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), + xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, - ripple::lsfMPTLocked, + xrpl::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT ) .getSerializer() @@ -361,9 +361,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters) createMpTokenObject( kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), + xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, - ripple::lsfMPTAuthorized, + xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() @@ -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{kTOKEN_INDEX1}); + auto const indexes = std::vector(50, xrpl::uint256{kTOKEN_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(50); for (int i = 0; i < 50; ++i) { v.push_back( - createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + createMpTokenObject(kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -425,8 +425,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, UseLimit) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 99); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 99); ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7); @@ -505,10 +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), kNEXT_PAGE).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; + auto const ownerDir2Kk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); @@ -517,7 +516,7 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput) v.reserve(kLIMIT); for (int i = 0; i < kLIMIT; ++i) { v.push_back( - createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + createMpTokenObject(kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -526,18 +525,18 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput) }(); EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs)); - std::vector indexes1; + std::vector indexes1; indexes1.reserve(10); for (int i = 0; i < 10; ++i) { indexes1.emplace_back(kTOKEN_INDEX1); } - ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX1); - ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE); + xrpl::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX1); + ownerDir1.setFieldU64(xrpl::sfIndexNext, kNEXT_PAGE); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir1.getSerializer().peekData())); - ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX2); - ownerDir2.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX2); + ownerDir2.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _)) .WillByDefault(Return(ownerDir2.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3); @@ -574,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), kNEXT_PAGE).key; + auto const ownerDirKk = xrpl::keylet::page(xrpl::keylet::ownerDir(account), kNEXT_PAGE).key; - auto const indexes = std::vector(kLIMIT, ripple::uint256{kTOKEN_INDEX1}); + auto const indexes = std::vector(kLIMIT, xrpl::uint256{kTOKEN_INDEX1}); auto const bbs = [&]() { std::vector v; v.reserve(kLIMIT); for (int i = 0; i < kLIMIT; ++i) { v.push_back( - createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) + createMpTokenObject(kACCOUNT, xrpl::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt) .getSerializer() .peekData() ); @@ -593,8 +592,8 @@ TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput) return v; }(); - ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); - ownerDir.setFieldU64(ripple::sfIndexNext, 0); + xrpl::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1); + ownerDir.setFieldU64(xrpl::sfIndexNext, 0); ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -630,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{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kTOKEN_INDEX1}, xrpl::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -644,9 +643,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) auto const bbs = std::vector{ createMpTokenObject( kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), + xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, - ripple::lsfMPTLocked, + xrpl::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT ) .getSerializer() @@ -654,9 +653,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin) createMpTokenObject( kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), + xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, - ripple::lsfMPTAuthorized, + xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() @@ -709,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{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 + xrpl::STObject const ownerDir = createOwnerDirLedgerObject( + {xrpl::uint256{kTOKEN_INDEX1}, xrpl::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1 ); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); @@ -723,9 +722,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) auto const bbs = std::vector{ createMpTokenObject( kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), + xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, - ripple::lsfMPTLocked, + xrpl::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT ) .getSerializer() @@ -733,9 +732,9 @@ TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax) createMpTokenObject( kACCOUNT, - ripple::uint192(kISSUANCE_ID_HEX), + xrpl::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, - ripple::lsfMPTAuthorized, + xrpl::lsfMPTAuthorized, std::nullopt ) .getSerializer() @@ -788,12 +787,12 @@ TEST_F(RPCAccountMPTokensHandlerTest, EmptyResult) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; - auto const owneDirKk = ripple::keylet::ownerDir(account).key; + auto const accountKk = xrpl::keylet::account(account).key; + auto const owneDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kTOKEN_INDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject({}, kTOKEN_INDEX1); EXPECT_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); diff --git a/tests/unit/rpc/handlers/AccountNFTsTests.cpp b/tests/unit/rpc/handlers/AccountNFTsTests.cpp index d59046140..b771f4e82 100644 --- a/tests/unit/rpc/handlers/AccountNFTsTests.cpp +++ b/tests/unit/rpc/handlers/AccountNFTsTests.cpp @@ -165,8 +165,8 @@ TEST_F(RPCAccountNFTsHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -195,7 +195,7 @@ 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( fmt::format( @@ -224,7 +224,7 @@ 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( fmt::format( @@ -309,10 +309,10 @@ TEST_F(RPCAccountNFTsHandlerTest, NormalPath) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); @@ -346,10 +346,10 @@ TEST_F(RPCAccountNFTsHandlerTest, Limit) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, firstPage ); @@ -372,7 +372,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,13 +384,13 @@ TEST_F(RPCAccountNFTsHandlerTest, Marker) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAGE}, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAGE}, 30, _)) .WillByDefault(Return(pageObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -420,7 +420,7 @@ TEST_F(RPCAccountNFTsHandlerTest, InvalidMarker) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); static auto const kINPUT = json::parse( @@ -453,7 +453,7 @@ TEST_F(RPCAccountNFTsHandlerTest, AccountWithNoNFT) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); static auto const kINPUT = json::parse( @@ -480,13 +480,13 @@ TEST_F(RPCAccountNFTsHandlerTest, invalidPage) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kPAGE}, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAGE}, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -549,10 +549,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitLessThanMin) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); @@ -615,10 +615,10 @@ TEST_F(RPCAccountNFTsHandlerTest, LimitMoreThanMax) auto const accountObject = createAccountRootObject(kACCOUNT, 0, 1, 10, 2, kTXN_ID, 3); auto const accountID = getAccountIdWithString(kACCOUNT); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(accountID).key, 30, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(accountID).key, 30, _)) .WillByDefault(Return(accountObject.getSerializer().peekData())); - auto const firstPage = ripple::keylet::nftpage_max(accountID).key; + auto const firstPage = xrpl::keylet::nftpage_max(accountID).key; auto const pageObject = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt ); diff --git a/tests/unit/rpc/handlers/AccountObjectsTests.cpp b/tests/unit/rpc/handlers/AccountObjectsTests.cpp index dfeabe82e..a99f73655 100644 --- a/tests/unit/rpc/handlers/AccountObjectsTests.cpp +++ b/tests/unit/rpc/handlers/AccountObjectsTests.cpp @@ -212,7 +212,7 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaIntSequence) { // return empty ledgerHeader EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -260,8 +260,8 @@ TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCAccountObjectsHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -346,17 +346,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -390,7 +390,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); @@ -398,13 +398,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::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -443,7 +443,7 @@ TEST_F(RPCAccountObjectsHandlerTest, Marker) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); @@ -451,9 +451,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())); @@ -494,25 +494,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); static constexpr auto kCOUNT = 10; static constexpr auto kNEXTPAGE = 1; auto cc = kCOUNT; - auto ownerDir = createOwnerDirLedgerObject(std::vector(cc, ripple::uint256{kINDEX1}), kINDEX1); + auto ownerDir = createOwnerDirLedgerObject(std::vector(cc, xrpl::uint256{kINDEX1}), kINDEX1); // set next page - ownerDir.setFieldU64(ripple::sfIndexNext, kNEXTPAGE); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; - auto const page1 = ripple::keylet::page(ownerDirKk, kNEXTPAGE).key; + ownerDir.setFieldU64(xrpl::sfIndexNext, kNEXTPAGE); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; + auto const page1 = xrpl::keylet::page(ownerDirKk, kNEXTPAGE).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(page1, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -555,18 +555,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -578,10 +578,10 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilter) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(line1.getSerializer().peekData()); @@ -613,18 +613,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -635,7 +635,7 @@ 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)); @@ -666,18 +666,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -688,10 +688,10 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterReturnEmpty) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(line1.getSerializer().peekData()); @@ -724,18 +724,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const line = createRippleStateLedgerObject( @@ -747,10 +747,10 @@ TEST_F(RPCAccountObjectsHandlerTest, DeletionBlockersOnlyFilter) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -785,18 +785,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); auto const line = createRippleStateLedgerObject( @@ -836,38 +836,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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::nftpage_max(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::to_currency("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::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -904,37 +904,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + 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::nftpage_max(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::to_currency("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::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -1032,19 +1032,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft page 1 - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(account).key; auto const nftPage2KK = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kINDEX1}).key; + xrpl::keylet::nftpage(xrpl::keylet::nftpage_min(account), xrpl::uint256{kINDEX1}).key; auto const nftpage1 = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, nftPage2KK ); @@ -1089,19 +1089,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto current = ripple::keylet::nftpage_max(account).key; + auto current = xrpl::keylet::nftpage_max(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::nftpage_min(account), xrpl::uint256{first.c_str()}) + .key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1128,7 +1127,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 +1138,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto current = ripple::keylet::nftpage_max(account).key; + auto current = xrpl::keylet::nftpage_max(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::nftpage_min(account), xrpl::uint256{first.c_str()}) + .key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1186,7 +1184,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::zero)), std::numeric_limits::max() ) ); @@ -1199,23 +1197,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); std::string first{kINDEX1}; - auto current = ripple::keylet::nftpage( - ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()} - ) - .key; + auto current = + xrpl::keylet::nftpage(xrpl::keylet::nftpage_min(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::nftpage_min(account), xrpl::uint256{first.c_str()}) + .key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1230,9 +1225,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 +1240,10 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -1266,7 +1261,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarker) "marker": "{},{}" }})JSON", kACCOUNT, - ripple::strHex(marker), + xrpl::strHex(marker), std::numeric_limits::max() ) ); @@ -1289,14 +1284,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, kMAX_SEQ, _)) .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 +1304,10 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -1330,7 +1325,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNoMoreNFT) "marker": "{},{}" }})JSON", kACCOUNT, - ripple::strHex(ripple::uint256{beast::zero}), + xrpl::strHex(xrpl::uint256{beast::zero}), std::numeric_limits::max() ) ); @@ -1350,7 +1345,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotInRange) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); @@ -1382,12 +1377,12 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotExist) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); // return null for this marker - auto const accountNftMax = ripple::keylet::nftpage_max(account).key; + auto const accountNftMax = xrpl::keylet::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountNftMax, kMAX_SEQ, _)) .WillOnce(Return(std::nullopt)); @@ -1398,7 +1393,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTMarkerNotExist) "marker": "{},{}" }})JSON", kACCOUNT, - ripple::strHex(accountNftMax), + xrpl::strHex(accountNftMax), std::numeric_limits::max() ) ); @@ -1419,23 +1414,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); std::string first{kINDEX1}; - auto current = ripple::keylet::nftpage( - ripple::keylet::nftpage_min(account), ripple::uint256{first.c_str()} - ) - .key; + auto current = + xrpl::keylet::nftpage(xrpl::keylet::nftpage_min(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::nftpage_min(account), xrpl::uint256{first.c_str()}) + .key; auto const nftpage = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, previous ); @@ -1450,8 +1442,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 +1456,10 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); @@ -1486,7 +1478,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTLimitAdjust) "limit": 12 }})JSON", kACCOUNT, - ripple::strHex(marker), + xrpl::strHex(marker), std::numeric_limits::max() ) ); @@ -1551,19 +1543,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft page 1 - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(account).key; auto const nftPage2KK = - ripple::keylet::nftpage(ripple::keylet::nftpage_min(account), ripple::uint256{kINDEX1}).key; + xrpl::keylet::nftpage(xrpl::keylet::nftpage_min(account), xrpl::uint256{kINDEX1}).key; auto const nftpage1 = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, nftPage2KK ); @@ -1609,7 +1601,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); @@ -1617,8 +1609,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())); @@ -1640,7 +1632,7 @@ TEST_F(RPCAccountObjectsHandlerTest, NFTZeroMarkerNotAffectOtherMarker) }})JSON", kACCOUNT, kLIMIT, - ripple::strHex(ripple::uint256{beast::zero}), + xrpl::strHex(xrpl::uint256{beast::zero}), std::numeric_limits::max() ) ); @@ -1697,17 +1689,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -1778,17 +1770,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -1824,17 +1816,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, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(nftMaxKK, 30, _)).WillOnce(Return(std::nullopt)); std::vector bbs; @@ -1865,7 +1857,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,23 +1868,23 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTokenType) EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerinfo)); auto const account = getAccountIdWithString(kACCOUNT); - auto const accountKk = ripple::keylet::account(account).key; + auto const accountKk = xrpl::keylet::account(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, kMAX_SEQ, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(account).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(account).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, 30, _)) .WillOnce(Return(ownerDir.getSerializer().peekData())); // nft null - auto const nftMaxKK = ripple::keylet::nftpage_max(account).key; + auto const nftMaxKK = xrpl::keylet::nftpage_max(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)); diff --git a/tests/unit/rpc/handlers/AccountOffersTests.cpp b/tests/unit/rpc/handlers/AccountOffersTests.cpp index fb14582ba..2affc82d3 100644 --- a/tests/unit/rpc/handlers/AccountOffersTests.cpp +++ b/tests/unit/rpc/handlers/AccountOffersTests.cpp @@ -160,8 +160,8 @@ TEST_F(RPCAccountOffersHandlerTest, LedgerNotFoundViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -190,7 +190,7 @@ 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( fmt::format( @@ -219,7 +219,7 @@ 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( fmt::format( @@ -301,12 +301,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, kLEDGER_SEQ, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -316,13 +316,13 @@ TEST_F(RPCAccountOffersHandlerTest, DefaultParams) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("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)); @@ -352,13 +352,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, kLEDGER_SEQ, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = - createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + createOwnerDirLedgerObject(std::vector{20, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -369,10 +369,10 @@ TEST_F(RPCAccountOffersHandlerTest, Limit) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(offer.getSerializer().peekData()); @@ -406,15 +406,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, kLEDGER_SEQ, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const startPage = 2; auto const ownerDir = - createOwnerDirLedgerObject(std::vector{20, ripple::uint256{kINDEX1}}, kINDEX1); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - auto const hintIndex = ripple::keylet::page(ownerDirKk, startPage).key; + createOwnerDirLedgerObject(std::vector{20, xrpl::uint256{kINDEX1}}, kINDEX1); + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const hintIndex = xrpl::keylet::page(ownerDirKk, startPage).key; ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -426,10 +426,10 @@ TEST_F(RPCAccountOffersHandlerTest, Marker) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); bbs.push_back(offer.getSerializer().peekData()); @@ -465,13 +465,13 @@ TEST_F(RPCAccountOffersHandlerTest, MarkerNotExists) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, kLEDGER_SEQ, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const startPage = 2; - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; - auto const hintIndex = ripple::keylet::page(ownerDirKk, startPage).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const hintIndex = xrpl::keylet::page(ownerDirKk, startPage).key; ON_CALL(*backend_, doFetchLedgerObject(hintIndex, kLEDGER_SEQ, _)) .WillByDefault(Return(std::nullopt)); @@ -506,14 +506,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, kLEDGER_SEQ, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{AccountOffersHandler::kLIMIT_MIN + 1, xrpl::uint256{kINDEX1}}, kINDEX1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -523,13 +523,13 @@ TEST_F(RPCAccountOffersHandlerTest, LimitLessThanMin) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); - offer.setFieldU32(ripple::sfExpiration, 123); + offer.setFieldU32(xrpl::sfExpiration, 123); bbs.reserve(AccountOffersHandler::kLIMIT_MIN + 1); for (auto i = 0; i < AccountOffersHandler::kLIMIT_MIN + 1; i++) @@ -564,15 +564,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, kLEDGER_SEQ, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{AccountOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{AccountOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kLEDGER_SEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -582,13 +582,13 @@ TEST_F(RPCAccountOffersHandlerTest, LimitMoreThanMax) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT2, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kINDEX1 ); - offer.setFieldU32(ripple::sfExpiration, 123); + offer.setFieldU32(xrpl::sfExpiration, 123); bbs.reserve(AccountOffersHandler::kLIMIT_MAX + 1); for (auto i = 0; i < AccountOffersHandler::kLIMIT_MAX + 1; i++) bbs.push_back(offer.getSerializer().peekData()); diff --git a/tests/unit/rpc/handlers/AccountTxTests.cpp b/tests/unit/rpc/handlers/AccountTxTests.cpp index ed03794db..14d1feb84 100644 --- a/tests/unit/rpc/handlers/AccountTxTests.cpp +++ b/tests/unit/rpc/handlers/AccountTxTests.cpp @@ -440,21 +440,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); @@ -1045,7 +1043,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); EXPECT_CALL(*backend_, fetchLedgerByHash); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{})); diff --git a/tests/unit/rpc/handlers/AllHandlerTests.cpp b/tests/unit/rpc/handlers/AllHandlerTests.cpp index ed3b2d696..1a44c9142 100644 --- a/tests/unit/rpc/handlers/AllHandlerTests.cpp +++ b/tests/unit/rpc/handlers/AllHandlerTests.cpp @@ -197,9 +197,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; @@ -248,7 +248,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 7c8d42cb0..84ff25452 100644 --- a/tests/unit/rpc/handlers/BookChangesTests.cpp +++ b/tests/unit/rpc/handlers/BookChangesTests.cpp @@ -106,7 +106,7 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaIntSequence) EXPECT_CALL(*backend_, fetchLedgerBySequence); // return empty ledgerHeader ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)) - .WillByDefault(Return(std::optional{})); + .WillByDefault(Return(std::optional{})); static auto const kINPUT = json::parse(R"JSON({"ledger_index": 30})JSON"); auto const handler = AnyHandler{BookChangesHandler{backend_}}; @@ -139,8 +139,8 @@ TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaStringSequence) TEST_F(RPCBookChangesHandlerTest, LedgerNonExistViaHash) { // return empty ledgerHeader - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -188,11 +188,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); @@ -236,10 +235,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); diff --git a/tests/unit/rpc/handlers/BookOffersTests.cpp b/tests/unit/rpc/handlers/BookOffersTests.cpp index 7cd97bd73..6283d36ca 100644 --- a/tests/unit/rpc/handlers/BookOffersTests.cpp +++ b/tests/unit/rpc/handlers/BookOffersTests.cpp @@ -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; }; @@ -560,17 +560,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::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); @@ -578,10 +578,10 @@ generateNormalPathBookOffersTestBundles() kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); @@ -589,9 +589,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::to_currency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -600,9 +600,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::to_currency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR, kDOMAIN @@ -610,31 +610,19 @@ generateNormalPathBookOffersTestBundles() auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - account, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + xrpl::to_currency("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::to_currency("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::to_currency("USD"), account, std::nullopt ) .value() ); @@ -696,35 +684,34 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2) .getSerializer() .peekData()}, // owner account object - {ripple::keylet::account(account2).key, + {xrpl::keylet::account(account2).key, createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2) .getSerializer() .peekData()}, // fee settings: base ->3 inc->2, account2 has 2 objects ,total // reserve ->7 // owner_funds should be 193 - {ripple::keylet::fees().key, feeLedgerObject} + {xrpl::keylet::fees().key, feeLedgerObject} }, .ledgerObjectCalls = 5, - .mockedOffers = std::vector{gets10XRPPays20USDOffer}, + .mockedOffers = std::vector{gets10XRPPays20USDOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -763,35 +750,34 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2) .getSerializer() .peekData()}, // owner account object, hold - {ripple::keylet::account(account2).key, + {xrpl::keylet::account(account2).key, createAccountRootObject(kACCOUNT2, 0, 2, 5 + 7, 2, kINDEX1, 2) .getSerializer() .peekData()}, // fee settings: base ->3 inc->2, account2 has 2 objects // ,total // reserve ->7 - {ripple::keylet::fees().key, feeLedgerObject} + {xrpl::keylet::fees().key, feeLedgerObject} }, .ledgerObjectCalls = 5, - .mockedOffers = std::vector{gets10XRPPays20USDOffer}, + .mockedOffers = std::vector{gets10XRPPays20USDOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -836,28 +822,25 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsXRPPaysUSDBook, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, - createAccountRootObject( - kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2 - ) + {xrpl::keylet::account(account).key, + createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2) .getSerializer() .peekData()} }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10XRPPays20USDOffer}, + .mockedOffers = std::vector{gets10XRPPays20USDOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -902,29 +885,25 @@ generateNormalPathBookOffersTestBundles() .inputJson = getsXRPPaysUSDInputJsonWithDomain, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsXRPPaysUSDBookWithDomain, - ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsXRPPaysUSDBookWithDomain, xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // pays issuer account object - {ripple::keylet::account(account).key, - createAccountRootObject( - kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2 - ) + {xrpl::keylet::account(account).key, + createAccountRootObject(kACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2) .getSerializer() .peekData()} }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10XRPPays20USDOfferWithDomain}, + .mockedOffers = std::vector{gets10XRPPays20USDOfferWithDomain}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -970,28 +949,27 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + 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, kTRANSFER_RATE_X2 + kACCOUNT, xrpl::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2 ) .getSerializer() .peekData()} }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1037,29 +1015,28 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // gets issuer account object, rate is 1/2 - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 8 USD - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::to_currency("USD")).key, trustline8Balance.getSerializer().peekData()}, }, .ledgerObjectCalls = 6, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1106,32 +1083,31 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, 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, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 30 USD - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::to_currency("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 @@ -1206,26 +1182,25 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // gets issuer account object, rate is 1/2 - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, }, .ledgerObjectCalls = 3, - .mockedOffers = std::vector{gets10USDPays20XRPOwnerOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOwnerOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1265,29 +1240,28 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // gets issuer account object, rate is 1/2 - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() .peekData()}, // trust line between gets issuer and owner,owner has 8 USD - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::to_currency("USD")).key, frozenTrustLine.getSerializer().peekData()}, }, .ledgerObjectCalls = 6, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1333,35 +1307,27 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // gets issuer account object, is deep frozen so unfunded - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject( - kACCOUNT, - ripple::lsfLowDeepFreeze, - 2, - 200, - 2, - kINDEX1, - 2, - kTRANSFER_RATE_X2 + kACCOUNT, xrpl::lsfLowDeepFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2 ) .getSerializer() .peekData()}, }, .ledgerObjectCalls = 4, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1407,38 +1373,30 @@ generateNormalPathBookOffersTestBundles() .inputJson = paysXRPGetsUSDInputJson, // prepare offer dir index .mockedSuccessors = - std::map>{ - {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - std::optional{}} + std::map>{ + {getsUSDPaysXRPBook, xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional{}} }, .mockedLedgerObjects = - std::map{ + std::map{ // book dir object - {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, - createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1) + {xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, + createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1) .getSerializer() .peekData()}, // gets issuer account object, is deep frozen so unfunded - {ripple::keylet::account(account).key, + {xrpl::keylet::account(account).key, createAccountRootObject( - kACCOUNT, - ripple::lsfLowDeepFreeze, - 2, - 200, - 2, - kINDEX1, - 2, - kTRANSFER_RATE_X2 + kACCOUNT, xrpl::lsfLowDeepFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2 ) .getSerializer() .peekData()}, - {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, + {xrpl::keylet::line(account2, account, xrpl::to_currency("USD")).key, frozenTrustLine.getSerializer().peekData()}, }, .ledgerObjectCalls = 6, - .mockedOffers = std::vector{gets10USDPays20XRPOffer}, + .mockedOffers = std::vector{gets10USDPays20XRPOffer}, .expectedJson = fmt::format( R"JSON({{ "ledger_hash": "{}", @@ -1495,7 +1453,7 @@ 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( fmt::format( @@ -1527,7 +1485,7 @@ 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( fmt::format( @@ -1558,8 +1516,8 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); static auto const kINPUT = json::parse( fmt::format( @@ -1602,38 +1560,32 @@ TEST_F(RPCBookOffersHandlerTest, Limit) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + xrpl::to_currency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); + auto const indexes = std::vector(10, xrpl::uint256{kINDEX2}); - ON_CALL( - *backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _) - ) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) ); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _) ) .WillByDefault(Return( createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() )); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, seq, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuer).key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(issuer).key, seq, _)) .WillByDefault( Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() @@ -1644,9 +1596,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::to_currency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -1693,39 +1645,33 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + xrpl::to_currency("USD"), issuer, xrpl::xrpCurrency(), xrpl::xrpAccount(), std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); auto const indexes = - std::vector(BookOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX2}); + std::vector(BookOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX2}); - ON_CALL( - *backend_, doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _) - ) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, seq, _)) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) ); ON_CALL( *backend_, - doFetchLedgerObject(ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _) + doFetchLedgerObject(xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, seq, _) ) .WillByDefault(Return( createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData() )); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, seq, _)) .WillByDefault(Return(createLegacyFeeSettingBlob(1, 2, 3, 4, 0))); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuer).key, seq, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::account(issuer).key, seq, _)) .WillByDefault( Return(createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) .getSerializer() @@ -1736,9 +1682,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::to_currency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); diff --git a/tests/unit/rpc/handlers/CredentialHelpersTests.cpp b/tests/unit/rpc/handlers/CredentialHelpersTests.cpp index 4eb871a96..df35ea445 100644 --- a/tests/unit/rpc/handlers/CredentialHelpersTests.cpp +++ b/tests/unit/rpc/handlers/CredentialHelpersTests.cpp @@ -41,7 +41,7 @@ constexpr std::string_view kCREDENTIAL_TYPE = "credType"; TEST(CreateAuthCredentialsTest, UniqueCredentials) { - ripple::STArray credentials; + xrpl::STArray credentials; auto const cred1 = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); auto const cred2 = createCredentialObject(kACCOUNT2, kACCOUNT, kCREDENTIAL_TYPE); @@ -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,26 +72,26 @@ TEST(ParseAuthorizeCredentialsTest, ValidCredentialsArray) boost::json::array credentials; boost::json::object credential1; credential1[JS(issuer)] = kACCOUNT; - credential1[JS(credential_type)] = ripple::strHex(kCREDENTIAL_TYPE); + credential1[JS(credential_type)] = xrpl::strHex(kCREDENTIAL_TYPE); credentials.push_back(credential1); - ripple::STArray const parsedCredentials = credentials::parseAuthorizeCredentials(credentials); + xrpl::STArray const parsedCredentials = credentials::parseAuthorizeCredentials(credentials); ASSERT_EQ(parsedCredentials.size(), 1); - ripple::STObject const& cred = parsedCredentials[0]; - ASSERT_TRUE(cred.isFieldPresent(ripple::sfIssuer)); - ASSERT_TRUE(cred.isFieldPresent(ripple::sfCredentialType)); + xrpl::STObject const& cred = parsedCredentials[0]; + ASSERT_TRUE(cred.isFieldPresent(xrpl::sfIssuer)); + ASSERT_TRUE(cred.isFieldPresent(xrpl::sfCredentialType)); - auto const expectedIssuer = *ripple::parseBase58( + auto const expectedIssuer = *xrpl::parseBase58( static_cast(credential1[JS(issuer)].as_string()) ); auto const expectedCredentialType = - ripple::strUnHex(static_cast(credential1[JS(credential_type)].as_string())) + xrpl::strUnHex(static_cast(credential1[JS(credential_type)].as_string())) .value(); - EXPECT_EQ(cred.getAccountID(ripple::sfIssuer), expectedIssuer); - EXPECT_EQ(cred.getFieldVL(ripple::sfCredentialType), expectedCredentialType); + EXPECT_EQ(cred.getAccountID(xrpl::sfIssuer), expectedIssuer); + EXPECT_EQ(cred.getFieldVL(xrpl::sfCredentialType), expectedCredentialType); } class CredentialHelperTest : public util::prometheus::WithPrometheus, @@ -129,12 +129,11 @@ TEST_F(CredentialHelperTest, GetValidCredentialArray) boost::json::array credentialsArray = {kCREDENTIAL_ID}; - 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(kCREDENTIAL_TYPE), std::end(kCREDENTIAL_TYPE)} + xrpl::sfCredentialType, xrpl::Blob{std::begin(kCREDENTIAL_TYPE), std::end(kCREDENTIAL_TYPE)} ); expectedAuthCreds.push_back(std::move(credential)); diff --git a/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp b/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp index 5fe9909bf..bbf9c5718 100644 --- a/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp +++ b/tests/unit/rpc/handlers/DepositAuthorizedTests.cpp @@ -276,7 +276,7 @@ TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaStringSequence) TEST_F(RPCDepositAuthorizedTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -307,7 +307,7 @@ TEST_F(RPCDepositAuthorizedTest, SourceAccountDoesNotExist) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -343,7 +343,7 @@ TEST_F(RPCDepositAuthorizedTest, DestinationAccountDoesNotExist) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -352,7 +352,7 @@ 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{})); @@ -397,7 +397,7 @@ TEST_F(RPCDepositAuthorizedTest, AccountsAreEqual) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -442,7 +442,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsNoDepositAuthFlag) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); @@ -451,12 +451,12 @@ 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); @@ -497,23 +497,23 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsFals auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + 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); @@ -554,24 +554,24 @@ TEST_F(RPCDepositAuthorizedTest, DifferentAccountsWithDepositAuthFlagReturnsTrue auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + 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); @@ -615,17 +615,17 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; @@ -633,12 +633,12 @@ 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, _, _)) @@ -656,7 +656,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialAcceptedAndNotExpiredReturnsTrue) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -673,17 +673,17 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE, false); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; @@ -691,12 +691,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, _, _)) @@ -715,7 +715,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialNotAuthorizedReturnsFalse) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -735,23 +735,23 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 100); // set parent close time to 500 seconds - ledgerHeader.parentCloseTime = ripple::NetClock::time_point{std::chrono::seconds{500}}; + ledgerHeader.parentCloseTime = xrpl::NetClock::time_point{std::chrono::seconds{500}}; - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); // credential expire time is 23 seconds, so credential will fail auto const expiredCredential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE, true, 23); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; @@ -759,12 +759,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, _, _)) @@ -783,7 +783,7 @@ TEST_F(RPCDepositAuthorizedTest, CredentialExpiredReturnsFalse) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); @@ -802,17 +802,17 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; @@ -820,12 +820,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, _, _)) @@ -844,8 +844,8 @@ TEST_F(RPCDepositAuthorizedTest, DuplicateCredentialsReturnsFalse) kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex), - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex), + xrpl::strHex(credentialIndex) ) ); @@ -864,23 +864,23 @@ TEST_F(RPCDepositAuthorizedTest, NoElementsInCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + 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())); @@ -915,17 +915,17 @@ TEST_F(RPCDepositAuthorizedTest, MoreThanMaxNumberOfCredentialsReturnsFalse) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30, 34); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); auto const credential = createCredentialObject(kACCOUNT, kACCOUNT2, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT), getAccountIdWithString(kACCOUNT2), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; @@ -933,12 +933,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, _, _)) @@ -946,7 +946,7 @@ 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( fmt::format( @@ -983,19 +983,19 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillOnce(Return(ledgerHeader)); auto const account1Root = createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2); auto const account2Root = - createAccountRootObject(kACCOUNT2, ripple::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); + createAccountRootObject(kACCOUNT2, xrpl::lsfDepositAuth, 2, 200, 2, kINDEX2, 2); // reverse the subject and issuer account. Now subject is Account2 auto const credential = createCredentialObject(kACCOUNT2, kACCOUNT, kCREDENTIAL_TYPE); - auto const credentialIndex = ripple::keylet::credential( + auto const credentialIndex = xrpl::keylet::credential( getAccountIdWithString(kACCOUNT2), getAccountIdWithString(kACCOUNT), - ripple::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) + xrpl::Slice(kCREDENTIAL_TYPE.data(), kCREDENTIAL_TYPE.size()) ) .key; @@ -1003,12 +1003,12 @@ 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, _, _)) @@ -1026,7 +1026,7 @@ TEST_F(RPCDepositAuthorizedTest, DifferentSubjectAccountForCredentialReturnsFals kACCOUNT, kACCOUNT2, kLEDGER_HASH, - ripple::strHex(credentialIndex) + xrpl::strHex(credentialIndex) ) ); diff --git a/tests/unit/rpc/handlers/FeatureTests.cpp b/tests/unit/rpc/handlers/FeatureTests.cpp index 3483da0cd..5619f9f68 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{kLEDGER_HASH}, testing::_)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, 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 0e946aec3..ebb37c27d 100644 --- a/tests/unit/rpc/handlers/GatewayBalancesTests.cpp +++ b/tests/unit/rpc/handlers/GatewayBalancesTests.cpp @@ -255,7 +255,7 @@ 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) { @@ -284,7 +284,7 @@ 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) { @@ -310,8 +310,8 @@ TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaIntIndex) TEST_F(RPCGatewayBalancesHandlerTest, LedgerNotFoundViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillOnce(Return(std::optional{})); + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillOnce(Return(std::optional{})); auto const handler = AnyHandler{GatewayBalancesHandler{backend_}}; runSpawn([&](auto yield) { @@ -342,7 +342,7 @@ TEST_F(RPCGatewayBalancesHandlerTest, AccountNotFound) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)) .WillOnce(Return(std::optional{})); @@ -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())); @@ -429,25 +429,25 @@ generateNormalPathTestBundles() auto frozenState = createRippleStateLedgerObject( "JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 ); - frozenState.setFieldU32(ripple::sfFlags, ripple::lsfLowFreeze); + frozenState.setFieldU32(xrpl::sfFlags, xrpl::lsfLowFreeze); auto overflowState = createRippleStateLedgerObject( "JPY", kISSUER, 50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 ); int64_t const min64 = -9922966390934554; overflowState.setFieldAmount( - ripple::sfBalance, ripple::STAmount(getIssue("JPY", kISSUER), min64, 80) + 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 = @@ -525,7 +525,7 @@ generateNormalPathTestBundles() }, NormalTestBundle{ .testName = "NoHotwallet", - .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), + .mockedDir = createOwnerDirLedgerObject({xrpl::uint256{kINDEX2}}, kINDEX1), .mockedObjects = std::vector{createRippleStateLedgerObject( "JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123 )}, @@ -545,7 +545,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( @@ -564,10 +564,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 = @@ -625,8 +625,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{ @@ -683,8 +682,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; }; @@ -699,11 +698,11 @@ TEST_P(EscrowTest, CheckEscrowOutput) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, seq); EXPECT_CALL(*backend_, fetchLedgerBySequence(seq, _)).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(accountKk, seq, _)) .WillOnce(Return(Blob{'f', 'a', 'k', 'e'})); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; EXPECT_CALL(*backend_, doFetchLedgerObject(ownerDirKk, seq, _)) .WillOnce(Return(bundle.mockedDir.getSerializer().peekData())); @@ -736,20 +735,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({{ @@ -765,7 +764,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( @@ -781,7 +780,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({{ @@ -797,8 +796,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 e0e12e642..1a0850d56 100644 --- a/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp +++ b/tests/unit/rpc/handlers/GetAggregatePriceTests.cpp @@ -53,16 +53,16 @@ mockLedgerObject( "70726F7669646572", 64u, time, - ripple::Blob(8, 'a'), - ripple::Blob(8, 'a'), + xrpl::Blob(8, 'a'), + xrpl::Blob(8, 'a'), kRANGE_MAX - 4, - ripple::uint256{tx}, + xrpl::uint256{tx}, createPriceDataSeries({createOraclePriceData( - price, ripple::to_currency("USD"), ripple::to_currency("XRP"), scale + price, xrpl::to_currency("USD"), xrpl::to_currency("XRP"), scale )}) ); - auto const oracleIndex = ripple::keylet::oracle(getAccountIdWithString(account), docId).key; + auto const oracleIndex = xrpl::keylet::oracle(getAccountIdWithString(account), docId).key; EXPECT_CALL(backend, doFetchLedgerObject(oracleIndex, kRANGE_MAX, _)) .WillOnce(Return(oracleObject.getSerializer().peekData())); } @@ -616,16 +616,16 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NewLedgerObjectHasNoPricePair) constexpr auto kDOCUMENT_ID = 1; mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX1), _)) .WillRepeatedly(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries({createOraclePriceData( - 1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2 - )}), + createPriceDataSeries( + {createOraclePriceData(1e3, xrpl::to_currency("EUR"), xrpl::to_currency("XRP"), 2)} + ), kINDEX, true, kTX2 @@ -911,7 +911,7 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NoOracleEntryFound) constexpr auto kDOCUMENT_ID = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; + xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(oracleIndex, kRANGE_MAX, _)) .WillOnce(Return(std::nullopt)); @@ -1311,20 +1311,20 @@ TEST_F(RPCGetAggregatePriceHandlerTest, FromTx) constexpr auto kDOCUMENT_ID = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; + xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 // return a tx which contains NewFields - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX1), _)) .WillOnce(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries({createOraclePriceData( - 1e3, ripple::to_currency("JPY"), ripple::to_currency("XRP"), 2 - )}), - ripple::to_string(oracleIndex), + createPriceDataSeries( + {createOraclePriceData(1e3, xrpl::to_currency("JPY"), xrpl::to_currency("XRP"), 2)} + ), + xrpl::to_string(oracleIndex), false, kTX1 ))); @@ -1378,35 +1378,35 @@ TEST_F(RPCGetAggregatePriceHandlerTest, NotFoundInTxHistory) constexpr auto kDOCUMENT_ID = 1; auto const oracleIndex = - ripple::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; + xrpl::keylet::oracle(getAccountIdWithString(kACCOUNT), kDOCUMENT_ID).key; mockLedgerObject(*backend_, kACCOUNT, kDOCUMENT_ID, kTX1, 1e3, 2); // 10 - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX1), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX1), _)) .WillOnce(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries({createOraclePriceData( - 1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2 - )}), - ripple::to_string(oracleIndex), + createPriceDataSeries( + {createOraclePriceData(1e3, xrpl::to_currency("EUR"), xrpl::to_currency("XRP"), 2)} + ), + xrpl::to_string(oracleIndex), false, kTX2 ))); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256(kTX2), _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256(kTX2), _)) .WillRepeatedly(Return(createOracleSetTxWithMetadata( kACCOUNT, kRANGE_MAX, 123, 1, 4321u, - createPriceDataSeries({createOraclePriceData( - 1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2 - )}), - ripple::to_string(oracleIndex), + createPriceDataSeries( + {createOraclePriceData(1e3, xrpl::to_currency("EUR"), xrpl::to_currency("XRP"), 2)} + ), + xrpl::to_string(oracleIndex), false, kTX2 ))); diff --git a/tests/unit/rpc/handlers/LedgerDataTests.cpp b/tests/unit/rpc/handlers/LedgerDataTests.cpp index c18cdef7b..02f2691ba 100644 --- a/tests/unit/rpc/handlers/LedgerDataTests.cpp +++ b/tests/unit/rpc/handlers/LedgerDataTests.cpp @@ -210,7 +210,7 @@ TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerDataHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -238,7 +238,7 @@ TEST_F(RPCLedgerDataHandlerTest, MarkerNotExist) .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -286,7 +286,7 @@ TEST_F(RPCLedgerDataHandlerTest, NoMarker) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -347,7 +347,7 @@ TEST_F(RPCLedgerDataHandlerTest, Version2) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -404,7 +404,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilter) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + limitTicket); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -469,7 +469,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterAMM) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limitLine + 1); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limitLine--) != 0) { auto const line = createRippleStateLedgerObject( @@ -479,7 +479,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)); @@ -533,8 +533,8 @@ TEST_F(RPCLedgerDataHandlerTest, OutOfOrder) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(2); ON_CALL(*backend_, doFetchSuccessorKey(kFIRST_KEY, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX2}, kRANGE_MAX, _)) + .WillByDefault(Return(xrpl::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kINDEX2}, kRANGE_MAX, _)) .WillByDefault(Return(std::nullopt)); auto const line = createRippleStateLedgerObject( @@ -567,7 +567,7 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) .WillByDefault(Return(createLedgerHeader(kLEDGER_HASH, kRANGE_MAX))); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1); - ON_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillByDefault(Return(createRippleStateLedgerObject( "USD", kACCOUNT2, 10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123 ) @@ -577,10 +577,10 @@ TEST_F(RPCLedgerDataHandlerTest, Marker) auto limit = 10; std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); - ON_CALL(*backend_, doFetchSuccessorKey(ripple::uint256{kINDEX2}, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) + .WillByDefault(Return(xrpl::uint256{kINDEX2})); + ON_CALL(*backend_, doFetchSuccessorKey(xrpl::uint256{kINDEX2}, kRANGE_MAX, _)) + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0) { auto const line = createRippleStateLedgerObject( @@ -631,7 +631,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(kRANGE_MAX, _)).WillByDefault(Return(los)); @@ -672,7 +672,7 @@ TEST_F(RPCLedgerDataHandlerTest, Binary) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(limit); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0) { auto const line = createRippleStateLedgerObject( @@ -714,7 +714,7 @@ TEST_F(RPCLedgerDataHandlerTest, BinaryLimitMoreThanMax) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLIMIT_BINARY); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0u) { auto const line = createRippleStateLedgerObject( @@ -762,7 +762,7 @@ TEST_F(RPCLedgerDataHandlerTest, JsonLimitMoreThanMax) EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(LedgerDataHandler::kLIMIT_JSON); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); while ((limit--) != 0u) { auto const line = createRippleStateLedgerObject( @@ -806,7 +806,7 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPTIssuance) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .WillByDefault(Return(ripple::uint256{kINDEX2})); + .WillByDefault(Return(xrpl::uint256{kINDEX2})); auto const issuance = createMptIssuanceObject(kACCOUNT, 2, "metadata"); bbs.push_back(issuance.getSerializer().peekData()); @@ -835,7 +835,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 +849,10 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPToken) std::vector bbs; EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1); ON_CALL(*backend_, doFetchSuccessorKey(_, kRANGE_MAX, _)) - .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)); diff --git a/tests/unit/rpc/handlers/LedgerEntryTests.cpp b/tests/unit/rpc/handlers/LedgerEntryTests.cpp index 9cdefcb47..8d3a5c7fb 100644 --- a/tests/unit/rpc/handlers/LedgerEntryTests.cpp +++ b/tests/unit/rpc/handlers/LedgerEntryTests.cpp @@ -2512,7 +2512,7 @@ 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, kRANGE_MAX, _)) .WillRepeatedly(Return(std::optional{})); @@ -2536,8 +2536,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 +2548,8 @@ generateTestValuesForNormalPathTest() { auto account1 = getAccountIdWithString(kACCOUNT); auto account2 = getAccountIdWithString(kACCOUNT2); - ripple::Currency currency; - ripple::to_currency(currency, "USD"); + xrpl::Currency currency; + xrpl::to_currency(currency, "USD"); return std::vector{ NormalPathTestBundle{ @@ -2561,9 +2561,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 +2574,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400) }, @@ -2587,7 +2587,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createNftTokenPage( std::vector{std::make_pair(kTOKEN_ID, "www.ok.com")}, std::nullopt @@ -2602,7 +2602,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createCheckLedgerObject(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2614,9 +2614,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 +2628,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createOfferLedgerObject( kACCOUNT, 100, @@ -2636,7 +2636,7 @@ generateTestValuesForNormalPathTest() "USD", "XRP", kACCOUNT2, - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), kINDEX1 ) }, @@ -2649,7 +2649,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createEscrowLedgerObject(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2661,7 +2661,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createTicketLedgerObject(kACCOUNT, 0) }, NormalPathTestBundle{ @@ -2673,7 +2673,7 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256{kINDEX1}, + .expectedIndex = xrpl::uint256{kINDEX1}, .mockedEntity = createDepositPreauthLedgerObjectByAuth(kACCOUNT, kACCOUNT2) }, NormalPathTestBundle{ @@ -2685,7 +2685,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 +2697,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 +2712,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 +2729,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 +2746,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 +2763,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 +2779,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 +2801,7 @@ generateTestValuesForNormalPathTest() kACCOUNT2, kCREDENTIAL_TYPE ), - .expectedIndex = ripple::keylet::depositPreauth( + .expectedIndex = xrpl::keylet::depositPreauth( account1, credentials::createAuthCredentials(createAuthCredentialArray( std::vector{kACCOUNT2}, @@ -2828,12 +2828,12 @@ generateTestValuesForNormalPathTest() kACCOUNT2, kCREDENTIAL_TYPE ), - .expectedIndex = ripple::keylet::credential( + .expectedIndex = xrpl::keylet::credential( account1, account2, - ripple::Slice( - ripple::strUnHex(kCREDENTIAL_TYPE)->data(), - ripple::strUnHex(kCREDENTIAL_TYPE)->size() + xrpl::Slice( + xrpl::strUnHex(kCREDENTIAL_TYPE)->data(), + xrpl::strUnHex(kCREDENTIAL_TYPE)->size() ) ) .key, @@ -2852,7 +2852,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 ) @@ -2869,7 +2869,7 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::getTicketIndex(account1, 2), + .expectedIndex = xrpl::getTicketIndex(account1, 2), .mockedEntity = createTicketLedgerObject(kACCOUNT, 0) }, NormalPathTestBundle{ @@ -2884,7 +2884,7 @@ generateTestValuesForNormalPathTest() }})JSON", kACCOUNT ), - .expectedIndex = ripple::keylet::offer(account1, 2).key, + .expectedIndex = xrpl::keylet::offer(account1, 2).key, .mockedEntity = createOfferLedgerObject( kACCOUNT, 100, @@ -2892,7 +2892,7 @@ generateTestValuesForNormalPathTest() "USD", "XRP", kACCOUNT2, - ripple::toBase58(ripple::xrpAccount()), + xrpl::toBase58(xrpl::xrpAccount()), kINDEX1 ) }, @@ -2905,9 +2905,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{ @@ -2928,13 +2928,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{ @@ -2960,14 +2960,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) @@ -2995,14 +2995,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) @@ -3029,10 +3029,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) ), @@ -3065,10 +3065,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) ), @@ -3091,18 +3091,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'), kRANGE_MAX - 2, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( - 2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3 + 2e4, xrpl::to_currency("XRP"), xrpl::to_currency("USD"), 3 )}) ) }, @@ -3118,18 +3118,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'), kRANGE_MAX - 2, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( - 2e4, ripple::to_currency("XRP"), ripple::to_currency("USD"), 3 + 2e4, xrpl::to_currency("XRP"), xrpl::to_currency("USD"), 3 )}) ) }, @@ -3140,20 +3140,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'), kRANGE_MAX - 4, - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321"}, createPriceDataSeries({createOraclePriceData( - 1e3, ripple::to_currency("USD"), ripple::to_currency("XRP"), 2 + 1e3, xrpl::to_currency("USD"), xrpl::to_currency("XRP"), 2 )}) ) }, @@ -3164,9 +3164,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{ @@ -3178,8 +3178,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", @@ -3192,10 +3192,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", @@ -3206,9 +3206,9 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = xrpl::uint256(kINDEX1), .mockedEntity = createPermissionedDomainObject( - kACCOUNT, kINDEX1, kRANGE_MAX, 0, ripple::uint256{0}, 0 + kACCOUNT, kINDEX1, kRANGE_MAX, 0, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3224,13 +3224,12 @@ generateTestValuesForNormalPathTest() kACCOUNT, kRANGE_MAX ), - .expectedIndex = - ripple::keylet::permissionedDomain( - ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX - ) - .key, + .expectedIndex = xrpl::keylet::permissionedDomain( + xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX + ) + .key, .mockedEntity = createPermissionedDomainObject( - kACCOUNT, kINDEX1, kRANGE_MAX, 0, ripple::uint256{0}, 0 + kACCOUNT, kINDEX1, kRANGE_MAX, 0, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3242,16 +3241,16 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = xrpl::uint256(kINDEX1), .mockedEntity = createVault( kACCOUNT, kACCOUNT, kRANGE_MAX, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{0}, + xrpl::uint256{0}, 0 ) }, @@ -3268,20 +3267,19 @@ generateTestValuesForNormalPathTest() kACCOUNT, kRANGE_MAX ), - .expectedIndex = - ripple::keylet::vault( - ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX - ) - .key, + .expectedIndex = xrpl::keylet::vault( + xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX + ) + .key, .mockedEntity = createVault( kACCOUNT, kACCOUNT, kRANGE_MAX, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{0}, + xrpl::uint256{0}, 0 ) }, @@ -3294,9 +3292,9 @@ generateTestValuesForNormalPathTest() }})JSON", kINDEX1 ), - .expectedIndex = ripple::uint256(kINDEX1), + .expectedIndex = xrpl::uint256(kINDEX1), .mockedEntity = createLoanBroker( - kACCOUNT, kACCOUNT, kRANGE_MAX, ripple::uint256{kINDEX1}, 1, ripple::uint256{0}, 0 + kACCOUNT, kACCOUNT, kRANGE_MAX, xrpl::uint256{kINDEX1}, 1, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3312,13 +3310,12 @@ generateTestValuesForNormalPathTest() kACCOUNT, kRANGE_MAX ), - .expectedIndex = - ripple::keylet::loanbroker( - ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX - ) - .key, + .expectedIndex = xrpl::keylet::loanbroker( + xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX + ) + .key, .mockedEntity = createLoanBroker( - kACCOUNT, kACCOUNT, kRANGE_MAX, ripple::uint256{kINDEX1}, 1, ripple::uint256{0}, 0 + kACCOUNT, kACCOUNT, kRANGE_MAX, xrpl::uint256{kINDEX1}, 1, xrpl::uint256{0}, 0 ) }, NormalPathTestBundle{ @@ -3330,9 +3327,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{ @@ -3347,9 +3344,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{ @@ -3361,9 +3358,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", @@ -3378,12 +3375,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) }, }; } @@ -3418,10 +3415,10 @@ TEST_P(RPCLedgerEntryNormalPathTest, NormalPath) EXPECT_EQ(outputJson.at("ledger_index").as_uint64(), kRANGE_MAX); 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 ); }); @@ -3458,7 +3455,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalse) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3490,19 +3487,18 @@ TEST_F(RPCLedgerEntryTest, Vault_BinaryFalse) kACCOUNT, kRANGE_MAX, "XRP", - ripple::toBase58(ripple::xrpAccount()), - ripple::uint192(0), + xrpl::toBase58(xrpl::xrpAccount()), + xrpl::uint192(0), 0, - ripple::uint256{1}, + xrpl::uint256{1}, 0 ); auto const vaultKey = - ripple::keylet::vault(ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX) - .key; + xrpl::keylet::vault(xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX).key; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{ + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{ vault.getSerializer().peekData().data(), vault.getSerializer().peekData().size() }, vaultKey @@ -3543,17 +3539,15 @@ TEST_F(RPCLedgerEntryTest, LoanBroker_BinaryFalse) boost::json::object const entry; auto const loanBroker = createLoanBroker( - kACCOUNT, kACCOUNT, kRANGE_MAX, ripple::uint256{kINDEX1}, 1, ripple::uint256{1}, 0 + kACCOUNT, kACCOUNT, kRANGE_MAX, xrpl::uint256{kINDEX1}, 1, xrpl::uint256{1}, 0 ); auto const loanBrokerKey = - ripple::keylet::loanbroker( - ripple::parseBase58(kACCOUNT).value(), kRANGE_MAX - ) + xrpl::keylet::loanbroker(xrpl::parseBase58(kACCOUNT).value(), kRANGE_MAX) .key; - ripple::STLedgerEntry const sle{ - ripple::SerialIter{ + xrpl::STLedgerEntry const sle{ + xrpl::SerialIter{ loanBroker.getSerializer().peekData().data(), loanBroker.getSerializer().peekData().size() }, @@ -3602,12 +3596,12 @@ TEST_F(RPCLedgerEntryTest, Loan_BinaryFalse) auto const loan = createLoan( kACCOUNT, - ripple::uint256{kINDEX1}, + xrpl::uint256{kINDEX1}, kLOAN_SEQ, kSTART_DATE, kPAYMENT_INTERVAL, kINTEREST_RATE, - ripple::uint256{1}, + xrpl::uint256{1}, 0 ); @@ -3648,7 +3642,7 @@ TEST_F(RPCLedgerEntryTest, UnexpectedLedgerType) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3720,7 +3714,7 @@ TEST_F(RPCLedgerEntryTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerEntryTest, LedgerNotExistViaHash) { - EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + EXPECT_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillRepeatedly(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -3819,7 +3813,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleted) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -3866,11 +3860,11 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryDeleted) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(uint32_t{kRANGE_MAX})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 1, _)) .WillOnce(Return(offer.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; @@ -3895,11 +3889,11 @@ TEST_F(RPCLedgerEntryTest, LedgerEntryNotExist) { auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(uint32_t{kRANGE_MAX})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 1, _)) .WillOnce(Return(std::optional{})); runSpawn([&, this](auto yield) { @@ -3953,7 +3947,7 @@ TEST_F(RPCLedgerEntryTest, BinaryFalseIncludeDeleteFalse) // return valid ledger entry which can be deserialized auto const ledgerEntry = createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 200, 300, kINDEX1, 400); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -4017,9 +4011,9 @@ TEST_F(RPCLedgerEntryTest, ObjectUpdateIncludeDelete) auto const line2 = createRippleStateLedgerObject( "USD", kACCOUNT, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123 ); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillRepeatedly(Return(line1.getSerializer().peekData())); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 1, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 1, _)) .WillRepeatedly(Return(line2.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -4066,11 +4060,11 @@ TEST_F(RPCLedgerEntryTest, ObjectDeletedPreviously) EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); // return valid ledger entry which can be deserialized auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(uint32_t{kRANGE_MAX - 4})); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX - 5, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX - 5, _)) .WillOnce(Return(offer.getSerializer().peekData())); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerEntryHandler{backend_}}; @@ -4095,9 +4089,9 @@ TEST_F(RPCLedgerEntryTest, ObjectSeqNotExist) { auto const ledgerinfo = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillRepeatedly(Return(ledgerinfo)); - EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::optional{})); - EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(ripple::uint256{kINDEX1}, kRANGE_MAX, _)) + EXPECT_CALL(*backend_, doFetchLedgerObjectSeq(xrpl::uint256{kINDEX1}, kRANGE_MAX, _)) .WillOnce(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -4142,7 +4136,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(kLEDGER_HASH, kRANGE_MAX); EXPECT_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)) @@ -4150,9 +4144,7 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) // return valid ledger entry which can be deserialized auto const ledgerEntry = createMptIssuanceObject(kACCOUNT, 2, "metadata"); - EXPECT_CALL( - *backend_, doFetchLedgerObject(ripple::keylet::mptIssuance(mptId).key, kRANGE_MAX, _) - ) + EXPECT_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::mptIssuance(mptId).key, kRANGE_MAX, _)) .WillRepeatedly(Return(ledgerEntry.getSerializer().peekData())); runSpawn([&, this](auto yield) { @@ -4162,7 +4154,7 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID) R"JSON({{ "mpt_issuance": "{}" }})JSON", - ripple::to_string(mptId) + xrpl::to_string(mptId) ) ); auto const output = handler.process(req, Context{yield}); diff --git a/tests/unit/rpc/handlers/LedgerTests.cpp b/tests/unit/rpc/handlers/LedgerTests.cpp index 0a40c7322..e7719ef1b 100644 --- a/tests/unit/rpc/handlers/LedgerTests.cpp +++ b/tests/unit/rpc/handlers/LedgerTests.cpp @@ -232,7 +232,7 @@ TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaStringSequence) TEST_F(RPCLedgerHandlerTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(std::nullopt)); runSpawn([&, this](auto yield) { @@ -331,7 +331,7 @@ TEST_F(RPCLedgerHandlerTest, QueryViaLedgerHash) { auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kRANGE_MAX); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kINDEX1}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kINDEX1}, _)) .WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { @@ -735,7 +735,7 @@ TEST_F(RPCLedgerHandlerTest, TransactionsNotExpand) EXPECT_CALL(*backend_, fetchAllTransactionHashesInLedger).Times(1); ON_CALL(*backend_, fetchAllTransactionHashesInLedger(kRANGE_MAX, _)) - .WillByDefault(Return(std::vector{ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}})); + .WillByDefault(Return(std::vector{xrpl::uint256{kINDEX1}, xrpl::uint256{kINDEX2}})); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{LedgerHandler{backend_, mockAmendmentCenterPtr_}}; @@ -787,12 +787,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() } @@ -836,12 +836,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() } @@ -1022,7 +1022,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; auto const accountObject = createAccountRootObject( kACCOUNT, 0, kRANGE_MAX, 200 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 @@ -1034,7 +1034,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryFalse) // fee object 2*2+3->7 ; balance 200 - 7 -> 193 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRANGE_MAX, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1097,7 +1097,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; auto const accountObject = createAccountRootObject( kACCOUNT, 0, kRANGE_MAX, 200 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 @@ -1109,7 +1109,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsTrueBinaryTrue) // fee object 2*2+3->7 ; balance 200 - 7 -> 193 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRANGE_MAX, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1211,7 +1211,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) ON_CALL(*backend_, fetchLedgerBySequence(kRANGE_MAX, _)).WillByDefault(Return(ledgerHeader)); // account doFetchLedgerObject - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; auto const accountObject = createAccountRootObject( kACCOUNT, 0, kRANGE_MAX, 6 /*balance*/, 2 /*owner object*/, kINDEX1, kRANGE_MAX - 1, 0 @@ -1223,7 +1223,7 @@ TEST_F(RPCLedgerHandlerTest, OwnerFundsNotEnoughForReserve) // fee object 2*2+3->7 ; balance 6 - 7 -> -1 auto feeBlob = createLegacyFeeSettingBlob(1, 2 /*reserve inc*/, 3 /*reserve base*/, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kRANGE_MAX, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kRANGE_MAX, _)) .WillByDefault(Return(feeBlob)); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); @@ -1269,10 +1269,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::to_currency(std::string(kCURRENCY)) ) .key; ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRANGE_MAX, _)) @@ -1335,12 +1335,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::to_currency(std::string(kCURRENCY)) ) .key; ON_CALL(*backend_, doFetchLedgerObject(lineKey, kRANGE_MAX, _)) diff --git a/tests/unit/rpc/handlers/MPTHoldersTests.cpp b/tests/unit/rpc/handlers/MPTHoldersTests.cpp index 86bbd9464..e496eefe7 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 @@ -220,8 +220,8 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); auto const input = json::parse( fmt::format( @@ -249,7 +249,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); auto const input = json::parse( fmt::format( R"JSON({{ @@ -273,7 +273,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); auto const input = json::parse( fmt::format( R"JSON({{ @@ -299,7 +299,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerinfo = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerinfo)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -351,7 +351,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCMPTHoldersHandlerTest, MPTNotFound) { auto ledgerinfo = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerinfo)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); @@ -394,18 +394,18 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ ) ) .Times(1); @@ -448,18 +448,18 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID), 0); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID), 0); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ ) ) .Times(1); @@ -499,18 +499,18 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, specificLedger); ON_CALL(*backend_, fetchLedgerBySequence(specificLedger, _)).WillByDefault(Return(ledgerInfo)); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, specificLedger, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), + xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(specificLedger), @@ -550,16 +550,16 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter) }})JSON", kMPT_ID, kMPT_OUT2, - ripple::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)) + xrpl::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)) ); auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; auto const marker = getAccountIdWithString(kHOLDE_R1_ACCOUNT); ON_CALL(*backend_, fetchMPTHolders) @@ -567,12 +567,12 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter) EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_ + xrpl::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_ ) ) .Times(1); - auto const holder1AccountId = ripple::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)); + auto const holder1AccountId = xrpl::strHex(getAccountIdWithString(kHOLDE_R1_ACCOUNT)); auto const input = json::parse( fmt::format( R"JSON({{ @@ -608,12 +608,12 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); - auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); + auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = { mptoken1.getSerializer().peekData(), mptoken2.getSerializer().peekData() }; @@ -622,7 +622,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs) EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ + xrpl::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_ ) ) .Times(1); @@ -659,18 +659,18 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx) auto ledgerInfo = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerInfo)); - auto const issuanceKk = ripple::keylet::mptIssuance(ripple::uint192(kMPT_ID)).key; + auto const issuanceKk = xrpl::keylet::mptIssuance(xrpl::uint192(kMPT_ID)).key; ON_CALL(*backend_, doFetchLedgerObject(issuanceKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); - auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); + auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, xrpl::uint192(kMPT_ID)); std::vector const mpts = {mptoken.getSerializer().peekData()}; ON_CALL(*backend_, fetchMPTHolders) .WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}})); EXPECT_CALL( *backend_, fetchMPTHolders( - ripple::uint192(kMPT_ID), + xrpl::uint192(kMPT_ID), Const(MPTHoldersHandler::kLIMIT_MAX), testing::Eq(std::nullopt), Const(30), diff --git a/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp b/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp index 756983d09..583c97f5c 100644 --- a/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTBuyOffersTests.cpp @@ -209,8 +209,8 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -239,7 +239,7 @@ 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( fmt::format( @@ -266,7 +266,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -318,7 +318,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTBuyOffersHandlerTest, NoNFT) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::nullopt)); @@ -366,7 +366,7 @@ 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) { @@ -433,9 +433,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{kNFT_ID}); + auto const directory = xrpl::keylet::nft_buys(xrpl::uint256{kNFT_ID}); 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())); @@ -474,16 +474,16 @@ TEST_F(RPCNFTBuyOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 500; auto const offer = createNftBuyOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -523,29 +523,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(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorBuyOffer = createNftBuyOffer(kNFT_ID, kACCOUNT); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorBuyOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_buys(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(3); @@ -587,29 +587,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(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorBuyOffer = createNftBuyOffer(kNFT_ID, kACCOUNT); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorBuyOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_buys(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(7); @@ -676,9 +676,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_buys(xrpl::uint256{kNFT_ID}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTBuyOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTBuyOffersHandler::kLIMIT_MIN + 1, xrpl::uint256{kINDEX1}}, kINDEX1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -721,9 +721,9 @@ TEST_F(RPCNFTBuyOffersHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_buys(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_buys(xrpl::uint256{kNFT_ID}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTBuyOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTBuyOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) diff --git a/tests/unit/rpc/handlers/NFTHistoryTests.cpp b/tests/unit/rpc/handlers/NFTHistoryTests.cpp index 003da307a..8c185c3a4 100644 --- a/tests/unit/rpc/handlers/NFTHistoryTests.cpp +++ b/tests/unit/rpc/handlers/NFTHistoryTests.cpp @@ -252,21 +252,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); @@ -982,7 +980,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash) auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); runSpawn([&, this](auto yield) { diff --git a/tests/unit/rpc/handlers/NFTInfoTests.cpp b/tests/unit/rpc/handlers/NFTInfoTests.cpp index 55b0999c0..2037dfbb6 100644 --- a/tests/unit/rpc/handlers/NFTInfoTests.cpp +++ b/tests/unit/rpc/handlers/NFTInfoTests.cpp @@ -141,8 +141,8 @@ TEST_F(RPCNFTInfoHandlerTest, NFTIDNotString) TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -171,7 +171,7 @@ 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( fmt::format( @@ -196,7 +196,7 @@ 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( fmt::format( @@ -223,7 +223,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -275,12 +275,12 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTInfoHandlerTest, NonExistNFT) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch nft return empty ON_CALL(*backend_, fetchNFT).WillByDefault(Return(std::optional{})); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); auto const input = json::parse( fmt::format( R"JSON({{ @@ -325,7 +325,7 @@ TEST_F(RPCNFTInfoHandlerTest, DefaultParameters) // fetch nft return something auto const nft = std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); auto const input = json::parse( fmt::format( @@ -366,10 +366,10 @@ TEST_F(RPCNFTInfoHandlerTest, BurnedNFT) // fetch nft return something auto const nft = std::make_optional( - createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, ripple::Blob{'u', 'r', 'i'}, true) + createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, xrpl::Blob{'u', 'r', 'i'}, true) ); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); auto const input = json::parse( fmt::format( @@ -410,9 +410,9 @@ TEST_F(RPCNFTInfoHandlerTest, NotBurnedNFTWithoutURI) // fetch nft return something auto const nft = - std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, ripple::Blob{})); + std::make_optional(createNft(kNFT_ID, kACCOUNT, ledgerHeader.seq, xrpl::Blob{})); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID}, 30, _)).Times(1); auto const input = json::parse( fmt::format( @@ -454,7 +454,7 @@ TEST_F(RPCNFTInfoHandlerTest, NFTWithExtraFieldsSet) // fetch nft return something auto const nft = std::make_optional(createNft(kNFT_ID2, kACCOUNT, ledgerHeader.seq)); ON_CALL(*backend_, fetchNFT).WillByDefault(Return(nft)); - EXPECT_CALL(*backend_, fetchNFT(ripple::uint256{kNFT_ID2}, 30, _)).Times(1); + EXPECT_CALL(*backend_, fetchNFT(xrpl::uint256{kNFT_ID2}, 30, _)).Times(1); auto const input = json::parse( fmt::format( diff --git a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp index 488187965..8896458db 100644 --- a/tests/unit/rpc/handlers/NFTSellOffersTests.cpp +++ b/tests/unit/rpc/handlers/NFTSellOffersTests.cpp @@ -209,8 +209,8 @@ TEST_F(RPCNFTSellOffersHandlerTest, NFTIDNotString) TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -239,7 +239,7 @@ 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( fmt::format( @@ -266,7 +266,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -318,7 +318,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTSellOffersHandlerTest, NoNFT) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::nullopt)); @@ -366,7 +366,7 @@ 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) { @@ -433,9 +433,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{kNFT_ID}); + auto const directory = xrpl::keylet::nft_sells(xrpl::uint256{kNFT_ID}); 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())); @@ -474,16 +474,16 @@ TEST_F(RPCNFTSellOffersHandlerTest, MultipleResultsWithMarkerAndLimitOutput) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index - std::vector indexes; + std::vector indexes; std::vector bbs; auto repetitions = 500; auto const offer = createNftSellOffer(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); ON_CALL(*backend_, doFetchLedgerObject) .WillByDefault(Return(ownerDir.getSerializer().peekData())); @@ -523,29 +523,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(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorSellOffer = createNftSellOffer(kNFT_ID, kACCOUNT); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorSellOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_sells(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(3); @@ -587,29 +587,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(kNFT_ID, kACCOUNT); - auto idx = ripple::uint256{kINDEX1}; + auto idx = xrpl::uint256{kINDEX1}; while ((repetitions--) != 0) { indexes.push_back(idx++); bbs.push_back(offer.getSerializer().peekData()); } - ripple::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); + xrpl::STObject const ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1); auto const cursorSellOffer = createNftSellOffer(kNFT_ID, kACCOUNT); // first is nft offer object auto const cursor = - ripple::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; - auto const first = ripple::keylet::nftoffer(cursor); + xrpl::uint256{"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC353"}; + auto const first = xrpl::keylet::nftoffer(cursor); ON_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)) .WillByDefault(Return(cursorSellOffer.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(first.key, testing::_, testing::_)).Times(1); - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_sells(xrpl::uint256{kNFT_ID}); auto const startHint = 0ul; // offer node is hardcoded to 0ul - auto const secondKey = ripple::keylet::page(directory, startHint).key; + auto const secondKey = xrpl::keylet::page(directory, startHint).key; ON_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject(secondKey, testing::_, testing::_)).Times(7); @@ -676,9 +676,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitLessThanMin) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_sells(xrpl::uint256{kNFT_ID}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLIMIT_MIN + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTSellOffersHandler::kLIMIT_MIN + 1, xrpl::uint256{kINDEX1}}, kINDEX1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) @@ -721,9 +721,9 @@ TEST_F(RPCNFTSellOffersHandlerTest, LimitMoreThanMax) EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); // return owner index containing 2 indexes - auto const directory = ripple::keylet::nft_sells(ripple::uint256{kNFT_ID}); + auto const directory = xrpl::keylet::nft_sells(xrpl::uint256{kNFT_ID}); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NFTSellOffersHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NFTSellOffersHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1 ); ON_CALL(*backend_, doFetchLedgerObject(directory.key, testing::_, testing::_)) diff --git a/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp b/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp index 520bf7632..d50423550 100644 --- a/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp +++ b/tests/unit/rpc/handlers/NFTsByIssuerTest.cpp @@ -203,8 +203,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash) { // mock fetchLedgerByHash return empty EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) - .WillByDefault(Return(std::optional{})); + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) + .WillByDefault(Return(std::optional{})); auto const input = json::parse( fmt::format( @@ -232,7 +232,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerStringIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); auto const input = json::parse( fmt::format( R"JSON({{ @@ -256,7 +256,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIntIndex) { // mock fetchLedgerBySequence return empty EXPECT_CALL(*backend_, fetchLedgerBySequence) - .WillOnce(Return(std::optional{})); + .WillOnce(Return(std::optional{})); auto const input = json::parse( fmt::format( R"JSON({{ @@ -282,7 +282,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash2) { // mock fetchLedgerByHash return ledger but seq is 31 > 30 auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); auto const input = json::parse( @@ -334,7 +334,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIndex2) TEST_F(RPCNFTsByIssuerHandlerTest, AccountNotFound) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); ON_CALL(*backend_, doFetchLedgerObject).WillByDefault(Return(std::optional{})); @@ -377,7 +377,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); @@ -436,7 +436,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'})); @@ -485,7 +485,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); @@ -532,16 +532,16 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MarkerParameter) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); std::vector const nfts = {createNft(kNFT_ID3, kACCOUNT, 29)}; auto const account = getAccountIdWithString(kACCOUNT); ON_CALL(*backend_, fetchNFTsByIssuer) - .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = ripple::uint256{kNFT_ID3}})); + .WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = xrpl::uint256{kNFT_ID3}})); EXPECT_CALL( - *backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(ripple::uint256{kNFT_ID1}), _) + *backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(xrpl::uint256{kNFT_ID1}), _) ) .Times(1); @@ -581,7 +581,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); @@ -630,7 +630,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax) auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); - auto const accountKk = ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key; + auto const accountKk = xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(accountKk, 30, _)) .WillByDefault(Return(Blob{'f', 'a', 'k', 'e'})); diff --git a/tests/unit/rpc/handlers/NoRippleCheckTests.cpp b/tests/unit/rpc/handlers/NoRippleCheckTests.cpp index c5edf43c7..da43053d0 100644 --- a/tests/unit/rpc/handlers/NoRippleCheckTests.cpp +++ b/tests/unit/rpc/handlers/NoRippleCheckTests.cpp @@ -194,7 +194,7 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaHash) { EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // return empty ledgerHeader - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(std::nullopt)); static auto const kINPUT = json::parse( @@ -279,7 +279,7 @@ TEST_F(RPCNoRippleCheckTest, LedgerNotExistViaStringIndex) TEST_F(RPCNoRippleCheckTest, AccountNotExist) { auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return empty @@ -320,30 +320,30 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleSetTrustLineNoRipple })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData() - )); + .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, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -387,7 +387,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleUserDefaultRippleUnsetTrustLineNoRipp })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -397,8 +397,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); @@ -452,30 +452,30 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleSetTrustLineNoRip })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData() - )); + .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, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -518,7 +518,7 @@ TEST_F(RPCNoRippleCheckTest, NormalPathRoleGatewayDefaultRippleUnsetTrustLineNoR })JSON"; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -528,8 +528,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); @@ -576,7 +576,7 @@ TEST_F( static constexpr auto kSEQ = 30; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -586,11 +586,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); @@ -635,30 +635,30 @@ TEST_F(RPCNoRippleCheckTest, NormalPathLimit) constexpr auto kSEQ = 30; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData() - )); + .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, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -738,13 +738,13 @@ TEST_F(RPCNoRippleCheckTest, NormalPathTransactions) }})JSON", kTRANSACTION_SEQ, kTRANSACTION_SEQ + 1, - ripple::tfClearNoRipple, + xrpl::tfClearNoRipple, kTRANSACTION_SEQ + 2, - ripple::tfClearNoRipple + xrpl::tfClearNoRipple ); auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag @@ -756,20 +756,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, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); auto const line2 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; @@ -804,27 +804,27 @@ TEST_F(RPCNoRippleCheckTest, LimitMoreThanMax) constexpr auto kSEQ = 30; auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, kSEQ); - ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)) + ON_CALL(*backend_, fetchLedgerByHash(xrpl::uint256{kLEDGER_HASH}, _)) .WillByDefault(Return(ledgerHeader)); EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1); // fetch account object return valid account with DefaultRippleSet flag ON_CALL(*backend_, doFetchLedgerObject) - .WillByDefault(Return( - createAccountRootObject(kACCOUNT, ripple::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) - .getSerializer() - .peekData() - )); + .WillByDefault( + Return(createAccountRootObject(kACCOUNT, xrpl::lsfDefaultRipple, 2, 200, 2, kINDEX1, 2) + .getSerializer() + .peekData()) + ); auto const ownerDir = createOwnerDirLedgerObject( - std::vector{NoRippleCheckHandler::kLIMIT_MAX + 1, ripple::uint256{kINDEX1}}, kINDEX1 + std::vector{NoRippleCheckHandler::kLIMIT_MAX + 1, xrpl::uint256{kINDEX1}}, kINDEX1 ); - auto const ownerDirKk = ripple::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; + auto const ownerDirKk = xrpl::keylet::ownerDir(getAccountIdWithString(kACCOUNT)).key; ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, kSEQ, _)) .WillByDefault(Return(ownerDir.getSerializer().peekData())); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2); auto const line1 = createRippleStateLedgerObject( - "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, ripple::lsfLowNoRipple + "USD", kISSUER, 100, kACCOUNT, 10, kACCOUNT2, 20, kTXN_ID, 123, xrpl::lsfLowNoRipple ); std::vector bbs; diff --git a/tests/unit/rpc/handlers/SubscribeTests.cpp b/tests/unit/rpc/handlers/SubscribeTests.cpp index 2e3e78acf..54ed44647 100644 --- a/tests/unit/rpc/handlers/SubscribeTests.cpp +++ b/tests/unit/rpc/handlers/SubscribeTests.cpp @@ -807,57 +807,46 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + xrpl::to_currency("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::to_currency("USD"), issuer, std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); ON_CALL( - *backend_, - doFetchSuccessorKey(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) + *backend_, doFetchSuccessorKey(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) ) .WillByDefault(Return(std::nullopt)); ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(4); // 2 book dirs + 2 issuer global freeze + 2 transferRate + 1 owner root + 1 fee EXPECT_CALL(*backend_, doFetchLedgerObject).Times(8); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); + auto const indexes = std::vector(10, xrpl::uint256{kINDEX2}); ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) + *backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) ) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) ); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kINDEX1}); + auto const indexes2 = std::vector(10, xrpl::uint256{kINDEX1}); ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _) + *backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _) ) .WillByDefault( Return(createOwnerDirLedgerObject(indexes2, kINDEX2).getSerializer().peekData()) @@ -867,7 +856,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _ + xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _ ) ) .WillByDefault(Return( @@ -878,7 +867,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _ + xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _ ) ) .WillByDefault(Return( @@ -887,16 +876,16 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kMAX_SEQ, _)) .WillByDefault(Return(feeBlob)); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -907,10 +896,10 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); @@ -1021,56 +1010,45 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) auto const getsXRPPaysUSDBook = getBookBase( rpc::parseBook( - ripple::to_currency("USD"), - issuer, - ripple::xrpCurrency(), - ripple::xrpAccount(), - std::nullopt + xrpl::to_currency("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::to_currency("USD"), issuer, std::nullopt ) .value() ); ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR})); ON_CALL( - *backend_, - doFetchSuccessorKey(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) + *backend_, doFetchSuccessorKey(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) ) .WillByDefault(Return(std::nullopt)); ON_CALL(*backend_, doFetchSuccessorKey(reversedBook, kMAX_SEQ, _)) - .WillByDefault(Return(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); + .WillByDefault(Return(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR})); EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(2); EXPECT_CALL(*backend_, doFetchLedgerObject).Times(5); - auto const indexes = std::vector(10, ripple::uint256{kINDEX2}); + auto const indexes = std::vector(10, xrpl::uint256{kINDEX2}); ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) + *backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, kMAX_SEQ, _) ) .WillByDefault( Return(createOwnerDirLedgerObject(indexes, kINDEX1).getSerializer().peekData()) ); // for reverse - auto const indexes2 = std::vector(10, ripple::uint256{kINDEX1}); + auto const indexes2 = std::vector(10, xrpl::uint256{kINDEX1}); ON_CALL( - *backend_, - doFetchLedgerObject(ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _) + *backend_, doFetchLedgerObject(xrpl::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, kMAX_SEQ, _) ) .WillByDefault( Return(createOwnerDirLedgerObject(indexes2, kINDEX2).getSerializer().peekData()) @@ -1080,7 +1058,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _ + xrpl::keylet::account(getAccountIdWithString(kACCOUNT2)).key, kMAX_SEQ, _ ) ) .WillByDefault(Return( @@ -1091,7 +1069,7 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) ON_CALL( *backend_, doFetchLedgerObject( - ripple::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _ + xrpl::keylet::account(getAccountIdWithString(kACCOUNT)).key, kMAX_SEQ, _ ) ) .WillByDefault(Return( @@ -1100,16 +1078,16 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) // fee auto feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0); - ON_CALL(*backend_, doFetchLedgerObject(ripple::keylet::fees().key, kMAX_SEQ, _)) + ON_CALL(*backend_, doFetchLedgerObject(xrpl::keylet::fees().key, kMAX_SEQ, _)) .WillByDefault(Return(feeBlob)); auto const gets10XRPPays20USDOffer = createOfferLedgerObject( kACCOUNT2, 10, 20, - ripple::to_string(ripple::xrpCurrency()), - ripple::to_string(ripple::to_currency("USD")), - toBase58(ripple::xrpAccount()), + xrpl::to_string(xrpl::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + toBase58(xrpl::xrpAccount()), kACCOUNT, kPAYS20_USD_GETS10_XRP_BOOK_DIR ); @@ -1120,10 +1098,10 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet) kACCOUNT, 10, 20, - ripple::to_string(ripple::to_currency("USD")), - ripple::to_string(ripple::xrpCurrency()), + xrpl::to_string(xrpl::to_currency("USD")), + xrpl::to_string(xrpl::xrpCurrency()), kACCOUNT, - toBase58(ripple::xrpAccount()), + toBase58(xrpl::xrpAccount()), kPAYS20_XRP_GETS10_USD_BOOK_DIR ); diff --git a/tests/unit/rpc/handlers/TransactionEntryTests.cpp b/tests/unit/rpc/handlers/TransactionEntryTests.cpp index 6e841a52c..2e12f6ef5 100644 --- a/tests/unit/rpc/handlers/TransactionEntryTests.cpp +++ b/tests/unit/rpc/handlers/TransactionEntryTests.cpp @@ -66,8 +66,8 @@ 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( @@ -95,7 +95,7 @@ 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( fmt::format( @@ -120,7 +120,7 @@ TEST_F(RPCTransactionEntryHandlerTest, TXNotFound) { ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kINDEX, 30))); EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1); - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillByDefault(Return(std::optional{})); EXPECT_CALL(*backend_, fetchTransaction).Times(1); runSpawn([this](auto yield) { @@ -152,7 +152,7 @@ TEST_F(RPCTransactionEntryHandlerTest, LedgerSeqNotMatch) .peekData(); tx.date = 123456; tx.ledgerSequence = 10; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(createLedgerHeader(kINDEX, 30))); @@ -227,7 +227,7 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPath) .peekData(); tx.date = 123456; tx.ledgerSequence = 30; - ON_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); + ON_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillByDefault(Return(tx)); EXPECT_CALL(*backend_, fetchTransaction).Times(1); ON_CALL(*backend_, fetchLedgerBySequence) @@ -303,7 +303,7 @@ TEST_F(RPCTransactionEntryHandlerTest, NormalPathV2) .peekData(); tx.date = 123456; tx.ledgerSequence = 30; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); EXPECT_CALL(*backend_, fetchLedgerBySequence) .WillOnce(Return(createLedgerHeader(kINDEX, tx.ledgerSequence))); diff --git a/tests/unit/rpc/handlers/TxTests.cpp b/tests/unit/rpc/handlers/TxTests.cpp index fae08efc0..b23a8b200 100644 --- a/tests/unit/rpc/handlers/TxTests.cpp +++ b/tests/unit/rpc/handlers/TxTests.cpp @@ -162,7 +162,7 @@ TEST_F(RPCTxTest, InvalidBinaryV1) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -234,7 +234,7 @@ TEST_F(RPCTxTest, InvalidLgrRange) TEST_F(RPCTxTest, TxnNotFound) { - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -264,7 +264,7 @@ TEST_F(RPCTxTest, TxnNotFound) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) { backend_->setRange(10, 30); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -297,7 +297,7 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse) TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue) { backend_->setRange(1, 1000); - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)) + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)) .WillOnce(Return(std::optional{})); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); @@ -373,7 +373,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -407,7 +407,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v1) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -441,7 +441,7 @@ TEST_F(RPCTxTest, PaymentTx_API_v2) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)) .WillOnce(Return(std::nullopt)); @@ -480,7 +480,7 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, tx.ledgerSequence); EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _)) .WillOnce(Return(ledgerHeader)); @@ -529,7 +529,7 @@ TEST_F(RPCTxTest, ReturnBinary) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -577,7 +577,7 @@ TEST_F(RPCTxTest, ReturnBinaryWithCTID) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -664,7 +664,7 @@ TEST_F(RPCTxTest, MintNFT) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -694,7 +694,7 @@ TEST_F(RPCTxTest, NFTAcceptOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -724,7 +724,7 @@ TEST_F(RPCTxTest, NFTCancelOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -763,7 +763,7 @@ TEST_F(RPCTxTest, NFTCreateOffer) tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -936,7 +936,7 @@ TEST_F(RPCTxTest, ReturnCTIDForTxInput) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); @@ -1008,7 +1008,7 @@ TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable) .peekData(); tx.date = 123456; tx.ledgerSequence = 100; - EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); + EXPECT_CALL(*backend_, fetchTransaction(xrpl::uint256{kTXN_ID}, _)).WillOnce(Return(tx)); auto const rawETLPtr = dynamic_cast(mockETLServicePtr_.get()); ASSERT_NE(rawETLPtr, nullptr); diff --git a/tests/unit/rpc/handlers/UnsubscribeTests.cpp b/tests/unit/rpc/handlers/UnsubscribeTests.cpp index 46c94ff5d..37ef191cb 100644 --- a/tests/unit/rpc/handlers/UnsubscribeTests.cpp +++ b/tests/unit/rpc/handlers/UnsubscribeTests.cpp @@ -623,7 +623,7 @@ TEST_F(RPCUnsubscribeTest, Books) auto const book = parsedBookMaybe.value(); EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(book, _)).Times(1); - EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(ripple::reversed(book), _)).Times(1); + EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(xrpl::reversed(book), _)).Times(1); runSpawn([&, this](auto yield) { auto const handler = AnyHandler{UnsubscribeHandler{mockSubscriptionManagerPtr_}}; diff --git a/tests/unit/rpc/handlers/VaultInfoTests.cpp b/tests/unit/rpc/handlers/VaultInfoTests.cpp index 326fe69cb..458ce446e 100644 --- a/tests/unit/rpc/handlers/VaultInfoTests.cpp +++ b/tests/unit/rpc/handlers/VaultInfoTests.cpp @@ -220,7 +220,7 @@ TEST_F(RPCVaultInfoHandlerTest, VaultIDFailsVaultDeserializationReturnsEntryNotF EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader)); // Mock: vault_id exists, but data is not a valid vault object - ripple::uint256 const vaultKey = ripple::uint256{kVAULT_ID}; + xrpl::uint256 const vaultKey = xrpl::uint256{kVAULT_ID}; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKey, kSEQ, _)) .WillOnce(Return(std::nullopt)); // intentionally invalid vault @@ -251,8 +251,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 +268,8 @@ TEST_F(RPCVaultInfoHandlerTest, MissingIssuanceObject) prevTxSeq ); - auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVAULT_ID}).key; - auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; + auto const vaultKeylet = xrpl::keylet::vault(xrpl::uint256{kVAULT_ID}).key; + auto const mptIssuance = xrpl::keylet::mptIssuance(mptSharesID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSEQ, _)) .WillOnce(Return(vault.getSerializer().peekData())); @@ -341,8 +341,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 +361,8 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID) // Set up keylet based on vaultID auto const issuance = createMptIssuanceObject(kACCOUNT, kSEQ, "metadata"); - auto const vaultKeylet = ripple::keylet::vault(ripple::uint256{kVAULT_ID}).key; - auto const mptIssuance = ripple::keylet::mptIssuance(mptSharesID).key; + auto const vaultKeylet = xrpl::keylet::vault(xrpl::uint256{kVAULT_ID}).key; + auto const mptIssuance = xrpl::keylet::mptIssuance(mptSharesID).key; EXPECT_CALL(*backend_, doFetchLedgerObject(vaultKeylet, kSEQ, _)) .WillOnce(Return(vault.getSerializer().peekData())); @@ -433,8 +433,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 +455,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())); diff --git a/tests/unit/util/AccountUtilsTests.cpp b/tests/unit/util/AccountUtilsTests.cpp index 2e13e9948..4f7104414 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 42c1cfe5e..44e515af2 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 kTESTED_TYPES = util::LedgerTypes::getDeletionBlockerLedgerTypes(); - static constexpr ripple::LedgerEntryType kDELETION_BLOCKERS[] = { - ripple::ltCHECK, - ripple::ltESCROW, - ripple::ltNFTOKEN_PAGE, - ripple::ltPAYCHAN, - ripple::ltRIPPLE_STATE, - ripple::ltXCHAIN_OWNED_CLAIM_ID, - ripple::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID, - ripple::ltBRIDGE, - ripple::ltMPTOKEN_ISSUANCE, - ripple::ltMPTOKEN, - ripple::ltPERMISSIONED_DOMAIN + static constexpr xrpl::LedgerEntryType kDELETION_BLOCKERS[] = { + xrpl::ltCHECK, + xrpl::ltESCROW, + xrpl::ltNFTOKEN_PAGE, + xrpl::ltPAYCHAN, + xrpl::ltRIPPLE_STATE, + xrpl::ltXCHAIN_OWNED_CLAIM_ID, + xrpl::ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID, + xrpl::ltBRIDGE, + xrpl::ltMPTOKEN_ISSUANCE, + xrpl::ltMPTOKEN, + xrpl::ltPERMISSIONED_DOMAIN }; static_assert(std::size(kDELETION_BLOCKERS) == kTESTED_TYPES.size()); @@ -93,92 +93,92 @@ TEST(LedgerUtilsTests, DeletionBlockerTypes) struct LedgerEntryTypeParam { std::string input; - ripple::LedgerEntryType expected; + xrpl::LedgerEntryType expected; }; static LedgerEntryTypeParam const kCHAIN_TEST_CASES[] = { // Using RPC name with exact match - {.input = "amendments", .expected = ripple::ltAMENDMENTS}, - {.input = "directory", .expected = ripple::ltDIR_NODE}, - {.input = "fee", .expected = ripple::ltFEE_SETTINGS}, - {.input = "hashes", .expected = ripple::ltLEDGER_HASHES}, - {.input = "nunl", .expected = ripple::ltNEGATIVE_UNL}, + {.input = "amendments", .expected = xrpl::ltAMENDMENTS}, + {.input = "directory", .expected = xrpl::ltDIR_NODE}, + {.input = "fee", .expected = xrpl::ltFEE_SETTINGS}, + {.input = "hashes", .expected = xrpl::ltLEDGER_HASHES}, + {.input = "nunl", .expected = xrpl::ltNEGATIVE_UNL}, // Using canonical name with exact match - {.input = "Amendments", .expected = ripple::ltAMENDMENTS}, - {.input = "DirectoryNode", .expected = ripple::ltDIR_NODE}, - {.input = "FeeSettings", .expected = ripple::ltFEE_SETTINGS}, - {.input = "LedgerHashes", .expected = ripple::ltLEDGER_HASHES}, - {.input = "NegativeUNL", .expected = ripple::ltNEGATIVE_UNL} + {.input = "Amendments", .expected = xrpl::ltAMENDMENTS}, + {.input = "DirectoryNode", .expected = xrpl::ltDIR_NODE}, + {.input = "FeeSettings", .expected = xrpl::ltFEE_SETTINGS}, + {.input = "LedgerHashes", .expected = xrpl::ltLEDGER_HASHES}, + {.input = "NegativeUNL", .expected = xrpl::ltNEGATIVE_UNL} }; static LedgerEntryTypeParam const kACCOUNT_OWNED_TEST_CASES[] = { // Using RPC name with exact match - {.input = "account", .expected = ripple::ltACCOUNT_ROOT}, - {.input = "check", .expected = ripple::ltCHECK}, - {.input = "deposit_preauth", .expected = ripple::ltDEPOSIT_PREAUTH}, - {.input = "escrow", .expected = ripple::ltESCROW}, - {.input = "offer", .expected = ripple::ltOFFER}, - {.input = "payment_channel", .expected = ripple::ltPAYCHAN}, - {.input = "signer_list", .expected = ripple::ltSIGNER_LIST}, - {.input = "state", .expected = ripple::ltRIPPLE_STATE}, - {.input = "ticket", .expected = ripple::ltTICKET}, - {.input = "nft_offer", .expected = ripple::ltNFTOKEN_OFFER}, - {.input = "nft_page", .expected = ripple::ltNFTOKEN_PAGE}, - {.input = "amm", .expected = ripple::ltAMM}, - {.input = "bridge", .expected = ripple::ltBRIDGE}, - {.input = "xchain_owned_claim_id", .expected = ripple::ltXCHAIN_OWNED_CLAIM_ID}, + {.input = "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 kCASE_INSENSITIVE_TEST_CASES[] = { // With canonical name in mixedcase - {.input = "mPtOKenIssuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, + {.input = "mPtOKenIssuance", .expected = xrpl::ltMPTOKEN_ISSUANCE}, // With canonical name in lowercase - {.input = "mptokenissuance", .expected = ripple::ltMPTOKEN_ISSUANCE}, + {.input = "mptokenissuance", .expected = xrpl::ltMPTOKEN_ISSUANCE}, }; static LedgerEntryTypeParam const kINVALID_TEST_CASES[] = { - {.input = "", .expected = ripple::ltANY}, - {.input = "1234", .expected = ripple::ltANY}, - {.input = "unknown", .expected = ripple::ltANY}, + {.input = "", .expected = xrpl::ltANY}, + {.input = "1234", .expected = xrpl::ltANY}, + {.input = "unknown", .expected = xrpl::ltANY}, // With RPC name with inexact match - {.input = "MPT_Issuance", .expected = ripple::ltANY} + {.input = "MPT_Issuance", .expected = xrpl::ltANY} }; class LedgerEntryTypeFromStrTest : public ::testing::TestWithParam {}; @@ -232,7 +232,7 @@ INSTANTIATE_TEST_SUITE_P( std::end(kCASE_INSENSITIVE_TEST_CASES) ); v.insert(v.end(), std::begin(kINVALID_TEST_CASES), std::end(kINVALID_TEST_CASES)); - v.push_back({"amendments", ripple::ltANY}); // chain type should return ltANY + v.push_back({"amendments", xrpl::ltANY}); // chain type should return ltANY return v; }()) ); diff --git a/tests/unit/util/ShasumTests.cpp b/tests/unit/util/ShasumTests.cpp index deadc655e..d35e9cb38 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(kEMPTY_HASH)); 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(kEMPTY_HASH)); 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(kHELLO_WORLD_HASH)); 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(kHELLO_WORLD_HASH)); EXPECT_EQ(result, expected); } diff --git a/tests/unit/util/TimeUtilsTests.cpp b/tests/unit/util/TimeUtilsTests.cpp index 3f8415c1a..05edd8008 100644 --- a/tests/unit/util/TimeUtilsTests.cpp +++ b/tests/unit/util/TimeUtilsTests.cpp @@ -73,6 +73,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::epoch_offset); } 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 a3af38ab9..229efb92a 100644 --- a/tests/unit/web/AdminVerificationTests.cpp +++ b/tests/unit/web/AdminVerificationTests.cpp @@ -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::www_authenticate), "")); } struct MakeAdminVerificationStrategyTestParams { diff --git a/tests/unit/web/ServerTests.cpp b/tests/unit/web/ServerTests.cpp index 04fcb09ce..b94e10d9e 100644 --- a/tests/unit/web/ServerTests.cpp +++ b/tests/unit/web/ServerTests.cpp @@ -650,7 +650,7 @@ INSTANTIATE_TEST_CASE_P( WebServerAdminTestParams{ .config = jsonServerConfigWithAdminPassword(tests::util::generateFreePort()), .headers = {WebHeader( - http::field::authentication_info, + http::field::www_authenticate, fmt::format( "{}{}", PasswordAdminVerificationStrategy::kPASSWORD_PREFIX,