chore: Revert extra commits for 2.4.1 (#2133)

src/etl/ETLService.hpp

@@ -182,10 +182,6 @@ public:
             ret = std::make_shared<etl::ETLService>(config, ioc, backend, subscriptions, balancer, ledgers);
         }
 
-        // inject networkID into subscriptions, as transaction feed require it to inject CTID in response
-        if (auto const state = ret->getETLState(); state)
-            subscriptions->setNetworkID(state->networkID);
-
         ret->run();
         return ret;
     }

src/etl/ETLState.cpp

@@ -40,7 +40,7 @@ tag_invoke(boost::json::value_to_tag<ETLState>, boost::json::value const& jv)
     if (jsonObject.contains(JS(result)) && jsonObject.at(JS(result)).as_object().contains(JS(info))) {
         auto const rippledInfo = jsonObject.at(JS(result)).as_object().at(JS(info)).as_object();
         if (rippledInfo.contains(JS(network_id)))
-            state.networkID = boost::json::value_to<int64_t>(rippledInfo.at(JS(network_id)));
+            state.networkID.emplace(boost::json::value_to<int64_t>(rippledInfo.at(JS(network_id))));
     }
 
     return state;

src/etl/ETLState.hpp

@@ -38,12 +38,7 @@ namespace etl {
  * @brief This class is responsible for fetching and storing the state of the ETL information, such as the network id
  */
 struct ETLState {
-    /*
+    std::optional<uint32_t> networkID;
-     * NOTE: Rippled NetworkID: Mainnet = 0; Testnet = 1; Devnet = 2
-     * However, if rippled is running on neither of these (ie. standalone mode) rippled will default to 0, but
-     * is not included in the stateOpt response. Must manually add it here.
-     */
-    uint32_t networkID{0};
 
     /**
      * @brief Fetch the ETL state from the rippled server

src/etl/LoadBalancer.cpp

@@ -174,11 +174,12 @@ LoadBalancer::LoadBalancer(
         if (!stateOpt) {
             LOG(log_.warn()) << "Failed to fetch ETL state from source = " << source->toString()
                              << " Please check the configuration and network";
-        } else if (etlState_ && etlState_->networkID != stateOpt->networkID) {
+        } else if (etlState_ && etlState_->networkID && stateOpt->networkID &&
+                   etlState_->networkID != stateOpt->networkID) {
             checkOnETLFailure(fmt::format(
                 "ETL sources must be on the same network. Source network id = {} does not match others network id = {}",
-                stateOpt->networkID,
+                *(stateOpt->networkID),
-                etlState_->networkID
+                *(etlState_->networkID)
             ));
         } else {
             etlState_ = stateOpt;

src/etlng/LoadBalancer.cpp

@@ -142,11 +142,12 @@ LoadBalancer::LoadBalancer(
         if (!stateOpt) {
             LOG(log_.warn()) << "Failed to fetch ETL state from source = " << source->toString()
                              << " Please check the configuration and network";
-        } else if (etlState_ && etlState_->networkID != stateOpt->networkID) {
+        } else if (etlState_ && etlState_->networkID && stateOpt->networkID &&
+                   etlState_->networkID != stateOpt->networkID) {
             checkOnETLFailure(fmt::format(
                 "ETL sources must be on the same network. Source network id = {} does not match others network id = {}",
-                stateOpt->networkID,
+                *(stateOpt->networkID),
-                etlState_->networkID
+                *(etlState_->networkID)
             ));
         } else {
             etlState_ = stateOpt;

src/feed/SubscriptionManager.cpp

@@ -191,7 +191,7 @@ SubscriptionManager::unsubBook(ripple::Book const& book, SubscriberSharedPtr con
 void
 SubscriptionManager::pubTransaction(data::TransactionAndMetadata const& txMeta, ripple::LedgerHeader const& lgrInfo)
 {
-    transactionFeed_.pub(txMeta, lgrInfo, backend_, amendmentCenter_, networkID_);
+    transactionFeed_.pub(txMeta, lgrInfo, backend_, amendmentCenter_);
 }
 
 boost::json::object
@@ -210,16 +210,4 @@ SubscriptionManager::report() const
     };
 }
 
-void
-SubscriptionManager::setNetworkID(uint32_t const networkID)
-{
-    networkID_ = networkID;
-}
-
-uint32_t
-SubscriptionManager::getNetworkID() const
-{
-    return networkID_;
-}
-
 }  // namespace feed

src/feed/SubscriptionManager.hpp

@@ -69,7 +69,6 @@ class SubscriptionManager : public SubscriptionManagerInterface {
     impl::BookChangesFeed bookChangesFeed_;
     impl::TransactionFeed transactionFeed_;
     impl::ProposedTransactionFeed proposedTransactionFeed_;
-    uint32_t networkID_{0};
 
 public:
     /**
@@ -333,21 +332,6 @@ public:
      */
     boost::json::object
     report() const final;
-
-    /**
-     * @brief Set the networkID.
-     * @param networkID The network id to set.
-     */
-    void
-    setNetworkID(uint32_t networkID) final;
-
-    /**
-     * @brief Get the networkID.
-     *
-     * @return The network id.
-     */
-    uint32_t
-    getNetworkID() const final;
 };
 
 }  // namespace feed

src/feed/SubscriptionManagerInterface.hpp

@@ -244,25 +244,10 @@ public:
     /**
      * @brief Get the number of subscribers.
      *
-     * @return The report of the number of subscribers.
+     * @return The report of the number of subscribers
      */
     virtual boost::json::object
     report() const = 0;
-
-    /**
-     * @brief Set the networkID.
-     * @param networkID The network id to set.
-     */
-    virtual void
-    setNetworkID(uint32_t networkID) = 0;
-
-    /**
-     * @brief Get the networkID.
-     *
-     * @return The network id.
-     */
-    virtual uint32_t
-    getNetworkID() const = 0;
 };
 
 }  // namespace feed

src/feed/impl/TransactionFeed.cpp

@@ -25,7 +25,6 @@
 #include "feed/Types.hpp"
 #include "rpc/JS.hpp"
 #include "rpc/RPCHelpers.hpp"
-#include "util/Assert.hpp"
 #include "util/log/Logger.hpp"
 
 #include <boost/asio/spawn.hpp>
@@ -177,8 +176,7 @@ TransactionFeed::pub(
     data::TransactionAndMetadata const& txMeta,
     ripple::LedgerHeader const& lgrInfo,
     std::shared_ptr<data::BackendInterface const> const& backend,
-    std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter,
+    std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter
-    uint32_t const networkID
 )
 {
     auto [tx, meta] = rpc::deserializeTxPlusMeta(txMeta, lgrInfo.seq);
@@ -207,15 +205,6 @@ TransactionFeed::pub(
         rpc::insertDeliverMaxAlias(pubObj[txKey].as_object(), version);
         rpc::insertMPTIssuanceID(pubObj[JS(meta)].as_object(), tx, meta);
 
-        auto const& metaObj = pubObj[JS(meta)];
-        ASSERT(metaObj.is_object(), "meta must be an obj in rippled and clio");
-        if (metaObj.as_object().contains("TransactionIndex") && metaObj.as_object().at("TransactionIndex").is_int64()) {
-            if (auto const& ctid =
-                    rpc::encodeCTID(lgrInfo.seq, metaObj.as_object().at("TransactionIndex").as_int64(), networkID);
-                ctid)
-                pubObj[JS(ctid)] = ctid.value();
-        }
-
         pubObj[JS(type)] = "transaction";
         pubObj[JS(validated)] = true;
         pubObj[JS(status)] = "closed";

src/feed/impl/TransactionFeed.hpp

@@ -182,14 +182,12 @@ public:
      * @param txMeta The transaction and metadata.
      * @param lgrInfo The ledger header.
      * @param backend The backend.
-     * @param networkID The network ID.
      */
     void
     pub(data::TransactionAndMetadata const& txMeta,
         ripple::LedgerHeader const& lgrInfo,
         std::shared_ptr<data::BackendInterface const> const& backend,
-        std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter,
+        std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter);
-        uint32_t networkID);
 
     /**
      * @brief Get the number of subscribers of the transaction feed.

src/rpc/RPCHelpers.cpp

@@ -290,10 +290,7 @@ std::optional<std::string>
 encodeCTID(uint32_t ledgerSeq, uint16_t txnIndex, uint16_t networkId) noexcept
 {
     static constexpr uint32_t kMAX_LEDGER_SEQ = 0x0FFF'FFFF;
-    static constexpr uint32_t kMAX_TXN_INDEX = 0xFFFF;
+    if (ledgerSeq > kMAX_LEDGER_SEQ)
-    static constexpr uint32_t kMAX_NETWORK_ID = 0xFFFF;
-
-    if (ledgerSeq > kMAX_LEDGER_SEQ || txnIndex > kMAX_TXN_INDEX || networkId > kMAX_NETWORK_ID)
         return {};
 
     static constexpr uint64_t kCTID_PREFIX = 0xC000'0000;

src/rpc/common/impl/HandlerProvider.cpp

@@ -87,7 +87,7 @@ ProductionHandlerProvider::ProductionHandlerProvider(
           {"account_nfts", {.handler = AccountNFTsHandler{backend}}},
           {"account_objects", {.handler = AccountObjectsHandler{backend}}},
           {"account_offers", {.handler = AccountOffersHandler{backend}}},
-          {"account_tx", {.handler = AccountTxHandler{backend, etl}}},
+          {"account_tx", {.handler = AccountTxHandler{backend}}},
           {"amm_info", {.handler = AMMInfoHandler{backend, amendmentCenter}}},
           {"book_changes", {.handler = BookChangesHandler{backend}}},
           {"book_offers", {.handler = BookOffersHandler{backend, amendmentCenter}}},

src/rpc/handlers/AccountLines.cpp

@@ -103,12 +103,6 @@ AccountLinesHandler::addLine(
     line.qualityIn = lineQualityIn;
     line.qualityOut = lineQualityOut;
 
-    if (lineNoRipple)
-        line.noRipple = true;
-
-    if (lineNoRipplePeer)
-        line.noRipplePeer = true;
-
     if (lineAuth)
         line.authorized = true;
 
@@ -127,6 +121,8 @@ AccountLinesHandler::addLine(
     if (lineDeepFreezePeer)
         line.deepFreezePeer = true;
 
+    line.noRipple = lineNoRipple;
+    line.noRipplePeer = lineNoRipplePeer;
     lines.push_back(line);
 }
 
@@ -262,11 +258,8 @@ tag_invoke(
         {JS(quality_out), line.qualityOut},
     };
 
-    if (line.noRipple)
+    obj[JS(no_ripple)] = line.noRipple;
-        obj[JS(no_ripple)] = *(line.noRipple);
+    obj[JS(no_ripple_peer)] = line.noRipplePeer;
-
-    if (line.noRipplePeer)
-        obj[JS(no_ripple_peer)] = *(line.noRipplePeer);
 
     if (line.authorized)
         obj[JS(authorized)] = *(line.authorized);

src/rpc/handlers/AccountLines.hpp

@@ -70,8 +70,8 @@ public:
         std::string limitPeer;
         uint32_t qualityIn{};
         uint32_t qualityOut{};
-        std::optional<bool> noRipple;
+        bool noRipple{};
-        std::optional<bool> noRipplePeer;
+        bool noRipplePeer{};
         std::optional<bool> authorized;
         std::optional<bool> peerAuthorized;
         std::optional<bool> freeze;

src/rpc/handlers/AccountTx.cpp

@@ -161,18 +161,6 @@ AccountTxHandler::process(AccountTxHandler::Input input, Context const& ctx) con
                 auto const txKey = ctx.apiVersion < 2u ? JS(tx) : JS(tx_json);
                 obj[JS(meta)] = std::move(meta);
                 obj[txKey] = std::move(txn);
-
-                // Put CTID into tx or tx_json
-                if (obj[JS(meta)].as_object().contains("TransactionIndex")) {
-                    auto networkID = 0u;
-                    if (auto const& etlState = etl_->getETLState(); etlState.has_value())
-                        networkID = etlState->networkID;
-
-                    auto const txnIdx = obj[JS(meta)].as_object().at("TransactionIndex").as_int64();
-                    if (auto const& ctid = rpc::encodeCTID(txnPlusMeta.ledgerSequence, txnIdx, networkID); ctid)
-                        obj[txKey].as_object()[JS(ctid)] = ctid.value();
-                }
-
                 obj[txKey].as_object()[JS(date)] = txnPlusMeta.date;
                 obj[txKey].as_object()[JS(ledger_index)] = txnPlusMeta.ledgerSequence;
 

src/rpc/handlers/AccountTx.hpp

@@ -20,7 +20,6 @@
 #pragma once
 
 #include "data/BackendInterface.hpp"
-#include "etlng/ETLServiceInterface.hpp"
 #include "rpc/Errors.hpp"
 #include "rpc/JS.hpp"
 #include "rpc/common/JsonBool.hpp"
@@ -56,7 +55,6 @@ namespace rpc {
 class AccountTxHandler {
     util::Logger log_{"RPC"};
     std::shared_ptr<BackendInterface> sharedPtrBackend_;
-    std::shared_ptr<etlng::ETLServiceInterface const> etl_;
 
 public:
     static constexpr auto kLIMIT_MIN = 1;
@@ -111,13 +109,8 @@ public:
      * @brief Construct a new AccountTxHandler object
      *
      * @param sharedPtrBackend The backend to use
-     * @param etl The ETL service to use
      */
-    AccountTxHandler(
+    AccountTxHandler(std::shared_ptr<BackendInterface> const& sharedPtrBackend) : sharedPtrBackend_(sharedPtrBackend)
-        std::shared_ptr<BackendInterface> const& sharedPtrBackend,
-        std::shared_ptr<etlng::ETLServiceInterface const> const& etl
-    )
-        : sharedPtrBackend_(sharedPtrBackend), etl_{etl}
     {
     }
 
@@ -137,7 +130,6 @@ public:
             {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator},
             {JS(ledger_index_min), validation::Type<int32_t>{}},
             {JS(ledger_index_max), validation::Type<int32_t>{}},
-            {JS(ctid), validation::Type<std::string>{}},
             {JS(limit),
              validation::Type<uint32_t>{},
              validation::Min(1u),

src/rpc/handlers/Tx.hpp

@@ -21,6 +21,7 @@
 
 #include "data/BackendInterface.hpp"
 #include "data/Types.hpp"
+#include "etl/ETLService.hpp"
 #include "etlng/ETLServiceInterface.hpp"
 #include "rpc/Errors.hpp"
 #include "rpc/JS.hpp"
@@ -37,9 +38,7 @@
 #include <boost/json/object.hpp>
 #include <boost/json/value.hpp>
 #include <boost/json/value_to.hpp>
-#include <fmt/core.h>
 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/chrono.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/LedgerHeader.h>
@@ -215,15 +214,17 @@ public:
             // input.transaction might be not available, get hash via tx object
             if (txn.contains(JS(hash)))
                 output.hash = txn.at(JS(hash)).as_string();
-        }
 
-        // append ctid here to mimic rippled behavior
+            // append ctid here to mimic rippled 1.12 behavior: return ctid even binary=true
-        auto const txnIdx = boost::json::value_to<uint64_t>(meta.at("TransactionIndex"));
+            // rippled will change it in the future, ctid should be part of tx json which not available in binary
-        if (txnIdx <= 0xFFFFU && dbResponse->ledgerSequence < 0x0FFF'FFFFUL && currentNetId &&
+            // mode
-            *currentNetId <= 0xFFFFU) {
+            auto const txnIdx = boost::json::value_to<uint64_t>(meta.at("TransactionIndex"));
-            output.ctid = rpc::encodeCTID(
+            if (txnIdx <= 0xFFFFU && dbResponse->ledgerSequence < 0x0FFF'FFFFUL && currentNetId &&
-                dbResponse->ledgerSequence, static_cast<uint16_t>(txnIdx), static_cast<uint16_t>(*currentNetId)
+                *currentNetId <= 0xFFFFU) {
-            );
+                output.ctid = rpc::encodeCTID(
+                    dbResponse->ledgerSequence, static_cast<uint16_t>(txnIdx), static_cast<uint16_t>(*currentNetId)
+                );
+            }
         }
 
         output.date = dbResponse->date;
@@ -280,10 +281,12 @@ private:
             if (output.tx) {
                 obj[JS(tx_json)] = *output.tx;
                 obj[JS(tx_json)].as_object()[JS(date)] = output.date;
-                if (output.ctid)
-                    obj[JS(tx_json)].as_object()[JS(ctid)] = *output.ctid;
-
                 obj[JS(tx_json)].as_object()[JS(ledger_index)] = output.ledgerIndex;
+                // move ctid from tx_json to root
+                if (obj[JS(tx_json)].as_object().contains(JS(ctid))) {
+                    obj[JS(ctid)] = obj[JS(tx_json)].as_object()[JS(ctid)];
+                    obj[JS(tx_json)].as_object().erase(JS(ctid));
+                }
                 // move hash from tx_json to root
                 if (obj[JS(tx_json)].as_object().contains(JS(hash))) {
                     obj[JS(hash)] = obj[JS(tx_json)].as_object()[JS(hash)];

tests/common/util/MockSubscriptionManager.hpp

@@ -103,10 +103,6 @@ struct MockSubscriptionManager : feed::SubscriptionManagerInterface {
 
     MOCK_METHOD(boost::json::object, report, (), (const, override));
 
-    MOCK_METHOD(void, setNetworkID, (uint32_t), (override));
-
-    MOCK_METHOD(uint32_t, getNetworkID, (), (const, override));
-
     MOCK_METHOD(void, stop, (), (override));
 };
 

tests/unit/etl/ETLStateTests.cpp

@@ -58,7 +58,8 @@ TEST_F(ETLStateTest, NetworkIdValid)
     EXPECT_CALL(source, forwardToRippled).WillOnce(Return(json.as_object()));
     auto const state = etl::ETLState::fetchETLStateFromSource(source);
     ASSERT_TRUE(state.has_value());
-    EXPECT_EQ(state->networkID, 12);
+    ASSERT_TRUE(state->networkID.has_value());
+    EXPECT_EQ(state->networkID.value(), 12);
 }
 
 TEST_F(ETLStateTest, NetworkIdInvalid)
@@ -75,7 +76,7 @@ TEST_F(ETLStateTest, NetworkIdInvalid)
     EXPECT_CALL(source, forwardToRippled).WillOnce(Return(json.as_object()));
     auto const state = etl::ETLState::fetchETLStateFromSource(source);
     ASSERT_TRUE(state.has_value());
-    EXPECT_NE(state->networkID, 12);
+    EXPECT_FALSE(state->networkID.has_value());
 }
 
 TEST_F(ETLStateTest, ResponseHasError)

tests/unit/feed/SubscriptionManagerTests.cpp

@@ -79,12 +79,6 @@ using SubscriptionManagerTest = SubscriptionManagerBaseTest<util::async::SyncExe
 
 using SubscriptionManagerAsyncTest = SubscriptionManagerBaseTest<util::async::PoolExecutionContext>;
 
-TEST_F(SubscriptionManagerAsyncTest, SetAndGetNetworkID)
-{
-    subscriptionManagerPtr_->setNetworkID(32u);
-    EXPECT_EQ(subscriptionManagerPtr_->getNetworkID(), 32u);
-}
-
 TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtx)
 {
     EXPECT_CALL(*sessionPtr_, onDisconnect);
@@ -394,7 +388,6 @@ TEST_F(SubscriptionManagerTest, TransactionTest)
                 "TransactionResult":"tesSUCCESS",
                 "delivered_amount":"unavailable"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",
@@ -484,7 +477,6 @@ TEST_F(SubscriptionManagerTest, ProposedTransactionTest)
                 "TransactionResult":"tesSUCCESS",
                 "delivered_amount":"unavailable"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",

tests/unit/feed/TransactionFeedTests.cpp

@@ -57,7 +57,6 @@ constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
 constexpr auto kTXN_ID = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
 constexpr auto kAMM_ACCOUNT = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs";
 constexpr auto kLPTOKEN_CURRENCY = "037C35306B24AAB7FF90848206E003279AA47090";
-constexpr auto kNETWORK_ID = 0u;
 
 constexpr auto kTRAN_V1 =
     R"({
@@ -105,7 +104,6 @@ constexpr auto kTRAN_V1 =
             "TransactionResult":"tesSUCCESS",
             "delivered_amount":"unavailable"
         },
-        "ctid":"C000002100160000",
         "type":"transaction",
         "validated":true,
         "status":"closed",
@@ -157,7 +155,6 @@ constexpr auto kTRAN_V2 =
             "TransactionResult":"tesSUCCESS",
             "delivered_amount":"unavailable"
         },
-        "ctid":"C000002100160000",
         "type":"transaction",
         "validated":true,
         "status":"closed",
@@ -192,10 +189,10 @@ TEST_F(FeedTransactionTest, SubTransactionV1)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(sessionPtr);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
 }
 
@@ -214,10 +211,10 @@ TEST_F(FeedTransactionTest, SubTransactionForProposedTx)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsubProposed(sessionPtr);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubTransactionV2)
@@ -235,12 +232,12 @@ TEST_F(FeedTransactionTest, SubTransactionV2)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2)));
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubAccountV1)
@@ -261,12 +258,12 @@ TEST_F(FeedTransactionTest, SubAccountV1)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubForProposedAccount)
@@ -287,10 +284,10 @@ TEST_F(FeedTransactionTest, SubForProposedAccount)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsubProposed(account, sessionPtr);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubAccountV2)
@@ -310,12 +307,12 @@ TEST_F(FeedTransactionTest, SubAccountV2)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2)));
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubBothTransactionAndAccount)
@@ -337,14 +334,14 @@ TEST_F(FeedTransactionTest, SubBothTransactionAndAccount)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).Times(2).WillRepeatedly(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(2);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubBookV1)
@@ -414,7 +411,6 @@ TEST_F(FeedTransactionTest, SubBookV1)
                 "TransactionResult":"tesSUCCESS",
                 "delivered_amount":"unavailable"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",
@@ -428,7 +424,7 @@ TEST_F(FeedTransactionTest, SubBookV1)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     // trigger by offer cancel meta data
     metaObj = createMetaDataForCancelOffer(kCURRENCY, kISSUER, 22, 3, 1);
@@ -471,7 +467,6 @@ TEST_F(FeedTransactionTest, SubBookV1)
                 "TransactionResult":"tesSUCCESS",
                 "delivered_amount":"unavailable"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",
@@ -485,7 +480,7 @@ TEST_F(FeedTransactionTest, SubBookV1)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_CANCEL_PUBLISH))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     // trigger by offer create meta data
     static constexpr auto kORDERBOOK_CREATE_PUBLISH =
@@ -527,7 +522,6 @@ TEST_F(FeedTransactionTest, SubBookV1)
                 "TransactionResult":"tesSUCCESS",
                 "delivered_amount":"unavailable"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",
@@ -543,12 +537,12 @@ TEST_F(FeedTransactionTest, SubBookV1)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_CREATE_PUBLISH))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(book, sessionPtr);
     EXPECT_EQ(testFeedPtr->bookSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubBookV2)
@@ -617,7 +611,6 @@ TEST_F(FeedTransactionTest, SubBookV2)
                 "TransactionResult":"tesSUCCESS",
                 "delivered_amount":"unavailable"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",
@@ -632,12 +625,12 @@ TEST_F(FeedTransactionTest, SubBookV2)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(book, sessionPtr);
     EXPECT_EQ(testFeedPtr->bookSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed)
@@ -662,18 +655,18 @@ TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account2, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion)
@@ -699,19 +692,19 @@ TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account2, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion)
@@ -733,12 +726,12 @@ TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubRepeat)
@@ -865,7 +858,6 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund)
                 "TransactionIndex":22,
                 "TransactionResult":"tesSUCCESS"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",
@@ -882,7 +874,7 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund)
     EXPECT_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_));
     ON_CALL(*mockAmendmentCenterPtr_, isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_))
         .WillByDefault(testing::Return(false));
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 static constexpr auto kTRAN_FROZEN =
@@ -910,7 +902,6 @@ static constexpr auto kTRAN_FROZEN =
             "TransactionIndex":22,
             "TransactionResult":"tesSUCCESS"
         },
-        "ctid":"C000002100160000",
         "type":"transaction",
         "validated":true,
         "status":"closed",
@@ -959,7 +950,7 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_FROZEN))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen)
@@ -1000,7 +991,7 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_FROZEN))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount)
@@ -1023,13 +1014,13 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(account, sessionPtr);
     testFeedPtr->unsubProposed(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubBothProposedAndValidated)
@@ -1050,11 +1041,11 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidated)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).Times(2).WillRepeatedly(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(2);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     testFeedPtr->unsub(sessionPtr);
     testFeedPtr->unsubProposed(sessionPtr);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubProposedDisconnect)
@@ -1072,10 +1063,10 @@ TEST_F(FeedTransactionTest, SubProposedDisconnect)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     sessionPtr.reset();
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 TEST_F(FeedTransactionTest, SubProposedAccountDisconnect)
@@ -1095,10 +1086,10 @@ TEST_F(FeedTransactionTest, SubProposedAccountDisconnect)
 
     EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
     EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1);
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 
     sessionPtr.reset();
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 // This test exercises `accountHold` for amendment fixFrozenLPTokenTransfer, so that the output shows "owner_funds: 0"
@@ -1171,7 +1162,6 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken)
                 "TransactionIndex":22,
                 "TransactionResult":"tesSUCCESS"
             },
-            "ctid":"C000002100160000",
             "type":"transaction",
             "validated":true,
             "status":"closed",
@@ -1200,7 +1190,7 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFundFrozenLPToken)
     EXPECT_CALL(*backend_, doFetchLedgerObject(ripple::keylet::account(issuerAccount).key, testing::_, testing::_))
         .WillOnce(testing::Return(issuerAccountRoot.getSerializer().peekData()));
 
-    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_, kNETWORK_ID);
+    testFeedPtr->pub(trans1, ledgerHeader, backend_, mockAmendmentCenterPtr_);
 }
 
 struct TransactionFeedMockPrometheusTest : WithMockPrometheus, SyncExecutionCtxFixture {

tests/unit/rpc/ErrorTests.cpp

@@ -67,7 +67,6 @@ TEST(RPCErrorsTest, StatusAsBool)
         RippledError::rpcUNKNOWN_COMMAND,
         RippledError::rpcTOO_BUSY,
         RippledError::rpcNO_NETWORK,
-        RippledError::rpcWRONG_NETWORK,
         RippledError::rpcACT_MALFORMED,
         RippledError::rpcBAD_MARKET,
         ClioError::RpcMalformedCurrency,

tests/unit/rpc/RPCHelpersTests.cpp

@@ -40,7 +40,6 @@
 #include <boost/json/array.hpp>
 #include <boost/json/object.hpp>
 #include <boost/json/parse.hpp>
-#include <boost/json/value_to.hpp>
 #include <fmt/core.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

tests/unit/rpc/handlers/AccountLinesTests.cpp

@@ -523,7 +523,9 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest)
                         "limit": "100",
                         "limit_peer": "200",
                         "quality_in": 0,
-                        "quality_out": 0
+                        "quality_out": 0,
+                        "no_ripple": false,
+                        "no_ripple_peer": false
                     },
                     {
                         "account": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
@@ -532,7 +534,9 @@ TEST_F(RPCAccountLinesHandlerTest, DefaultParameterTest)
                         "limit": "200",
                         "limit_peer": "100",
                         "quality_in": 0,
-                        "quality_out": 0
+                        "quality_out": 0,
+                        "no_ripple": false,
+                        "no_ripple_peer": false
                     }
                 ]
             })";
@@ -734,6 +738,7 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze)
                 "limit_peer": "200",
                 "quality_in": 0,
                 "quality_out": 0,
+                "no_ripple": false,
                 "no_ripple_peer": true,
                 "peer_authorized": true,
                 "freeze_peer": true,
@@ -748,6 +753,7 @@ TEST_F(RPCAccountLinesHandlerTest, OptionalResponseFieldWithDeepFreeze)
                 "quality_in": 0,
                 "quality_out": 0,
                 "no_ripple": true,
+                "no_ripple_peer": false,
                 "authorized": true,
                 "freeze": true,
                 "deep_freeze": true
@@ -824,6 +830,8 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse)
                 "limit_peer": "200",
                 "quality_in": 0,
                 "quality_out": 0,
+                "no_ripple": false,
+                "no_ripple_peer": false,
                 "peer_authorized": true,
                 "freeze_peer": true
             },
@@ -836,7 +844,9 @@ TEST_F(RPCAccountLinesHandlerTest, FrozenTrustLineResponse)
                 "quality_in": 0,
                 "quality_out": 0,
                 "authorized": true,
-                "freeze": true
+                "freeze": true,
+                "no_ripple": false,
+                "no_ripple_peer": false
             }
         ]
     })";
@@ -1067,7 +1077,9 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin)
                         "limit": "100",
                         "limit_peer": "200",
                         "quality_in": 0,
-                        "quality_out": 0
+                        "quality_out": 0,
+                        "no_ripple": false,
+                        "no_ripple_peer": false
                     }},
                     {{
                         "account": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
@@ -1076,7 +1088,9 @@ TEST_F(RPCAccountLinesHandlerTest, LimitLessThanMin)
                         "limit": "200",
                         "limit_peer": "100",
                         "quality_in": 0,
-                        "quality_out": 0
+                        "quality_out": 0,
+                        "no_ripple": false,
+                        "no_ripple_peer": false
                     }}
                 ]
             }})",
@@ -1144,7 +1158,9 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax)
                         "limit": "100",
                         "limit_peer": "200",
                         "quality_in": 0,
-                        "quality_out": 0
+                        "quality_out": 0,
+                        "no_ripple": false,
+                        "no_ripple_peer": false
                     }},
                     {{
                         "account": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
@@ -1153,7 +1169,9 @@ TEST_F(RPCAccountLinesHandlerTest, LimitMoreThanMax)
                         "limit": "200",
                         "limit_peer": "100",
                         "quality_in": 0,
-                        "quality_out": 0
+                        "quality_out": 0,
+                        "no_ripple": false,
+                        "no_ripple_peer": false
                     }}
                 ]
             }})",

tests/unit/rpc/handlers/AccountTxTests.cpp

@@ -18,7 +18,6 @@
 //==============================================================================
 
 #include "data/Types.hpp"
-#include "etl/ETLState.hpp"
 #include "rpc/Errors.hpp"
 #include "rpc/common/AnyHandler.hpp"
 #include "rpc/common/Types.hpp"
@@ -420,7 +419,7 @@ TEST_P(AccountTxParameterTest, CheckParams)
         ASSERT_TRUE(testBundle.expectedErrorMessage.has_value());
 
         runSpawn([&, this](auto yield) {
-            auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+            auto const handler = AnyHandler{AccountTxHandler{backend_}};
             auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
             ASSERT_FALSE(output);
             auto const err = rpc::makeError(output.result.error());
@@ -431,7 +430,7 @@ TEST_P(AccountTxParameterTest, CheckParams)
         EXPECT_CALL(*backend_, fetchAccountTransactions);
 
         runSpawn([&, this](auto yield) {
-            auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+            auto const handler = AnyHandler{AccountTxHandler{backend_}};
             auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
             EXPECT_TRUE(output);
         });
@@ -506,12 +505,11 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue)
             testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ, INT32_MAX})),
             testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -548,12 +546,11 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse)
             testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
             testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -590,12 +587,11 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue)
             testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ - 1, INT32_MAX})),
             testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -632,12 +628,11 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse)
             testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
             testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -674,10 +669,11 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue)
             testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
             testing::_
         )
-    );
+    )
+        .Times(1);
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -731,7 +727,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2)
         .WillOnce(Return(transCursor));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -780,10 +776,8 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker)
     )
         .WillOnce(Return(transCursor));
 
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
-
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -814,10 +808,9 @@ TEST_F(RPCAccountTxHandlerTest, LimitIsCapped)
     auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
     EXPECT_CALL(*backend_, fetchAccountTransactions(testing::_, testing::_, false, testing::_, testing::_))
         .WillOnce(Return(transCursor));
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -846,10 +839,9 @@ TEST_F(RPCAccountTxHandlerTest, LimitAllowedUpToCap)
     auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
     EXPECT_CALL(*backend_, fetchAccountTransactions(testing::_, testing::_, false, testing::_, testing::_))
         .WillOnce(Return(transCursor));
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -888,16 +880,15 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex)
             testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
             testing::_
         )
-    );
+    )
+        .Times(1);
 
     auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1);
     EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
     ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(ledgerHeader));
 
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
-
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -923,7 +914,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerIntIndex)
     ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -946,7 +937,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerStringIndex)
     ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -985,10 +976,8 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash)
     EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1);
     ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader));
 
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
-
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -1023,16 +1012,15 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated)
             testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
             testing::_
         )
-    );
+    )
+        .Times(1);
 
     auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ);
     EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
     ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(ledgerHeader));
 
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
-
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -1065,12 +1053,11 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq)
             testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
             testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -1107,12 +1094,11 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq)
             testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 2, INT32_MAX})),
             testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -1201,7 +1187,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                         "hash": "C74463F49CFDCBEF3E9902672719918CDE5042DC7E7660BEBD1D1105C4B6DFF4",
                         "ledger_index": 11,
                         "inLedger": 11,
-                        "ctid": "C000000B00000000",
                         "date": 1
                     },
                     "validated": true
@@ -1240,7 +1225,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                         "hash": "C85E486EE308C68D7E601FCEB4FC961BFA914C80ABBF7ECC7E6277B06692B490",
                         "ledger_index": 11,
                         "inLedger": 11,
-                        "ctid": "C000000B00000000",
                         "date": 2
                     },
                     "validated": true
@@ -1293,7 +1277,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                         "hash": "9F82743EEB30065FB9CB92C61F0F064B5859C5A590FA811FAAAD9C988E5B47DB",
                         "ledger_index": 11,
                         "inLedger": 11,
-                        "ctid": "C000000B00000000",
                         "date": 3
                     },
                     "validated": true
@@ -1327,7 +1310,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                         "hash": "ECB1837EB7C7C0AC22ECDCCE59FDD4795C70E0B9D8F4E1C9A9408BB7EC75DA5C",
                         "ledger_index": 11,
                         "inLedger": 11,
-                        "ctid": "C000000B00000000",
                         "date": 4
                     },
                     "validated": true
@@ -1349,12 +1331,11 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
         fetchAccountTransactions(
             testing::_, testing::_, false, testing::Optional(testing::Eq(TransactionsCursor{10, 11})), testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -1441,7 +1422,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                         "SigningPubKey": "74657374",
                         "TransactionType": "NFTokenMint",
                         "ledger_index": 11,
-                        "ctid": "C000000B00000000",
                         "date": 1
                     },
                     "validated": true
@@ -1481,7 +1461,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                         "SigningPubKey": "74657374",
                         "TransactionType": "NFTokenAcceptOffer",
                         "ledger_index": 11,
-                        "ctid": "C000000B00000000",
                         "date": 2
                     },
                     "validated": true
@@ -1536,7 +1515,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                         "SigningPubKey": "74657374",
                         "TransactionType": "NFTokenCancelOffer",
                         "ledger_index": 11,
-                        "ctid": "C000000B00000000",
                         "date": 3
                     },
                     "validated": true
@@ -1572,7 +1550,6 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                         "SigningPubKey": "74657374",
                         "TransactionType": "NFTokenCreateOffer",
                         "ledger_index": 11,
-                        "ctid": "C000000B00000000",
                         "date": 4
                     },
                     "validated": true
@@ -1594,15 +1571,14 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
         fetchAccountTransactions(
             testing::_, testing::_, false, testing::Optional(testing::Eq(TransactionsCursor{10, 11})), testing::_
         )
-    );
+    )
-
+        .Times(1);
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
 
     auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 11);
     EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(transactions.size()).WillRepeatedly(Return(ledgerHeader));
 
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto static const kINPUT = json::parse(fmt::format(
             R"({{
                 "account": "{}",
@@ -1897,7 +1873,6 @@ generateTransactionTypeTestValues()
                         "hash": "51D2AAA6B8E4E16EF22F6424854283D8391B56875858A711B8CE4D5B9A422CC2",
                         "ledger_index": 30,
                         "inLedger": 30,
-                        "ctid": "C000001E00000000",
                         "date": 1
                     },
                     "validated": true
@@ -1950,7 +1925,6 @@ generateTransactionTypeTestValues()
                         "hash": "51D2AAA6B8E4E16EF22F6424854283D8391B56875858A711B8CE4D5B9A422CC2",
                         "ledger_index": 30,
                         "inLedger": 30,
-                        "ctid": "C000001E00000000",
                         "date": 1
                     },
                     "validated": true
@@ -2004,7 +1978,6 @@ generateTransactionTypeTestValues()
                     "SigningPubKey": "74657374",
                     "TransactionType": "Payment",
                     "ledger_index": 30,
-                    "ctid": "C000001E00000000",
                     "date": 1
                 },
                 "validated": true
@@ -2118,17 +2091,16 @@ TEST_P(AccountTxTransactionTypeTest, SpecificTransactionType)
     ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
     EXPECT_CALL(
         *backend_, fetchAccountTransactions(_, _, false, Optional(Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), _)
-    );
+    )
+        .Times(1);
 
     auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ);
     ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(ledgerHeader));
     EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).Times(Between(1, 2));
 
-    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
-
     auto const testBundle = GetParam();
     runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_}};
         auto const req = json::parse(testBundle.testJson);
         auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
         EXPECT_TRUE(output);

tests/unit/rpc/handlers/AllHandlerTests.cpp

@@ -144,8 +144,6 @@ private:
             return HandlerType{this->backend_, this->mockAmendmentCenterPtr_};
         } else if constexpr (std::is_same_v<HandlerType, SubscribeHandler>) {
             return HandlerType{this->backend_, this->mockAmendmentCenterPtr_, this->mockSubscriptionManagerPtr_};
-        } else if constexpr (std::is_same_v<HandlerType, AccountTxHandler>) {
-            return HandlerType{this->backend_, mockETLServicePtr_};
         } else if constexpr (std::is_same_v<HandlerType, TestServerInfoHandler>) {
             return HandlerType{
                 this->backend_,
@@ -178,15 +176,6 @@ createInput<AccountInfoHandler>()
     return input;
 }
 
-template <>
-AccountTxHandler::Input
-createInput<AccountTxHandler>()
-{
-    AccountTxHandler::Input input{};
-    input.account = kACCOUNT;
-    return input;
-}
-
 template <>
 AMMInfoHandler::Input
 createInput<AMMInfoHandler>()

tests/unit/rpc/handlers/TxTests.cpp

@@ -71,7 +71,6 @@ constexpr auto kDEFAULT_OUT1 = R"({
     "TakerPays": "300",
     "TransactionType": "OfferCreate",
     "hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
-    "ctid": "C000006400640000",
     "meta": {
         "AffectedNodes": [
             {
@@ -120,10 +119,8 @@ constexpr auto kDEFAULT_OUT2 = R"({
         "TransactionIndex": 100,
         "TransactionResult": "tesSUCCESS"
     },
-    "ctid": "C000006400640000",
     "tx_json": {
         "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
-        "ctid": "C000006400640000",
         "date": 123456,
         "Fee": "2",
         "ledger_index": 100,
@@ -495,8 +492,7 @@ TEST_F(RPCTxTest, ReturnBinary)
         "date": 123456,
         "ledger_index": 100,
         "inLedger": 100,
-        "validated": true,
+        "validated": true
-        "ctid": "C000006400640000"
     })";
 
     TransactionAndMetadata tx;
@@ -582,7 +578,6 @@ TEST_F(RPCTxTest, MintNFT)
             "SigningPubKey": "74657374",
             "TransactionType": "NFTokenMint",
             "hash": "C74463F49CFDCBEF3E9902672719918CDE5042DC7E7660BEBD1D1105C4B6DFF4",
-            "ctid": "C000006400000000",
             "meta": {{
                 "AffectedNodes": [
                 {{
@@ -834,7 +829,6 @@ TEST_F(RPCTxTest, CTIDNotMatch)
         ASSERT_FALSE(output);
 
         auto const err = rpc::makeError(output.result.error());
-        // TODO: https://github.com/XRPLF/clio/issues/2002
         EXPECT_EQ(err.at("error_code").as_uint64(), 4);
         EXPECT_EQ(
             err.at("error_message").as_string(),