refactor: Remove unnecessary version number and options in cmake find_package (#6169 )

This change removes unnecessary version numbers in the OpenSSL and Boost `find_package` CMake statements. An unnecessary OpenSSL definition is removed, while Conan options for SSL are updated to disable insecure ciphers. Moreover, the statements are now ordered alphabetically and more logically.
2026-01-13 03:05:28 +00:00 · 2026-01-12 19:14:39 -05:00
29 changed files with 202 additions and 1053 deletions
--- a/BUILD.md
+++ b/BUILD.md
@@ -148,7 +148,8 @@ function extract_version {
 }

 # Define which recipes to export.
-recipes=(ed25519 grpc secp256k1 snappy soci)
+recipes=('ed25519' 'grpc' 'openssl' 'secp256k1' 'snappy' 'soci')
+folders=('all'     'all'  '3.x.x'   'all'       'all'    'all')

 # Selectively check out the recipes from our CCI fork.
 cd external
@@ -157,20 +158,24 @@ cd conan-center-index
 git init
 git remote add origin git@github.com:XRPLF/conan-center-index.git
 git sparse-checkout init
-for recipe in ${recipes[@]}; do
-  echo "Checking out ${recipe}..."
-  git sparse-checkout add recipes/${recipe}/all
+for ((index = 1; index <= ${#recipes[@]}; index++)); do
+  recipe=${recipes[index]}
+  folder=${folders[index]}
+  echo "Checking out recipe '${recipe}' from folder '${folder}'..."
+  git sparse-checkout add recipes/${recipe}/${folder}
 done
 git fetch origin master
 git checkout master
 cd ../..

 # Export the recipes into the local cache.
-for recipe in ${recipes[@]}; do
+for ((index = 1; index <= ${#recipes[@]}; index++)); do
+  recipe=${recipes[index]}
+  folder=${folders[index]}
  version=$(extract_version ${recipe})
-  echo "Exporting ${recipe}/${version}..."
+  echo "Exporting '${recipe}/${version}' from '${recipe}/${folder}'..."
  conan export --version $(extract_version ${recipe}) \
-    external/conan-center-index/recipes/${recipe}/all
+    external/conan-center-index/recipes/${recipe}/${folder}
 done
 ```

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,34 +88,18 @@ endif()
 ###

 include(deps/Boost)
-find_package(OpenSSL 1.1.1 REQUIRED)
-set_target_properties(OpenSSL::SSL PROPERTIES
-  INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
-)

 add_subdirectory(external/antithesis-sdk)
-find_package(gRPC REQUIRED)
-find_package(lz4 REQUIRED)
-# Target names with :: are not allowed in a generator expression.
-# We need to pull the include directories and imported location properties
-# from separate targets.
-find_package(LibArchive REQUIRED)
-find_package(SOCI REQUIRED)
-find_package(SQLite3 REQUIRED)
-
-option(rocksdb "Enable RocksDB" ON)
-if(rocksdb)
-  find_package(RocksDB REQUIRED)
-  set_target_properties(RocksDB::rocksdb PROPERTIES
-    INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
-  )
-  target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
-endif()
-
 find_package(date REQUIRED)
 find_package(ed25519 REQUIRED)
+find_package(gRPC REQUIRED)
+find_package(LibArchive REQUIRED)
+find_package(lz4 REQUIRED)
 find_package(nudb REQUIRED)
+find_package(OpenSSL REQUIRED)
 find_package(secp256k1 REQUIRED)
+find_package(SOCI REQUIRED)
+find_package(SQLite3 REQUIRED)
 find_package(xxHash REQUIRED)

 target_link_libraries(xrpl_libs INTERFACE
@@ -128,6 +112,15 @@ target_link_libraries(xrpl_libs INTERFACE
  SQLite::SQLite3
 )

+option(rocksdb "Enable RocksDB" ON)
+if(rocksdb)
+    find_package(RocksDB REQUIRED)
+    set_target_properties(RocksDB::rocksdb PROPERTIES
+            INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
+    )
+    target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
+endif()
+
 # Work around changes to Conan recipe for now.
 if(TARGET nudb::core)
  set(nudb nudb::core)
--- a/cmake/deps/Boost.cmake
+++ b/cmake/deps/Boost.cmake
@@ -1,4 +1,4 @@
-find_package(Boost 1.82 REQUIRED
+find_package(Boost REQUIRED
  COMPONENTS
    chrono
    container
--- a/conan.lock
+++ b/conan.lock
@@ -1,44 +1,44 @@
 {
    "version": "0.5",
    "requires": [
-        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1756234269.497",
-        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1756234289.683",
-        "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1756234266.869",
-        "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1756234262.318",
-        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1756234314.246",
-        "secp256k1/0.7.0#9c4ab67bdc3860c16ea5b36aed8f74ea%1765202256.763",
-        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1762797952.535",
-        "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1764175362.029",
-        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1764863245.83",
-        "openssl/3.5.4#a1d5835cc6ed5c5b8f3cd5b9b5d24205%1760106486.594",
-        "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1763150366.909",
-        "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1756234228.999",
-        "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1756223727.64",
-        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1756230911.03",
-        "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1764175360.142",
+        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075",
+        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987",
+        "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1765850149.926",
+        "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1765850149.46",
+        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1765850147.878",
+        "secp256k1/0.7.0#9c4ab67bdc3860c16ea5b36aed8f74ea%1765850147.928",
+        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1765850186.86",
+        "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1765850148.103",
+        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1765850161.038",
+        "openssl/3.5.4#58f5173c2ee51d6fc0f0c61b4eddadbb%1768259092.666",
+        "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1765850143.957",
+        "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914",
+        "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492",
+        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03",
+        "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1765850144.736",
        "jemalloc/5.3.0#e951da9cf599e956cebc117880d2d9f8%1729241615.244",
-        "grpc/1.72.0#f244a57bff01e708c55a1100b12e1589%1763158050.628",
-        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1764270189.893",
-        "doctest/2.4.12#eb9fb352fb2fdfc8abb17ec270945165%1762797941.757",
-        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1763584497.32",
-        "c-ares/1.34.5#5581c2b62a608b40bb85d965ab3ec7c8%1764175359.429",
-        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1764175359.429",
-        "boost/1.88.0#8852c0b72ce8271fb8ff7c53456d4983%1756223752.326",
-        "abseil/20250127.0#9e8e8cfc89a1324139fc0ee3bd4d8c8c%1753819045.301"
+        "grpc/1.72.0#f244a57bff01e708c55a1100b12e1589%1765850193.734",
+        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1765850143.772",
+        "doctest/2.4.12#eb9fb352fb2fdfc8abb17ec270945165%1765850143.95",
+        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772",
+        "c-ares/1.34.5#5581c2b62a608b40bb85d965ab3ec7c8%1765850144.336",
+        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837",
+        "boost/1.88.0#8852c0b72ce8271fb8ff7c53456d4983%1765850172.862",
+        "abseil/20250127.0#99262a368bd01c0ccca8790dfced9719%1766517936.993"
    ],
    "build_requires": [
-        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1756234269.497",
-        "strawberryperl/5.32.1.1#707032463aa0620fa17ec0d887f5fe41%1756234281.733",
-        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1764863245.83",
-        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1756234232.901",
+        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075",
+        "strawberryperl/5.32.1.1#707032463aa0620fa17ec0d887f5fe41%1765850165.196",
+        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1765850161.038",
+        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1765850144.707",
        "msys2/cci.latest#1996656c3c98e5765b25b60ff5cf77b4%1764840888.758",
        "m4/1.4.19#70dc8bbb33e981d119d2acc0175cf381%1763158052.846",
-        "cmake/4.2.0#ae0a44f44a1ef9ab68fd4b3e9a1f8671%1764175359.44",
-        "cmake/3.31.10#313d16a1aa16bbdb2ca0792467214b76%1764175359.429",
-        "b2/5.3.3#107c15377719889654eb9a162a673975%1756234226.28",
+        "cmake/4.2.0#ae0a44f44a1ef9ab68fd4b3e9a1f8671%1765850153.937",
+        "cmake/3.31.10#313d16a1aa16bbdb2ca0792467214b76%1765850153.479",
+        "b2/5.3.3#107c15377719889654eb9a162a673975%1765850144.355",
        "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56",
        "autoconf/2.71#51077f068e61700d65bb05541ea1e4b0%1731054366.86",
-        "abseil/20250127.0#9e8e8cfc89a1324139fc0ee3bd4d8c8c%1753819045.301"
+        "abseil/20250127.0#99262a368bd01c0ccca8790dfced9719%1766517936.993"
    ],
    "python_requires": [],
    "overrides": {
--- a/conanfile.py
+++ b/conanfile.py
@@ -87,7 +87,13 @@ class Xrpl(ConanFile):
        "libarchive/*:with_xattr": False,
        "libarchive/*:with_zlib": False,
        "lz4/*:shared": False,
+        "openssl/*:no_dtls": True,
+        "openssl/*:no_ssl": True,
+        "openssl/*:no_ssl3": True,
+        "openssl/*:no_tls1": True,
+        "openssl/*:no_tls1_1": True,
        "openssl/*:shared": False,
+        "openssl/*:tls_security_level": 2,
        "protobuf/*:shared": False,
        "protobuf/*:with_zlib": True,
        "rocksdb/*:enable_sse": False,
--- a/include/xrpl/basics/CanProcess.h
+++ b/include/xrpl/basics/CanProcess.h
@@ -1,134 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2024 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_CANPROCESS_H_INCLUDED
-#define RIPPLE_BASICS_CANPROCESS_H_INCLUDED
-
-#include <functional>
-#include <mutex>
-#include <set>
-
-/** RAII class to check if an Item is already being processed on another thread,
- * as indicated by it's presence in a Collection.
- *
- * If the Item is not in the Collection, it will be added under lock in the
- * ctor, and removed under lock in the dtor. The object will be considered
- * "usable" and evaluate to `true`.
- *
- * If the Item is in the Collection, no changes will be made to the collection,
- * and the CanProcess object will be considered "unusable".
- *
- * It's up to the caller to decide what "usable" and "unusable" mean. (e.g.
- * Process or skip a block of code, or set a flag.)
- *
- * The current use is to avoid lock contention that would be involved in
- * processing something associated with the Item.
- *
- * Examples:
- *
- * void IncomingLedgers::acquireAsync(LedgerHash const& hash, ...)
- * {
- *    if (CanProcess check{acquiresMutex_, pendingAcquires_, hash})
- *    {
- *      acquire(hash, ...);
- *    }
- * }
- *
- * bool
- * NetworkOPsImp::recvValidation(
- *   std::shared_ptr<STValidation> const& val,
- *   std::string const& source)
- *   {
- *       CanProcess check(
- *           validationsMutex_, pendingValidations_, val->getLedgerHash());
- *       BypassAccept bypassAccept =
- *           check ? BypassAccept::no : BypassAccept::yes;
- *       handleNewValidation(app_, val, source, bypassAccept, m_journal);
- *   }
- *
- */
-class CanProcess
-{
-public:
-    template <class Mutex, class Collection, class Item>
-    CanProcess(Mutex& mtx, Collection& collection, Item const& item)
-        : cleanup_(insert(mtx, collection, item))
-    {
-    }
-
-    ~CanProcess()
-    {
-        if (cleanup_)
-            cleanup_();
-    }
-
-    explicit
-    operator bool() const
-    {
-        return static_cast<bool>(cleanup_);
-    }
-
-private:
-    template <bool useIterator, class Mutex, class Collection, class Item>
-    std::function<void()>
-    doInsert(Mutex& mtx, Collection& collection, Item const& item)
-    {
-        std::unique_lock<Mutex> lock(mtx);
-        // TODO: Use structured binding once LLVM 16 is the minimum supported
-        // version. See also: https://github.com/llvm/llvm-project/issues/48582
-        // https://github.com/llvm/llvm-project/commit/127bf44385424891eb04cff8e52d3f157fc2cb7c
-        auto const insertResult = collection.insert(item);
-        auto const it = insertResult.first;
-        if (!insertResult.second)
-            return {};
-        if constexpr (useIterator)
-            return [&, it]() {
-                std::unique_lock<Mutex> lock(mtx);
-                collection.erase(it);
-            };
-        else
-            return [&]() {
-                std::unique_lock<Mutex> lock(mtx);
-                collection.erase(item);
-            };
-    }
-
-    // Generic insert() function doesn't use iterators because they may get
-    // invalidated
-    template <class Mutex, class Collection, class Item>
-    std::function<void()>
-    insert(Mutex& mtx, Collection& collection, Item const& item)
-    {
-        return doInsert<false>(mtx, collection, item);
-    }
-
-    // Specialize insert() for std::set, which does not invalidate iterators for
-    // insert and erase
-    template <class Mutex, class Item>
-    std::function<void()>
-    insert(Mutex& mtx, std::set<Item>& collection, Item const& item)
-    {
-        return doInsert<true>(mtx, collection, item);
-    }
-
-    // If set, then the item is "usable"
-    std::function<void()> cleanup_;
-};
-
-#endif
--- a/include/xrpl/proto/xrpl.proto
+++ b/include/xrpl/proto/xrpl.proto
@@ -286,18 +286,8 @@ message TMLedgerData {
  required uint32 ledgerSeq = 2;
  required TMLedgerInfoType type = 3;
  repeated TMLedgerNode nodes = 4;
-  // If the peer supports "responseCookies", this field will
-  // never be populated.
  optional uint32 requestCookie = 5;
  optional TMReplyError error = 6;
-  // The old field is called "requestCookie", but this is
-  // a response, so this name makes more sense
-  repeated uint32 responseCookies = 7;
-  // If a TMGetLedger request was received without a "requestCookie",
-  // and the peer supports it, this flag will be set to true to
-  // indicate that the receiver should process the result in addition
-  // to forwarding it to its "responseCookies" peers.
-  optional bool directResponse = 8;
 }

 message TMPing {
--- a/include/xrpl/protocol/LedgerHeader.h
+++ b/include/xrpl/protocol/LedgerHeader.h
@@ -36,8 +36,6 @@ struct LedgerHeader

    // If validated is false, it means "not yet validated."
    // Once validated is true, it will never be set false at a later time.
-    // NOTE: If you are accessing this directly, you are probably doing it
-    //   wrong. Use LedgerMaster::isValidated().
    // VFALCO TODO Make this not mutable
    bool mutable validated = false;
    bool accepted = false;
--- a/src/test/app/HashRouter_test.cpp
+++ b/src/test/app/HashRouter_test.cpp
@@ -389,33 +389,6 @@ class HashRouter_test : public beast::unit_test::suite
        BEAST_EXPECT(!any(HF::UNDEFINED));
    }

-    void
-    testProcessPeer()
-    {
-        using namespace std::chrono_literals;
-        TestStopwatch stopwatch;
-        HashRouter router(getSetup(5s, 5s), stopwatch);
-        uint256 const key(1);
-        HashRouter::PeerShortID peer1 = 1;
-        HashRouter::PeerShortID peer2 = 2;
-        auto const timeout = 2s;
-
-        BEAST_EXPECT(router.shouldProcessForPeer(key, peer1, timeout));
-        BEAST_EXPECT(!router.shouldProcessForPeer(key, peer1, timeout));
-        ++stopwatch;
-        BEAST_EXPECT(!router.shouldProcessForPeer(key, peer1, timeout));
-        BEAST_EXPECT(router.shouldProcessForPeer(key, peer2, timeout));
-        BEAST_EXPECT(!router.shouldProcessForPeer(key, peer2, timeout));
-        ++stopwatch;
-        BEAST_EXPECT(router.shouldProcessForPeer(key, peer1, timeout));
-        BEAST_EXPECT(!router.shouldProcessForPeer(key, peer2, timeout));
-        ++stopwatch;
-        BEAST_EXPECT(router.shouldProcessForPeer(key, peer2, timeout));
-        ++stopwatch;
-        BEAST_EXPECT(router.shouldProcessForPeer(key, peer1, timeout));
-        BEAST_EXPECT(!router.shouldProcessForPeer(key, peer2, timeout));
-    }
-
 public:
    void
    run() override
@@ -428,7 +401,6 @@ public:
        testProcess();
        testSetup();
        testFlagsOps();
-        testProcessPeer();
    }
 };

--- a/src/test/app/LedgerReplay_test.cpp
+++ b/src/test/app/LedgerReplay_test.cpp
@@ -305,11 +305,6 @@ public:
    {
        return false;
    }
-    std::set<std::optional<uint64_t>>
-    releaseRequestCookies(uint256 const& requestHash) override
-    {
-        return {};
-    }

    std::string const&
    fingerprint() const override
--- a/src/test/overlay/ProtocolVersion_test.cpp
+++ b/src/test/overlay/ProtocolVersion_test.cpp
@@ -69,8 +69,8 @@ public:
                negotiateProtocolVersion("XRPL/2.2") == make_protocol(2, 2));
            BEAST_EXPECT(
                negotiateProtocolVersion(
-                    "RTXP/1.2, XRPL/2.2, XRPL/2.3, XRPL/2.4, XRPL/999.999") ==
-                make_protocol(2, 3));
+                    "RTXP/1.2, XRPL/2.2, XRPL/2.3, XRPL/999.999") ==
+                make_protocol(2, 2));
            BEAST_EXPECT(
                negotiateProtocolVersion("XRPL/999.999, WebSocket/1.0") ==
                std::nullopt);
--- a/src/test/overlay/reduce_relay_test.cpp
+++ b/src/test/overlay/reduce_relay_test.cpp
@@ -170,11 +170,6 @@ public:
    removeTxQueue(uint256 const&) override
    {
    }
-    std::set<std::optional<uint64_t>>
-    releaseRequestCookies(uint256 const& requestHash) override
-    {
-        return {};
-    }
 };

 /** Manually advanced clock. */
--- a/src/xrpld/app/consensus/RCLConsensus.cpp
+++ b/src/xrpld/app/consensus/RCLConsensus.cpp
@@ -1056,8 +1056,7 @@ void
 RCLConsensus::Adaptor::updateOperatingMode(std::size_t const positions) const
 {
    if (!positions && app_.getOPs().isFull())
-        app_.getOPs().setMode(
-            OperatingMode::CONNECTED, "updateOperatingMode: no positions");
+        app_.getOPs().setMode(OperatingMode::CONNECTED);
 }

 void
--- a/src/xrpld/app/ledger/InboundLedger.h
+++ b/src/xrpld/app/ledger/InboundLedger.h
@@ -179,25 +179,6 @@ private:
    std::unique_ptr<PeerSet> mPeerSet;
 };

-inline std::string
-to_string(InboundLedger::Reason reason)
-{
-    using enum InboundLedger::Reason;
-    switch (reason)
-    {
-        case HISTORY:
-            return "HISTORY";
-        case GENERIC:
-            return "GENERIC";
-        case CONSENSUS:
-            return "CONSENSUS";
-        default:
-            UNREACHABLE(
-                "ripple::to_string(InboundLedger::Reason) : unknown value");
-            return "unknown";
-    }
-}
-
 }  // namespace xrpl

 #endif
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -374,14 +374,7 @@ InboundLedger::onTimer(bool wasProgress, ScopedLockType&)

    if (!wasProgress)
    {
-        if (checkLocal())
-        {
-            // Done. Something else (probably consensus) built the ledger
-            // locally while waiting for data (or possibly before requesting)
-            XRPL_ASSERT(isDone(), "ripple::InboundLedger::onTimer : done");
-            JLOG(journal_.info()) << "Finished while waiting " << hash_;
-            return;
-        }
+        checkLocal();

        mByHash = true;

--- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -3,9 +3,9 @@
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/NetworkOPs.h>

-#include <xrpl/basics/CanProcess.h>
 #include <xrpl/basics/DecayingSample.h>
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/scope.h>
 #include <xrpl/beast/container/aged_map.h>
 #include <xrpl/core/JobQueue.h>
 #include <xrpl/core/PerfLog.h>
@@ -58,85 +58,11 @@ public:
                hash.isNonZero(),
                "xrpl::InboundLedgersImp::acquire::doAcquire : nonzero hash");

-            bool const needNetworkLedger = app_.getOPs().isNeedNetworkLedger();
-            bool const shouldAcquire = [&]() {
-                if (!needNetworkLedger)
-                    return true;
-                if (reason == InboundLedger::Reason::GENERIC)
-                    return true;
-                if (reason == InboundLedger::Reason::CONSENSUS)
-                    return true;
-                return false;
-            }();
-
-            std::stringstream ss;
-            ss << "InboundLedger::acquire: "
-               << "Request: " << to_string(hash) << ", " << seq
-               << " NeedNetworkLedger: " << (needNetworkLedger ? "yes" : "no")
-               << " Reason: " << to_string(reason)
-               << " Should acquire: " << (shouldAcquire ? "true." : "false.");
-
-            /*  Acquiring ledgers is somewhat expensive. It requires lots of
-             *  computation and network communication. Avoid it when it's not
-             *  appropriate. Every validation from a peer for a ledger that
-             *  we do not have locally results in a call to this function: even
-             *  if we are moments away from validating the same ledger.
-             */
-            bool const shouldBroadcast = [&]() {
-                // If the node is not in "full" state, it needs to sync to
-                // the network, and doesn't have the necessary tx's and
-                // ledger entries to build the ledger.
-                bool const isFull = app_.getOPs().isFull();
-                // If everything else is ok, don't try to acquire the ledger
-                // if the requested seq is in the near future relative to
-                // the validated ledger. If the requested ledger is between
-                // 1 and 19 inclusive ledgers ahead of the valid ledger this
-                // node has not built it yet, but it's possible/likely it
-                // has the tx's necessary to build it and get caught up.
-                // Plus it might not become validated. On the other hand, if
-                // it's more than 20 in the future, this node should request
-                // it so that it can jump ahead and get caught up.
-                LedgerIndex const validSeq =
-                    app_.getLedgerMaster().getValidLedgerIndex();
-                constexpr std::size_t lagLeeway = 20;
-                bool const nearFuture =
-                    (seq > validSeq) && (seq < validSeq + lagLeeway);
-                // If everything else is ok, don't try to acquire the ledger
-                // if the request is related to consensus. (Note that
-                // consensus calls usually pass a seq of 0, so nearFuture
-                // will be false other than on a brand new network.)
-                bool const consensus =
-                    reason == InboundLedger::Reason::CONSENSUS;
-                ss << " Evaluating whether to broadcast requests to peers"
-                   << ". full: " << (isFull ? "true" : "false")
-                   << ". ledger sequence " << seq
-                   << ". Valid sequence: " << validSeq
-                   << ". Lag leeway: " << lagLeeway
-                   << ". request for near future ledger: "
-                   << (nearFuture ? "true" : "false")
-                   << ". Consensus: " << (consensus ? "true" : "false");
-
-                // If the node is not synced, send requests.
-                if (!isFull)
-                    return true;
-                // If the ledger is in the near future, do NOT send requests.
-                // This node is probably about to build it.
-                if (nearFuture)
-                    return false;
-                // If the request is because of consensus, do NOT send requests.
-                // This node is probably about to build it.
-                if (consensus)
-                    return false;
-                return true;
-            }();
-            ss << ". Would broadcast to peers? "
-               << (shouldBroadcast ? "true." : "false.");
-
-            if (!shouldAcquire)
-            {
-                JLOG(j_.debug()) << "Abort(rule): " << ss.str();
+            // probably not the right rule
+            if (app_.getOPs().isNeedNetworkLedger() &&
+                (reason != InboundLedger::Reason::GENERIC) &&
+                (reason != InboundLedger::Reason::CONSENSUS))
                return {};
-            }

            bool isNew = true;
            std::shared_ptr<InboundLedger> inbound;
@@ -144,7 +70,6 @@ public:
                ScopedLockType sl(mLock);
                if (stopping_)
                {
-                    JLOG(j_.debug()) << "Abort(stopping): " << ss.str();
                    return {};
                }

@@ -168,29 +93,23 @@ public:
                    ++mCounter;
                }
            }
-            ss << " IsNew: " << (isNew ? "true" : "false");

            if (inbound->isFailed())
-            {
-                JLOG(j_.debug()) << "Abort(failed): " << ss.str();
                return {};
-            }

            if (!isNew)
                inbound->update(seq);

            if (!inbound->isComplete())
-            {
-                JLOG(j_.debug()) << "InProgress: " << ss.str();
                return {};
-            }

-            JLOG(j_.debug()) << "Complete: " << ss.str();
            return inbound->getLedger();
        };
        using namespace std::chrono_literals;
-        return perf::measureDurationAndLog(
+        std::shared_ptr<Ledger const> ledger = perf::measureDurationAndLog(
            doAcquire, "InboundLedgersImp::acquire", 500ms, j_);
+
+        return ledger;
    }

    void
@@ -199,25 +118,28 @@ public:
        std::uint32_t seq,
        InboundLedger::Reason reason) override
    {
-        if (CanProcess const check{acquiresMutex_, pendingAcquires_, hash})
+        std::unique_lock lock(acquiresMutex_);
+        try
        {
-            try
-            {
-                acquire(hash, seq, reason);
-            }
-            catch (std::exception const& e)
-            {
-                JLOG(j_.warn())
-                    << "Exception thrown for acquiring new inbound ledger "
-                    << hash << ": " << e.what();
-            }
-            catch (...)
-            {
-                JLOG(j_.warn()) << "Unknown exception thrown for acquiring new "
-                                   "inbound ledger "
-                                << hash;
-            }
+            if (pendingAcquires_.contains(hash))
+                return;
+            pendingAcquires_.insert(hash);
+            scope_unlock unlock(lock);
+            acquire(hash, seq, reason);
        }
+        catch (std::exception const& e)
+        {
+            JLOG(j_.warn())
+                << "Exception thrown for acquiring new inbound ledger " << hash
+                << ": " << e.what();
+        }
+        catch (...)
+        {
+            JLOG(j_.warn())
+                << "Unknown exception thrown for acquiring new inbound ledger "
+                << hash;
+        }
+        pendingAcquires_.erase(hash);
    }

    std::shared_ptr<InboundLedger>
--- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -942,9 +942,8 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
    }

    JLOG(m_journal.info()) << "Advancing accepted ledger to "
-                           << ledger->header().seq << " ("
-                           << to_short_string(ledger->header().hash)
-                           << ") with >= " << minVal << " validations";
+                           << ledger->header().seq << " with >= " << minVal
+                           << " validations";

    ledger->setValidated();
    ledger->setFull();
--- a/src/xrpld/app/ledger/detail/TimeoutCounter.cpp
+++ b/src/xrpld/app/ledger/detail/TimeoutCounter.cpp
@@ -13,8 +13,7 @@ TimeoutCounter::TimeoutCounter(
    QueueJobParameter&& jobParameter,
    beast::Journal journal)
    : app_(app)
-    , sink_(journal, to_short_string(hash) + " ")
-    , journal_(sink_)
+    , journal_(journal)
    , hash_(hash)
    , timeouts_(0)
    , complete_(false)
@@ -34,8 +33,6 @@ TimeoutCounter::setTimer(ScopedLockType& sl)
 {
    if (isDone())
        return;
-    JLOG(journal_.debug()) << "Setting timer for " << timerInterval_.count()
-                           << "ms";
    timer_.expires_after(timerInterval_);
    timer_.async_wait(
        [wptr = pmDowncast()](boost::system::error_code const& ec) {
@@ -44,12 +41,6 @@ TimeoutCounter::setTimer(ScopedLockType& sl)

            if (auto ptr = wptr.lock())
            {
-                JLOG(ptr->journal_.debug())
-                    << "timer: ec: " << ec << " (operation_aborted: "
-                    << boost::asio::error::operation_aborted << " - "
-                    << (ec == boost::asio::error::operation_aborted ? "aborted"
-                                                                    : "other")
-                    << ")";
                ScopedLockType sl(ptr->mtx_);
                ptr->queueJob(sl);
            }
--- a/src/xrpld/app/ledger/detail/TimeoutCounter.h
+++ b/src/xrpld/app/ledger/detail/TimeoutCounter.h
@@ -4,7 +4,6 @@
 #include <xrpld/app/main/Application.h>

 #include <xrpl/beast/utility/Journal.h>
-#include <xrpl/beast/utility/WrappedSink.h>
 #include <xrpl/core/Job.h>

 #include <boost/asio/basic_waitable_timer.hpp>
@@ -105,7 +104,6 @@ protected:
    // Used in this class for access to boost::asio::io_context and
    // xrpl::Overlay. Used in subtypes for the kitchen sink.
    Application& app_;
-    beast::WrappedSink sink_;
    beast::Journal journal_;
    mutable std::recursive_mutex mtx_;

--- a/src/xrpld/app/misc/HashRouter.cpp
+++ b/src/xrpld/app/misc/HashRouter.cpp
@@ -75,20 +75,6 @@ HashRouter::shouldProcess(
    return s.shouldProcess(suppressionMap_.clock().now(), tx_interval);
 }

-bool
-HashRouter::shouldProcessForPeer(
-    uint256 const& key,
-    PeerShortID peer,
-    std::chrono::seconds interval)
-{
-    std::lock_guard lock(mutex_);
-
-    auto& entry = emplace(key).first;
-
-    return entry.shouldProcessForPeer(
-        peer, suppressionMap_.clock().now(), interval);
-}
-
 HashRouterFlags
 HashRouter::getFlags(uint256 const& key)
 {
@@ -163,13 +149,4 @@ setup_HashRouter(Config const& config)
    return setup;
 }

-auto
-HashRouter::getPeers(uint256 const& key) -> std::set<PeerShortID>
-{
-    std::lock_guard lock(mutex_);
-
-    auto& s = emplace(key).first;
-    return s.peekPeerSet();
-}
-
 }  // namespace xrpl
--- a/src/xrpld/app/misc/HashRouter.h
+++ b/src/xrpld/app/misc/HashRouter.h
@@ -140,13 +140,6 @@ private:
            return std::move(peers_);
        }

-        /** Return set of peers waiting for reply. Leaves list unchanged. */
-        std::set<PeerShortID> const&
-        peekPeerSet()
-        {
-            return peers_;
-        }
-
        /** Return seated relay time point if the message has been relayed */
        std::optional<Stopwatch::time_point>
        relayed() const
@@ -180,21 +173,6 @@ private:
            return true;
        }

-        bool
-        shouldProcessForPeer(
-            PeerShortID peer,
-            Stopwatch::time_point now,
-            std::chrono::seconds interval)
-        {
-            if (peerProcessed_.contains(peer) &&
-                ((peerProcessed_[peer] + interval) > now))
-                return false;
-            // Peer may already be in the list, but adding it again doesn't hurt
-            addPeer(peer);
-            peerProcessed_[peer] = now;
-            return true;
-        }
-
    private:
        HashRouterFlags flags_ = HashRouterFlags::UNDEFINED;
        std::set<PeerShortID> peers_;
@@ -202,7 +180,6 @@ private:
        // than one flag needs to expire independently.
        std::optional<Stopwatch::time_point> relayed_;
        std::optional<Stopwatch::time_point> processed_;
-        std::map<PeerShortID, Stopwatch::time_point> peerProcessed_;
    };

 public:
@@ -226,7 +203,7 @@ public:

    /** Add a suppression peer and get message's relay status.
     * Return pair:
-     * element 1: true if the key is added.
+     * element 1: true if the peer is added.
     * element 2: optional is seated to the relay time point or
     * is unseated if has not relayed yet. */
    std::pair<bool, std::optional<Stopwatch::time_point>>
@@ -246,18 +223,6 @@ public:
        HashRouterFlags& flags,
        std::chrono::seconds tx_interval);

-    /** Determines whether the hashed item should be processed for the given
-       peer. Could be an incoming or outgoing message.
-
-       Items filtered with this function should only be processed for the given
-       peer once. Unlike shouldProcess, it can be processed for other peers.
-     */
-    bool
-    shouldProcessForPeer(
-        uint256 const& key,
-        PeerShortID peer,
-        std::chrono::seconds interval);
-
    /** Set the flags on a hash.

        @return `true` if the flags were changed. `false` if unchanged.
@@ -283,11 +248,6 @@ public:
    std::optional<std::set<PeerShortID>>
    shouldRelay(uint256 const& key);

-    /** Returns a copy of the set of peers in the Entry for the key
-     */
-    std::set<PeerShortID>
-    getPeers(uint256 const& key);
-
 private:
    // pair.second indicates whether the entry was created
    std::pair<Entry&, bool>
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -33,10 +33,10 @@
 #include <xrpld/rpc/MPTokenIssuanceID.h>
 #include <xrpld/rpc/ServerHandler.h>

-#include <xrpl/basics/CanProcess.h>
 #include <xrpl/basics/UptimeClock.h>
 #include <xrpl/basics/mulDiv.h>
 #include <xrpl/basics/safe_cast.h>
+#include <xrpl/basics/scope.h>
 #include <xrpl/beast/utility/rngfill.h>
 #include <xrpl/core/PerfLog.h>
 #include <xrpl/crypto/RFC1751.h>
@@ -408,7 +408,7 @@ public:
    isFull() override;

    void
-    setMode(OperatingMode om, char const* reason) override;
+    setMode(OperatingMode om) override;

    bool
    isBlocked() override;
@@ -886,7 +886,7 @@ NetworkOPsImp::strOperatingMode(bool const admin /* = false */) const
 inline void
 NetworkOPsImp::setStandAlone()
 {
-    setMode(OperatingMode::FULL, "setStandAlone");
+    setMode(OperatingMode::FULL);
 }

 inline void
@@ -1036,9 +1036,7 @@ NetworkOPsImp::processHeartbeatTimer()
        {
            if (mMode != OperatingMode::DISCONNECTED)
            {
-                setMode(
-                    OperatingMode::DISCONNECTED,
-                    "Heartbeat: insufficient peers");
+                setMode(OperatingMode::DISCONNECTED);
                std::stringstream ss;
                ss << "Node count (" << numPeers << ") has fallen "
                   << "below required minimum (" << minPeerCount_ << ").";
@@ -1063,7 +1061,7 @@ NetworkOPsImp::processHeartbeatTimer()

        if (mMode == OperatingMode::DISCONNECTED)
        {
-            setMode(OperatingMode::CONNECTED, "Heartbeat: sufficient peers");
+            setMode(OperatingMode::CONNECTED);
            JLOG(m_journal.info())
                << "Node count (" << numPeers << ") is sufficient.";
            CLOG(clog.ss()) << "setting mode to CONNECTED based on " << numPeers
@@ -1075,9 +1073,9 @@ NetworkOPsImp::processHeartbeatTimer()
        auto origMode = mMode.load();
        CLOG(clog.ss()) << "mode: " << strOperatingMode(origMode, true);
        if (mMode == OperatingMode::SYNCING)
-            setMode(OperatingMode::SYNCING, "Heartbeat: check syncing");
+            setMode(OperatingMode::SYNCING);
        else if (mMode == OperatingMode::CONNECTED)
-            setMode(OperatingMode::CONNECTED, "Heartbeat: check connected");
+            setMode(OperatingMode::CONNECTED);
        auto newMode = mMode.load();
        if (origMode != newMode)
        {
@@ -1827,7 +1825,7 @@ void
 NetworkOPsImp::setAmendmentBlocked()
 {
    amendmentBlocked_ = true;
-    setMode(OperatingMode::CONNECTED, "setAmendmentBlocked");
+    setMode(OperatingMode::CONNECTED);
 }

 inline bool
@@ -1858,7 +1856,7 @@ void
 NetworkOPsImp::setUNLBlocked()
 {
    unlBlocked_ = true;
-    setMode(OperatingMode::CONNECTED, "setUNLBlocked");
+    setMode(OperatingMode::CONNECTED);
 }

 inline void
@@ -1959,7 +1957,7 @@ NetworkOPsImp::checkLastClosedLedger(

    if ((mMode == OperatingMode::TRACKING) || (mMode == OperatingMode::FULL))
    {
-        setMode(OperatingMode::CONNECTED, "check LCL: not on consensus ledger");
+        setMode(OperatingMode::CONNECTED);
    }

    if (consensus)
@@ -2050,9 +2048,8 @@ NetworkOPsImp::beginConsensus(
        // this shouldn't happen unless we jump ledgers
        if (mMode == OperatingMode::FULL)
        {
-            JLOG(m_journal.warn())
-                << "beginConsensus Don't have LCL, going to tracking";
-            setMode(OperatingMode::TRACKING, "beginConsensus: No LCL");
+            JLOG(m_journal.warn()) << "Don't have LCL, going to tracking";
+            setMode(OperatingMode::TRACKING);
            CLOG(clog) << "beginConsensus Don't have LCL, going to tracking. ";
        }

@@ -2188,7 +2185,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
        // validations we have for LCL.  If the ledger is good enough, go to
        // TRACKING - TODO
        if (!needNetworkLedger_)
-            setMode(OperatingMode::TRACKING, "endConsensus: check tracking");
+            setMode(OperatingMode::TRACKING);
    }

    if (((mMode == OperatingMode::CONNECTED) ||
@@ -2203,7 +2200,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
            (current->header().parentCloseTime +
             2 * current->header().closeTimeResolution))
        {
-            setMode(OperatingMode::FULL, "endConsensus: check full");
+            setMode(OperatingMode::FULL);
        }
    }

@@ -2215,7 +2212,7 @@ NetworkOPsImp::consensusViewChange()
 {
    if ((mMode == OperatingMode::FULL) || (mMode == OperatingMode::TRACKING))
    {
-        setMode(OperatingMode::CONNECTED, "consensusViewChange");
+        setMode(OperatingMode::CONNECTED);
    }
 }

@@ -2534,7 +2531,7 @@ NetworkOPsImp::pubPeerStatus(std::function<Json::Value(void)> const& func)
 }

 void
-NetworkOPsImp::setMode(OperatingMode om, char const* reason)
+NetworkOPsImp::setMode(OperatingMode om)
 {
    using namespace std::chrono_literals;
    if (om == OperatingMode::CONNECTED)
@@ -2554,12 +2551,11 @@ NetworkOPsImp::setMode(OperatingMode om, char const* reason)
    if (mMode == om)
        return;

-    auto const sink = om < mMode ? m_journal.warn() : m_journal.info();
    mMode = om;

    accounting_.mode(om);

-    JLOG(sink) << "STATE->" << strOperatingMode() << " - " << reason;
+    JLOG(m_journal.info()) << "STATE->" << strOperatingMode();
    pubServer();
 }

@@ -2571,28 +2567,34 @@ NetworkOPsImp::recvValidation(
    JLOG(m_journal.trace())
        << "recvValidation " << val->getLedgerHash() << " from " << source;

+    std::unique_lock lock(validationsMutex_);
+    BypassAccept bypassAccept = BypassAccept::no;
+    try
    {
-        CanProcess const check(
-            validationsMutex_, pendingValidations_, val->getLedgerHash());
-        try
-        {
-            BypassAccept bypassAccept =
-                check ? BypassAccept::no : BypassAccept::yes;
-            handleNewValidation(app_, val, source, bypassAccept, m_journal);
-        }
-        catch (std::exception const& e)
-        {
-            JLOG(m_journal.warn())
-                << "Exception thrown for handling new validation "
-                << val->getLedgerHash() << ": " << e.what();
-        }
-        catch (...)
-        {
-            JLOG(m_journal.warn())
-                << "Unknown exception thrown for handling new validation "
-                << val->getLedgerHash();
-        }
+        if (pendingValidations_.contains(val->getLedgerHash()))
+            bypassAccept = BypassAccept::yes;
+        else
+            pendingValidations_.insert(val->getLedgerHash());
+        scope_unlock unlock(lock);
+        handleNewValidation(app_, val, source, bypassAccept, m_journal);
    }
+    catch (std::exception const& e)
+    {
+        JLOG(m_journal.warn())
+            << "Exception thrown for handling new validation "
+            << val->getLedgerHash() << ": " << e.what();
+    }
+    catch (...)
+    {
+        JLOG(m_journal.warn())
+            << "Unknown exception thrown for handling new validation "
+            << val->getLedgerHash();
+    }
+    if (bypassAccept == BypassAccept::no)
+    {
+        pendingValidations_.erase(val->getLedgerHash());
+    }
+    lock.unlock();

    pubValidation(val);

--- a/src/xrpld/app/misc/NetworkOPs.h
+++ b/src/xrpld/app/misc/NetworkOPs.h
@@ -191,7 +191,7 @@ public:
    virtual bool
    isFull() = 0;
    virtual void
-    setMode(OperatingMode om, char const* reason) = 0;
+    setMode(OperatingMode om) = 0;
    virtual bool
    isBlocked() = 0;
    virtual bool
--- a/src/xrpld/overlay/Peer.h
+++ b/src/xrpld/overlay/Peer.h
@@ -18,7 +18,6 @@ enum class ProtocolFeature {
    ValidatorListPropagation,
    ValidatorList2Propagation,
    LedgerReplay,
-    LedgerDataCookies
 };

 /** Represents a peer connection in the overlay. */
@@ -118,13 +117,6 @@ public:

    virtual bool
    txReduceRelayEnabled() const = 0;
-
-    //
-    // Messages
-    //
-
-    virtual std::set<std::optional<uint64_t>>
-    releaseRequestCookies(uint256 const& requestHash) = 0;
 };

 }  // namespace xrpl
--- a/src/xrpld/overlay/detail/PeerImp.cpp
+++ b/src/xrpld/overlay/detail/PeerImp.cpp
@@ -11,7 +11,6 @@
 #include <xrpld/app/tx/apply.h>
 #include <xrpld/overlay/Cluster.h>
 #include <xrpld/overlay/detail/PeerImp.h>
-#include <xrpld/overlay/detail/ProtocolMessage.h>
 #include <xrpld/overlay/detail/Tuning.h>

 #include <xrpl/basics/UptimeClock.h>
@@ -46,8 +45,6 @@ std::chrono::seconds constexpr peerTimerInterval{60};
 /** The timeout for a shutdown timer */
 std::chrono::seconds constexpr shutdownTimerInterval{5};

-/** How often we process duplicate incoming TMGetLedger messages */
-std::chrono::seconds constexpr getledgerInterval{15};
 }  // namespace

 // TODO: Remove this exclusion once unit tests are added after the hotfix
@@ -502,8 +499,6 @@ PeerImp::supportsFeature(ProtocolFeature f) const
            return protocol_ >= make_protocol(2, 2);
        case ProtocolFeature::LedgerReplay:
            return ledgerReplayEnabled_;
-        case ProtocolFeature::LedgerDataCookies:
-            return protocol_ >= make_protocol(2, 3);
    }
    return false;
 }
@@ -1480,9 +1475,8 @@ PeerImp::handleTransaction(
 void
 PeerImp::onMessage(std::shared_ptr<protocol::TMGetLedger> const& m)
 {
-    auto badData = [&](std::string const& msg, bool chargefee = true) {
-        if (chargefee)
-            fee_.update(Resource::feeInvalidData, "get_ledger " + msg);
+    auto badData = [&](std::string const& msg) {
+        fee_.update(Resource::feeInvalidData, "get_ledger " + msg);
        JLOG(p_journal_.warn()) << "TMGetLedger: " << msg;
    };
    auto const itype{m->itype()};
@@ -1559,74 +1553,12 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetLedger> const& m)
        }
    }

-    // Drop duplicate requests from the same peer for at least
-    // `getLedgerInterval` seconds.
-    // Append a little junk to prevent the hash of an incoming messsage
-    // from matching the hash of the same outgoing message.
-    // `shouldProcessForPeer` does not distingish between incoming and
-    // outgoing, and some of the message relay logic checks the hash to see
-    // if the message has been relayed already. If the hashes are the same,
-    // a duplicate will be detected when sending the message is attempted,
-    // so it will fail.
-    auto const messageHash = sha512Half(*m, nullptr);
-    // Request cookies are not included in the hash. Track them here.
-    auto const requestCookie = [&m]() -> std::optional<uint64_t> {
-        if (m->has_requestcookie())
-            return m->requestcookie();
-        return std::nullopt;
-    }();
-    auto const [inserted, pending] = [&] {
-        std::lock_guard lock{cookieLock_};
-        auto& cookies = messageRequestCookies_[messageHash];
-        bool const pending = !cookies.empty();
-        return std::pair{cookies.emplace(requestCookie).second, pending};
-    }();
-    // Check if the request has been seen from this peer.
-    if (!app_.getHashRouter().shouldProcessForPeer(
-            messageHash, id_, getledgerInterval))
-    {
-        // This request has already been seen from this peer.
-        // Has it been seen with this request cookie (or lack thereof)?
-
-        if (inserted)
-        {
-            // This is a duplicate request, but with a new cookie. When a
-            // response is ready, one will be sent for each request cookie.
-            JLOG(p_journal_.debug())
-                << "TMGetLedger: duplicate request with new request cookie: "
-                << requestCookie.value_or(0)
-                << ". Job pending: " << (pending ? "yes" : "no") << ": "
-                << messageHash;
-            if (pending)
-            {
-                // Don't bother queueing up a new job if other requests are
-                // already pending. This should limit entries in the job queue
-                // to one per peer per unique request.
-                JLOG(p_journal_.debug())
-                    << "TMGetLedger: Suppressing recvGetLedger job, since one "
-                       "is pending: "
-                    << messageHash;
-                return;
-            }
-        }
-        else
-        {
-            // Don't punish nodes that don't know any better
-            return badData(
-                "duplicate request: " + to_string(messageHash),
-                supportsFeature(ProtocolFeature::LedgerDataCookies));
-        }
-    }
-
    // Queue a job to process the request
-    JLOG(p_journal_.debug())
-        << "TMGetLedger: Adding recvGetLedger job: " << messageHash;
    std::weak_ptr<PeerImp> weak = shared_from_this();
-    app_.getJobQueue().addJob(
-        jtLEDGER_REQ, "recvGetLedger", [weak, m, messageHash]() {
-            if (auto peer = weak.lock())
-                peer->processLedgerRequest(m, messageHash);
-        });
+    app_.getJobQueue().addJob(jtLEDGER_REQ, "recvGetLedger", [weak, m]() {
+        if (auto peer = weak.lock())
+            peer->processLedgerRequest(m);
+    });
 }

 void
@@ -1742,9 +1674,8 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMReplayDeltaResponse> const& m)
 void
 PeerImp::onMessage(std::shared_ptr<protocol::TMLedgerData> const& m)
 {
-    auto badData = [&](std::string const& msg, bool charge = true) {
-        if (charge)
-            fee_.update(Resource::feeInvalidData, msg);
+    auto badData = [&](std::string const& msg) {
+        fee_.update(Resource::feeInvalidData, msg);
        JLOG(p_journal_.warn()) << "TMLedgerData: " << msg;
    };

@@ -1795,99 +1726,23 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMLedgerData> const& m)
            "Invalid Ledger/TXset nodes " + std::to_string(m->nodes_size()));
    }

-    auto const messageHash = sha512Half(*m);
-    if (!app_.getHashRouter().addSuppressionPeer(messageHash, id_))
+    // If there is a request cookie, attempt to relay the message
+    if (m->has_requestcookie())
    {
-        // Don't punish nodes that don't know any better
-        return badData(
-            "Duplicate message: " + to_string(messageHash),
-            supportsFeature(ProtocolFeature::LedgerDataCookies));
-    }
-
-    bool const routed = m->has_directresponse() || m->responsecookies_size() ||
-        m->has_requestcookie();
-
-    {
-        // Check if this message needs to be forwarded to one or more peers.
-        // Maximum of one of the relevant fields should be populated.
-        XRPL_ASSERT(
-            !m->has_requestcookie() || !m->responsecookies_size(),
-            "ripple::PeerImp::onMessage(TMLedgerData) : valid cookie fields");
-
-        // Make a copy of the response cookies, then wipe the list so it can be
-        // forwarded cleanly
-        auto const responseCookies = m->responsecookies();
-        m->clear_responsecookies();
-        // Flag indicating if this response should be processed locally,
-        // possibly in addition to being forwarded.
-        bool const directResponse =
-            m->has_directresponse() && m->directresponse();
-        m->clear_directresponse();
-
-        auto const relay = [this, m, &messageHash](auto const cookie) {
-            if (auto peer = overlay_.findPeerByShortID(cookie))
-            {
-                XRPL_ASSERT(
-                    !m->has_requestcookie() && !m->responsecookies_size(),
-                    "ripple::PeerImp::onMessage(TMLedgerData) relay : no "
-                    "cookies");
-                if (peer->supportsFeature(ProtocolFeature::LedgerDataCookies))
-                    // Setting this flag is not _strictly_ necessary for peers
-                    // that support it if there are no cookies included in the
-                    // message, but it is more accurate.
-                    m->set_directresponse(true);
-                else
-                    m->clear_directresponse();
-                peer->send(
-                    std::make_shared<Message>(*m, protocol::mtLEDGER_DATA));
-            }
-            else
-                JLOG(p_journal_.info())
-                    << "Unable to route TX/ledger data reply to peer ["
-                    << cookie << "]: " << messageHash;
-        };
-        // If there is a request cookie, attempt to relay the message
-        if (m->has_requestcookie())
+        if (auto peer = overlay_.findPeerByShortID(m->requestcookie()))
        {
-            XRPL_ASSERT(
-                responseCookies.empty(),
-                "ripple::PeerImp::onMessage(TMLedgerData) : no response "
-                "cookies");
            m->clear_requestcookie();
-            relay(m->requestcookie());
-            if (!directResponse && responseCookies.empty())
-                return;
+            peer->send(std::make_shared<Message>(*m, protocol::mtLEDGER_DATA));
        }
-        // If there's a list of request cookies, attempt to relay the message to
-        // all of them.
-        if (responseCookies.size())
+        else
        {
-            for (auto const cookie : responseCookies)
-                relay(cookie);
-            if (!directResponse)
-                return;
-        }
-    }
-
-    // Now that any forwarding is done check the base message (data only, no
-    // routing info for duplicates)
-    if (routed)
-    {
-        m->clear_directresponse();
-        XRPL_ASSERT(
-            !m->has_requestcookie() && !m->responsecookies_size(),
-            "ripple::PeerImp::onMessage(TMLedgerData) : no cookies");
-        auto const baseMessageHash = sha512Half(*m);
-        if (!app_.getHashRouter().addSuppressionPeer(baseMessageHash, id_))
-        {
-            // Don't punish nodes that don't know any better
-            return badData(
-                "Duplicate message: " + to_string(baseMessageHash),
-                supportsFeature(ProtocolFeature::LedgerDataCookies));
+            JLOG(p_journal_.info()) << "Unable to route TX/ledger data reply";
        }
+        return;
    }

    uint256 const ledgerHash{m->ledgerhash()};
+
    // Otherwise check if received data for a candidate transaction set
    if (m->type() == protocol::liTS_CANDIDATE)
    {
@@ -3317,22 +3172,16 @@ PeerImp::checkValidation(
 // the TX tree with the specified root hash.
 //
 static std::shared_ptr<PeerImp>
-getPeerWithTree(
-    OverlayImpl& ov,
-    uint256 const& rootHash,
-    PeerImp const* skip,
-    std::function<bool(Peer::id_t)> shouldProcessCallback)
+getPeerWithTree(OverlayImpl& ov, uint256 const& rootHash, PeerImp const* skip)
 {
    std::shared_ptr<PeerImp> ret;
    int retScore = 0;

-    XRPL_ASSERT(
-        shouldProcessCallback, "ripple::getPeerWithTree : callback provided");
    ov.for_each([&](std::shared_ptr<PeerImp>&& p) {
        if (p->hasTxSet(rootHash) && p.get() != skip)
        {
            auto score = p->getScore(true);
-            if (!ret || (score > retScore && shouldProcessCallback(p->id())))
+            if (!ret || (score > retScore))
            {
                ret = std::move(p);
                retScore = score;
@@ -3351,19 +3200,16 @@ getPeerWithLedger(
    OverlayImpl& ov,
    uint256 const& ledgerHash,
    LedgerIndex ledger,
-    PeerImp const* skip,
-    std::function<bool(Peer::id_t)> shouldProcessCallback)
+    PeerImp const* skip)
 {
    std::shared_ptr<PeerImp> ret;
    int retScore = 0;

-    XRPL_ASSERT(
-        shouldProcessCallback, "ripple::getPeerWithLedger : callback provided");
    ov.for_each([&](std::shared_ptr<PeerImp>&& p) {
        if (p->hasLedger(ledgerHash, ledger) && p.get() != skip)
        {
            auto score = p->getScore(true);
-            if (!ret || (score > retScore && shouldProcessCallback(p->id())))
+            if (!ret || (score > retScore))
            {
                ret = std::move(p);
                retScore = score;
@@ -3377,8 +3223,7 @@ getPeerWithLedger(
 void
 PeerImp::sendLedgerBase(
    std::shared_ptr<Ledger const> const& ledger,
-    protocol::TMLedgerData& ledgerData,
-    PeerCookieMap const& destinations)
+    protocol::TMLedgerData& ledgerData)
 {
    JLOG(p_journal_.trace()) << "sendLedgerBase: Base data";

@@ -3410,102 +3255,15 @@ PeerImp::sendLedgerBase(
        }
    }

-    sendToMultiple(ledgerData, destinations);
-}
-
-void
-PeerImp::sendToMultiple(
-    protocol::TMLedgerData& ledgerData,
-    PeerCookieMap const& destinations)
-{
-    bool foundSelf = false;
-    for (auto const& [peer, cookies] : destinations)
-    {
-        if (peer.get() == this)
-            foundSelf = true;
-        bool const multipleCookies =
-            peer->supportsFeature(ProtocolFeature::LedgerDataCookies);
-        std::vector<std::uint64_t> sendCookies;
-
-        bool directResponse = false;
-        if (!multipleCookies)
-        {
-            JLOG(p_journal_.debug())
-                << "sendToMultiple: Sending " << cookies.size()
-                << " TMLedgerData messages to peer [" << peer->id()
-                << "]: " << sha512Half(ledgerData);
-        }
-        for (auto const& cookie : cookies)
-        {
-            // Unfortunately, need a separate Message object for every
-            // combination
-            if (cookie)
-            {
-                if (multipleCookies)
-                {
-                    // Save this one for later to send a single message
-                    sendCookies.emplace_back(*cookie);
-                    continue;
-                }
-
-                // Feature not supported, so send a single message with a
-                // single cookie
-                ledgerData.set_requestcookie(*cookie);
-            }
-            else
-            {
-                if (multipleCookies)
-                {
-                    // Set this flag later on the single message
-                    directResponse = true;
-                    continue;
-                }
-
-                ledgerData.clear_requestcookie();
-            }
-            XRPL_ASSERT(
-                !multipleCookies,
-                "ripple::PeerImp::sendToMultiple : ledger data cookies "
-                "unsupported");
-            auto message{
-                std::make_shared<Message>(ledgerData, protocol::mtLEDGER_DATA)};
-            peer->send(message);
-        }
-        if (multipleCookies)
-        {
-            // Send a single message with all the cookies and/or the direct
-            // response flag, so the receiver can farm out the single message to
-            // multiple peers and/or itself
-            XRPL_ASSERT(
-                sendCookies.size() || directResponse,
-                "ripple::PeerImp::sendToMultiple : valid response options");
-            ledgerData.clear_requestcookie();
-            ledgerData.clear_responsecookies();
-            ledgerData.set_directresponse(directResponse);
-            for (auto const& cookie : sendCookies)
-                ledgerData.add_responsecookies(cookie);
-            auto message{
-                std::make_shared<Message>(ledgerData, protocol::mtLEDGER_DATA)};
-            peer->send(message);
-
-            JLOG(p_journal_.debug())
-                << "sendToMultiple: Sent 1 TMLedgerData message to peer ["
-                << peer->id() << "]: including "
-                << (directResponse ? "the direct response flag and " : "")
-                << sendCookies.size() << " response cookies. "
-                << ": " << sha512Half(ledgerData);
-        }
-    }
-    XRPL_ASSERT(
-        foundSelf, "ripple::PeerImp::sendToMultiple : current peer included");
+    auto message{
+        std::make_shared<Message>(ledgerData, protocol::mtLEDGER_DATA)};
+    send(message);
 }

 std::shared_ptr<Ledger const>
-PeerImp::getLedger(
-    std::shared_ptr<protocol::TMGetLedger> const& m,
-    uint256 const& mHash)
+PeerImp::getLedger(std::shared_ptr<protocol::TMGetLedger> const& m)
 {
-    JLOG(p_journal_.trace()) << "getLedger: Ledger " << mHash;
+    JLOG(p_journal_.trace()) << "getLedger: Ledger";

    std::shared_ptr<Ledger const> ledger;

@@ -3522,33 +3280,22 @@ PeerImp::getLedger(
            if (m->has_querytype() && !m->has_requestcookie())
            {
                // Attempt to relay the request to a peer
-                // Note repeated messages will not relay to the same peer
-                // before `getLedgerInterval` seconds. This prevents one
-                // peer from getting flooded, and distributes the request
-                // load. If a request has been relayed to all eligible
-                // peers, then this message will not be relayed.
                if (auto const peer = getPeerWithLedger(
                        overlay_,
                        ledgerHash,
                        m->has_ledgerseq() ? m->ledgerseq() : 0,
-                        this,
-                        [&](Peer::id_t id) {
-                            return app_.getHashRouter().shouldProcessForPeer(
-                                mHash, id, getledgerInterval);
-                        }))
+                        this))
                {
                    m->set_requestcookie(id());
                    peer->send(
                        std::make_shared<Message>(*m, protocol::mtGET_LEDGER));
                    JLOG(p_journal_.debug())
-                        << "getLedger: Request relayed to peer [" << peer->id()
-                        << "]: " << mHash;
+                        << "getLedger: Request relayed to peer";
                    return ledger;
                }

                JLOG(p_journal_.trace())
-                    << "getLedger: Don't have ledger with hash " << ledgerHash
-                    << ": " << mHash;
+                    << "getLedger: Failed to find peer to relay request";
            }
        }
    }
@@ -3558,7 +3305,7 @@ PeerImp::getLedger(
        if (m->ledgerseq() < app_.getLedgerMaster().getEarliestFetch())
        {
            JLOG(p_journal_.debug())
-                << "getLedger: Early ledger sequence request " << mHash;
+                << "getLedger: Early ledger sequence request";
        }
        else
        {
@@ -3567,7 +3314,7 @@ PeerImp::getLedger(
            {
                JLOG(p_journal_.debug())
                    << "getLedger: Don't have ledger with sequence "
-                    << m->ledgerseq() << ": " << mHash;
+                    << m->ledgerseq();
            }
        }
    }
@@ -3590,33 +3337,29 @@ PeerImp::getLedger(
                        Resource::feeMalformedRequest, "get_ledger ledgerSeq");

                ledger.reset();
-                JLOG(p_journal_.warn()) << "getLedger: Invalid ledger sequence "
-                                        << ledgerSeq << ": " << mHash;
+                JLOG(p_journal_.warn())
+                    << "getLedger: Invalid ledger sequence " << ledgerSeq;
            }
        }
        else if (ledgerSeq < app_.getLedgerMaster().getEarliestFetch())
        {
            ledger.reset();
            JLOG(p_journal_.debug())
-                << "getLedger: Early ledger sequence request " << ledgerSeq
-                << ": " << mHash;
+                << "getLedger: Early ledger sequence request " << ledgerSeq;
        }
    }
    else
    {
-        JLOG(p_journal_.debug())
-            << "getLedger: Unable to find ledger " << mHash;
+        JLOG(p_journal_.debug()) << "getLedger: Unable to find ledger";
    }

    return ledger;
 }

 std::shared_ptr<SHAMap const>
-PeerImp::getTxSet(
-    std::shared_ptr<protocol::TMGetLedger> const& m,
-    uint256 const& mHash) const
+PeerImp::getTxSet(std::shared_ptr<protocol::TMGetLedger> const& m) const
 {
-    JLOG(p_journal_.trace()) << "getTxSet: TX set " << mHash;
+    JLOG(p_journal_.trace()) << "getTxSet: TX set";

    uint256 const txSetHash{m->ledgerhash()};
    std::shared_ptr<SHAMap> shaMap{
@@ -3626,34 +3369,22 @@ PeerImp::getTxSet(
        if (m->has_querytype() && !m->has_requestcookie())
        {
            // Attempt to relay the request to a peer
-            // Note repeated messages will not relay to the same peer
-            // before `getLedgerInterval` seconds. This prevents one
-            // peer from getting flooded, and distributes the request
-            // load. If a request has been relayed to all eligible
-            // peers, then this message will not be relayed.
-            if (auto const peer = getPeerWithTree(
-                    overlay_, txSetHash, this, [&](Peer::id_t id) {
-                        return app_.getHashRouter().shouldProcessForPeer(
-                            mHash, id, getledgerInterval);
-                    }))
+            if (auto const peer = getPeerWithTree(overlay_, txSetHash, this))
            {
                m->set_requestcookie(id());
                peer->send(
                    std::make_shared<Message>(*m, protocol::mtGET_LEDGER));
-                JLOG(p_journal_.debug())
-                    << "getTxSet: Request relayed to peer [" << peer->id()
-                    << "]: " << mHash;
+                JLOG(p_journal_.debug()) << "getTxSet: Request relayed";
            }
            else
            {
                JLOG(p_journal_.debug())
-                    << "getTxSet: Failed to find relay peer: " << mHash;
+                    << "getTxSet: Failed to find relay peer";
            }
        }
        else
        {
-            JLOG(p_journal_.debug())
-                << "getTxSet: Failed to find TX set " << mHash;
+            JLOG(p_journal_.debug()) << "getTxSet: Failed to find TX set";
        }
    }

@@ -3661,9 +3392,7 @@ PeerImp::getTxSet(
 }

 void
-PeerImp::processLedgerRequest(
-    std::shared_ptr<protocol::TMGetLedger> const& m,
-    uint256 const& mHash)
+PeerImp::processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m)
 {
    // Do not resource charge a peer responding to a relay
    if (!m->has_requestcookie())
@@ -3677,74 +3406,9 @@ PeerImp::processLedgerRequest(
    bool fatLeaves{true};
    auto const itype{m->itype()};

-    auto getDestinations = [&] {
-        // If a ledger data message is generated, it's going to be sent to every
-        // peer that is waiting for it.
-
-        PeerCookieMap result;
-
-        std::size_t numCookies = 0;
-        {
-            // Don't do the work under this peer if this peer is not waiting for
-            // any replies
-            auto myCookies = releaseRequestCookies(mHash);
-            if (myCookies.empty())
-            {
-                JLOG(p_journal_.debug()) << "TMGetLedger: peer is no longer "
-                                            "waiting for response to request: "
-                                         << mHash;
-                return result;
-            }
-            numCookies += myCookies.size();
-            result[shared_from_this()] = myCookies;
-        }
-
-        std::set<HashRouter::PeerShortID> const peers =
-            app_.getHashRouter().getPeers(mHash);
-        for (auto const peerID : peers)
-        {
-            // This loop does not need to be done under the HashRouter
-            // lock because findPeerByShortID and releaseRequestCookies
-            // are thread safe, and everything else is local
-            if (auto p = overlay_.findPeerByShortID(peerID))
-            {
-                auto cookies = p->releaseRequestCookies(mHash);
-                numCookies += cookies.size();
-                if (result.contains(p))
-                {
-                    // Unlikely, but if a request came in to this peer while
-                    // iterating, add the items instead of copying /
-                    // overwriting.
-                    XRPL_ASSERT(
-                        p.get() == this,
-                        "ripple::PeerImp::processLedgerRequest : found self in "
-                        "map");
-                    for (auto const& cookie : cookies)
-                        result[p].emplace(cookie);
-                }
-                else if (cookies.size())
-                    result[p] = cookies;
-            }
-        }
-
-        JLOG(p_journal_.debug())
-            << "TMGetLedger: Processing request for " << result.size()
-            << " peers. Will send " << numCookies
-            << " messages if successful: " << mHash;
-
-        return result;
-    };
-    // Will only populate this if we're going to do work.
-    PeerCookieMap destinations;
-
    if (itype == protocol::liTS_CANDIDATE)
    {
-        destinations = getDestinations();
-        if (destinations.empty())
-            // Nowhere to send the response!
-            return;
-
-        if (sharedMap = getTxSet(m, mHash); !sharedMap)
+        if (sharedMap = getTxSet(m); !sharedMap)
            return;
        map = sharedMap.get();

@@ -3752,6 +3416,8 @@ PeerImp::processLedgerRequest(
        ledgerData.set_ledgerseq(0);
        ledgerData.set_ledgerhash(m->ledgerhash());
        ledgerData.set_type(protocol::liTS_CANDIDATE);
+        if (m->has_requestcookie())
+            ledgerData.set_requestcookie(m->requestcookie());

        // We'll already have most transactions
        fatLeaves = false;
@@ -3770,12 +3436,7 @@ PeerImp::processLedgerRequest(
            return;
        }

-        destinations = getDestinations();
-        if (destinations.empty())
-            // Nowhere to send the response!
-            return;
-
-        if (ledger = getLedger(m, mHash); !ledger)
+        if (ledger = getLedger(m); !ledger)
            return;

        // Fill out the reply
@@ -3783,11 +3444,13 @@ PeerImp::processLedgerRequest(
        ledgerData.set_ledgerhash(ledgerHash.begin(), ledgerHash.size());
        ledgerData.set_ledgerseq(ledger->header().seq);
        ledgerData.set_type(itype);
+        if (m->has_requestcookie())
+            ledgerData.set_requestcookie(m->requestcookie());

        switch (itype)
        {
            case protocol::liBASE:
-                sendLedgerBase(ledger, ledgerData, destinations);
+                sendLedgerBase(ledger, ledgerData);
                return;

            case protocol::liTX_NODE:
@@ -3904,7 +3567,7 @@ PeerImp::processLedgerRequest(
    if (ledgerData.nodes_size() == 0)
        return;

-    sendToMultiple(ledgerData, destinations);
+    send(std::make_shared<Message>(ledgerData, protocol::mtLEDGER_DATA));
 }

 int
@@ -3952,19 +3615,6 @@ PeerImp::isHighLatency() const
    return latency_ >= peerHighLatency;
 }

-std::set<std::optional<uint64_t>>
-PeerImp::releaseRequestCookies(uint256 const& requestHash)
-{
-    std::set<std::optional<uint64_t>> result;
-    std::lock_guard lock(cookieLock_);
-    if (messageRequestCookies_.contains(requestHash))
-    {
-        std::swap(result, messageRequestCookies_[requestHash]);
-        messageRequestCookies_.erase(requestHash);
-    }
-    return result;
-};
-
 void
 PeerImp::Metrics::add_message(std::uint64_t bytes)
 {
--- a/src/xrpld/overlay/detail/PeerImp.h
+++ b/src/xrpld/overlay/detail/PeerImp.h
@@ -253,15 +253,6 @@ private:
    bool ledgerReplayEnabled_ = false;
    LedgerReplayMsgHandler ledgerReplayMsgHandler_;

-    // Track message requests and responses
-    // TODO: Use an expiring cache or something
-    using MessageCookieMap =
-        std::map<uint256, std::set<std::optional<uint64_t>>>;
-    using PeerCookieMap =
-        std::map<std::shared_ptr<Peer>, std::set<std::optional<uint64_t>>>;
-    std::mutex mutable cookieLock_;
-    MessageCookieMap messageRequestCookies_;
-
    friend class OverlayImpl;

    class Metrics
@@ -505,13 +496,6 @@ public:
        return txReduceRelayEnabled_;
    }

-    //
-    // Messages
-    //
-
-    std::set<std::optional<uint64_t>>
-    releaseRequestCookies(uint256 const& requestHash) override;
-
 private:
    /**
     * @brief Handles a failure associated with a specific error code.
@@ -814,28 +798,16 @@ private:
    void
    sendLedgerBase(
        std::shared_ptr<Ledger const> const& ledger,
-        protocol::TMLedgerData& ledgerData,
-        PeerCookieMap const& destinations);
-
-    void
-    sendToMultiple(
-        protocol::TMLedgerData& ledgerData,
-        PeerCookieMap const& destinations);
+        protocol::TMLedgerData& ledgerData);

    std::shared_ptr<Ledger const>
-    getLedger(
-        std::shared_ptr<protocol::TMGetLedger> const& m,
-        uint256 const& mHash);
+    getLedger(std::shared_ptr<protocol::TMGetLedger> const& m);

    std::shared_ptr<SHAMap const>
-    getTxSet(
-        std::shared_ptr<protocol::TMGetLedger> const& m,
-        uint256 const& mHash) const;
+    getTxSet(std::shared_ptr<protocol::TMGetLedger> const& m) const;

    void
-    processLedgerRequest(
-        std::shared_ptr<protocol::TMGetLedger> const& m,
-        uint256 const& mHash);
+    processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m);
 };

 //------------------------------------------------------------------------------
--- a/src/xrpld/overlay/detail/PeerSet.cpp
+++ b/src/xrpld/overlay/detail/PeerSet.cpp
@@ -1,11 +1,8 @@
 #include <xrpld/app/main/Application.h>
-#include <xrpld/app/misc/HashRouter.h>
-#include <xrpld/core/JobQueue.h>
 #include <xrpld/overlay/Overlay.h>
 #include <xrpld/overlay/PeerSet.h>

 #include <xrpl/core/JobQueue.h>
-#include <xrpl/protocol/digest.h>

 namespace xrpl {

@@ -89,52 +86,16 @@ PeerSetImpl::sendRequest(
    std::shared_ptr<Peer> const& peer)
 {
    auto packet = std::make_shared<Message>(message, type);
-
-    auto const messageHash = [&]() {
-        auto const packetBuffer =
-            packet->getBuffer(compression::Compressed::Off);
-        return sha512Half(Slice(packetBuffer.data(), packetBuffer.size()));
-    }();
-
-    // Allow messages to be re-sent to the same peer after a delay
-    using namespace std::chrono_literals;
-    constexpr std::chrono::seconds interval = 30s;
-
    if (peer)
    {
-        if (app_.getHashRouter().shouldProcessForPeer(
-                messageHash, peer->id(), interval))
-        {
-            JLOG(journal_.trace())
-                << "Sending " << protocolMessageName(type) << " message to ["
-                << peer->id() << "]: " << messageHash;
-            peer->send(packet);
-        }
-        else
-            JLOG(journal_.debug())
-                << "Suppressing sending duplicate " << protocolMessageName(type)
-                << " message to [" << peer->id() << "]: " << messageHash;
+        peer->send(packet);
        return;
    }

    for (auto id : peers_)
    {
        if (auto p = app_.overlay().findPeerByShortID(id))
-        {
-            if (app_.getHashRouter().shouldProcessForPeer(
-                    messageHash, p->id(), interval))
-            {
-                JLOG(journal_.trace())
-                    << "Sending " << protocolMessageName(type)
-                    << " message to [" << p->id() << "]: " << messageHash;
-                p->send(packet);
-            }
-            else
-                JLOG(journal_.debug())
-                    << "Suppressing sending duplicate "
-                    << protocolMessageName(type) << " message to [" << p->id()
-                    << "]: " << messageHash;
-        }
+            p->send(packet);
    }
 }

--- a/src/xrpld/overlay/detail/ProtocolMessage.h
+++ b/src/xrpld/overlay/detail/ProtocolMessage.h
@@ -24,12 +24,6 @@ protocolMessageType(protocol::TMGetLedger const&)
    return protocol::mtGET_LEDGER;
 }

-inline protocol::MessageType
-protocolMessageType(protocol::TMLedgerData const&)
-{
-    return protocol::mtLEDGER_DATA;
-}
-
 inline protocol::MessageType
 protocolMessageType(protocol::TMReplayDeltaRequest const&)
 {
@@ -473,64 +467,4 @@ invokeProtocolMessage(

 }  // namespace xrpl

-namespace protocol {
-
-template <class Hasher>
-void
-hash_append(Hasher& h, TMGetLedger const& msg)
-{
-    using beast::hash_append;
-    using namespace ripple;
-    hash_append(h, safe_cast<int>(protocolMessageType(msg)));
-    hash_append(h, safe_cast<int>(msg.itype()));
-    if (msg.has_ltype())
-        hash_append(h, safe_cast<int>(msg.ltype()));
-
-    if (msg.has_ledgerhash())
-        hash_append(h, msg.ledgerhash());
-
-    if (msg.has_ledgerseq())
-        hash_append(h, msg.ledgerseq());
-
-    for (auto const& nodeId : msg.nodeids())
-        hash_append(h, nodeId);
-    hash_append(h, msg.nodeids_size());
-
-    // Do NOT include the request cookie. It does not affect the content of the
-    // request, but only where to route the results.
-    // if (msg.has_requestcookie())
-    //    hash_append(h, msg.requestcookie());
-
-    if (msg.has_querytype())
-        hash_append(h, safe_cast<int>(msg.querytype()));
-
-    if (msg.has_querydepth())
-        hash_append(h, msg.querydepth());
-}
-
-template <class Hasher>
-void
-hash_append(Hasher& h, TMLedgerData const& msg)
-{
-    using beast::hash_append;
-    using namespace ripple;
-    hash_append(h, safe_cast<int>(protocolMessageType(msg)));
-    hash_append(h, msg.ledgerhash());
-    hash_append(h, msg.ledgerseq());
-    hash_append(h, safe_cast<int>(msg.type()));
-    for (auto const& node : msg.nodes())
-    {
-        hash_append(h, node.nodedata());
-        if (node.has_nodeid())
-            hash_append(h, node.nodeid());
-    }
-    hash_append(h, msg.nodes_size());
-    if (msg.has_requestcookie())
-        hash_append(h, msg.requestcookie());
-    if (msg.has_error())
-        hash_append(h, safe_cast<int>(msg.error()));
-}
-
-}  // namespace protocol
-
 #endif
--- a/src/xrpld/overlay/detail/ProtocolVersion.cpp
+++ b/src/xrpld/overlay/detail/ProtocolVersion.cpp
@@ -21,9 +21,7 @@ namespace xrpl {
 constexpr ProtocolVersion const supportedProtocolList[]
 {
    {2, 1},
-    {2, 2},
-    // Adds TMLedgerData::responseCookies and directResponse
-    {2, 3}
+    {2, 2}
 };
 // clang-format on