remove unused

.github/scripts/strategy-matrix/generate.py

@@ -156,107 +156,15 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
         # Add the configuration to the list, with the most unique fields first,
         # so that they are easier to identify in the GitHub Actions UI, as long
         # names get truncated.
-        # Add Address and Thread (both coupled with UB) sanitizers when the distro is bookworm.
-        if os['distro_version'] == 'bookworm' and f'{os["compiler_name"]}-{os["compiler_version"]}' in {'gcc-15', 'clang-20'}:
-            extra_warning_flags = ''
-            linker_relocation_flags = ''
-            linker_flags = ''
-            cxx_flags += ' -DBOOST_USE_TSAN -DBOOST_USE_UBSAN -DBOOST_USE_UCONTEXT'
-
-            # Use large code model to avoid relocation errors with large binaries
-            # Only for x86-64 (amd64) - ARM64 doesn't support -mcmodel=large
-            if architecture['platform'] == 'linux/amd64' and os['compiler_name'] == 'gcc':
-                # Add -mcmodel=large and -fPIC to both compiler AND linker flags
-                # This is needed because sanitizers create very large binaries
-                # -fPIC enables position independent code to avoid relocation range issues
-                # large model removes the 2GB limitation that medium model has
-                cxx_flags += ' -mcmodel=large -fno-PIC'
-                linker_relocation_flags+=' -mcmodel=large -fno-PIC'
-
-            # Create default sanitizer flags
-            sanitizers_flags = 'undefined,float-divide-by-zero'
-
-            if os['compiler_name'] == 'gcc':
-                sanitizers_flags = f'{sanitizers_flags},signed-integer-overflow'
-                # Suppress false positive warnings in GCC with stringop-overflow
-                extra_warning_flags += ' -Wno-stringop-overflow'
-                # Disable mold, gold and lld linkers.
-                # Use default linker (bfd/ld) which is more lenient with mixed code models
-                cmake_args += ' -Duse_mold=OFF -Duse_gold=OFF -Duse_lld=OFF'
-                # Add linker flags for Sanitizers
-                linker_flags += f' -DCMAKE_EXE_LINKER_FLAGS="{linker_relocation_flags} -fsanitize=address,{sanitizers_flags}"'
-                linker_flags += f' -DCMAKE_SHARED_LINKER_FLAGS="{linker_relocation_flags} -fsanitize=address,{sanitizers_flags}"'
-            elif os['compiler_name'] == 'clang':
-                sanitizers_flags = f'{sanitizers_flags},signed-integer-overflow,unsigned-integer-overflow'
-                linker_flags += f' -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address,{sanitizers_flags}"'
-                linker_flags += f' -DCMAKE_SHARED_LINKER_FLAGS="-fsanitize=address,{sanitizers_flags}"'
-
-            # Sanitizers recommend minimum of -O1 for reasonable performance
-            if "-O0" in cxx_flags:
-                cxx_flags = cxx_flags.replace("-O0", "-O1")
-            else:
-                cxx_flags += " -O1"
-
-            # First create config for asan
-            cmake_args_flags = f'{cmake_args} -DCMAKE_CXX_FLAGS="-fsanitize=address,{sanitizers_flags} -fno-omit-frame-pointer {cxx_flags} {extra_warning_flags}" {linker_flags}'
-
-            # Add config with asan
-            configurations.append({
-                'config_name': config_name + "_asan",
-                'cmake_args': cmake_args_flags,
-                'cmake_target': cmake_target,
-                'build_only': build_only,
-                'build_type': build_type,
-                'os': os,
-                'architecture': architecture,
-                'sanitizers': 'Address'
-            })
-
-            linker_flags = ''
-            # Update configs for tsan
-            # gcc doesn't supports atomic_thread_fence with tsan. Suppress warnings.
-            # Also tsan doesn't work well with mcmode=large and bfd linker
-            if os['compiler_name'] == 'gcc':
-                extra_warning_flags += ' -Wno-tsan'
-                cxx_flags = cxx_flags.replace('-mcmodel=large', '-mcmodel=medium')
-                linker_relocation_flags = linker_relocation_flags.replace('-mcmodel=large', '-mcmodel=medium')
-                # Add linker flags for Sanitizers
-                linker_flags += f' -DCMAKE_EXE_LINKER_FLAGS="{linker_relocation_flags} -fsanitize=thread,{sanitizers_flags}"'
-                linker_flags += f' -DCMAKE_SHARED_LINKER_FLAGS="{linker_relocation_flags} -fsanitize=thread,{sanitizers_flags}"'
-            elif os['compiler_name'] == 'clang':
-                cxx_flags += ' -fsanitize-blacklist=$GITHUB_WORKSPACE/external/sanitizer-blacklist.txt'
-                linker_flags += f' -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=thread,{sanitizers_flags}"'
-                linker_flags += f' -DCMAKE_SHARED_LINKER_FLAGS="-fsanitize=thread,{sanitizers_flags}"'
-
-            # Note: We use $GITHUB_WORKSPACE environment variable which will be expanded by the shell
-            # before CMake processes it. This ensures the compiler receives an absolute path.
-            # CMAKE_SOURCE_DIR won't work here because it's inside CMAKE_CXX_FLAGS string.
-            cmake_args_flags = f'{cmake_args} -DCMAKE_CXX_FLAGS="-fsanitize=thread,{sanitizers_flags} -fno-omit-frame-pointer {cxx_flags} {extra_warning_flags}" {linker_flags}'
-
-            configurations.append({
-                'config_name': config_name+ "_tsan",
-                'cmake_args': cmake_args_flags,
-                'cmake_target': cmake_target,
-                'build_only': build_only,
-                'build_type': build_type,
-                'os': os,
-                'architecture': architecture,
-                'sanitizers': 'Thread'
-            })
-        else:
-            if cxx_flags:
-                cmake_args_flags = f'{cmake_args} -DCMAKE_CXX_FLAGS={cxx_flags}'
-            else:
-                cmake_args_flags = f'{cmake_args}'
-            configurations.append({
-                'config_name': config_name,
-                'cmake_args': cmake_args_flags,
-                'cmake_target': cmake_target,
-                'build_only': build_only,
-                'build_type': build_type,
-                'os': os,
-                'architecture': architecture
-            })
+        configurations.append({
+            'config_name': config_name,
+            'cmake_args': cmake_args,
+            'cmake_target': cmake_target,
+            'build_only': build_only,
+            'build_type': build_type,
+            'os': os,
+            'architecture': architecture,
+        })
 
     return configurations
 

.github/workflows/reusable-build-test-config.yml

@@ -130,7 +130,7 @@ jobs:
             --target "${CMAKE_TARGET}"
 
       - name: Upload rippled artifact (Linux)
-        if: ${{ github.repository_owner == 'XRPLF' && runner.os == 'Linux' }}
+        if: ${{ runner.os == 'Linux' }}
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         env:
           BUILD_DIR: ${{ inputs.build_dir }}

cmake/XrplConfig.cmake

@@ -17,7 +17,7 @@ find_dependency (Boost
     chrono
     container
     context
-    coroutine2
+    coroutine
     date_time
     filesystem
     program_options

cmake/deps/Boost.cmake

@@ -2,7 +2,7 @@ find_package(Boost 1.82 REQUIRED
   COMPONENTS
     chrono
     container
-    context
+    coroutine
     date_time
     filesystem
     json
@@ -20,7 +20,7 @@ target_link_libraries(xrpl_boost
     Boost::headers
     Boost::chrono
     Boost::container
-    Boost::context
+    Boost::coroutine
     Boost::date_time
     Boost::filesystem
     Boost::json

conan/profiles/ci

@@ -1 +0,0 @@
- include(sanitizers)

conan/profiles/sanitizers

@@ -1,69 +0,0 @@
-include(default)
-{% set compiler, version, compiler_exe = detect_api.detect_default_compiler() %}
-{% set default_sanitizer_flags = "undefined,float-divide-by-zero,signed-integer-overflow" %}
-{% set sanitizers = os.getenv("SANITIZERS") %}
-
-[settings]
-
-[conf]
-
-{% if sanitizers == "Address" or sanitizers == "Thread" %}
-user.package:sanitizers={{ sanitizers }}
-tools.info.package_id:confs+=["user.package:sanitizers"]
-{% endif %}
-
-{% if compiler == "gcc" %}
-
-{% set asan_sanitizer_flags = "-fsanitize=address,"~default_sanitizer_flags~" -mcmodel=large -fno-PIC" %}
-{% set tsan_sanitizer_flags = "-fsanitize=thread,"~default_sanitizer_flags~" -mcmodel=medium -fno-PIC" %}
-
-{% if sanitizers == "Address" %}
-tools.build:cxxflags+=['{{asan_sanitizer_flags}} -fno-omit-frame-pointer -O1 -Wno-stringop-overflow -DBOOST_USE_ASAN -DBOOST_USE_UBSAN -DBOOST_USE_UCONTEXT']
-tools.build:sharedlinkflags+=['{{asan_sanitizer_flags}}']
-tools.build:exelinkflags+=['{{asan_sanitizer_flags}}']
-tools.cmake.cmaketoolchain:extra_variables={"use_mold": "OFF", "use_gold": "OFF", "use_lld": "OFF"}
-tools.build:defines+=["BOOST_USE_ASAN", "BOOST_USE_UBSAN", "BOOST_USE_UCONTEXT"]
-
-{% elif sanitizers == "Thread" %}
-tools.build:cxxflags+=['{{tsan_sanitizer_flags}} -fno-omit-frame-pointer -O1 -Wno-stringop-overflow -Wno-tsan -DBOOST_USE_TSAN -DBOOST_USE_UBSAN -DBOOST_USE_UCONTEXT']
-tools.build:sharedlinkflags+=['{{tsan_sanitizer_flags}}']
-tools.build:exelinkflags+=['{{tsan_sanitizer_flags}}']
-tools.build:defines+=["BOOST_USE_TSAN", "BOOST_USE_UBSAN", "BOOST_USE_UCONTEXT"]
-
-{% endif %}
-
-{% elif compiler == "apple-clang" or compiler == "clang" %}
-
-{% set asan_sanitizer_flags = "-fsanitize=address,"~default_sanitizer_flags~",unsigned-integer-overflow" %}
-{% set tsan_sanitizer_flags = "-fsanitize=thread,"~default_sanitizer_flags~",unsigned-integer-overflow" %}
-{% if sanitizers == "Address" %}
-tools.build:cxxflags+=['{{asan_sanitizer_flags}} -fno-omit-frame-pointer -O1 -DBOOST_USE_ASAN -DBOOST_USE_UBSAN -DBOOST_USE_UCONTEXT']
-tools.build:sharedlinkflags+=['{{asan_sanitizer_flags}}']
-tools.build:exelinkflags+=['{{asan_sanitizer_flags}}']
-tools.build:defines+=["BOOST_USE_ASAN", "BOOST_USE_UBSAN", "BOOST_USE_UCONTEXT"]
-
-{% elif sanitizers == "Thread" %}
-tools.build:cxxflags+=['{{tsan_sanitizer_flags}} -fno-omit-frame-pointer -O1 -DBOOST_USE_TSAN -DBOOST_USE_UBSAN -DBOOST_USE_UCONTEXT']
-tools.build:sharedlinkflags+=['{{tsan_sanitizer_flags}}']
-tools.build:exelinkflags+=['{{tsan_sanitizer_flags}}']
-tools.build:defines+=["BOOST_USE_TSAN", "BOOST_USE_UBSAN", "BOOST_USE_UCONTEXT"]
-
-{% endif %}
-
-{% endif %}
-
-[options]
-{% if compiler == "gcc" or compiler == "apple-clang" or compiler == "clang" %}
-{% if sanitizers == "Address" or sanitizers == "Thread" %}
-boost/*:without_context=False
-boost/*:without_stacktrace=True
-boost/*:without_coroutine2=False
-
-{% if sanitizers == "Address" %}
-boost/*:extra_b2_flags="context-impl=ucontext address-sanitizer=norecover undefined-sanitizer=norecover --with-coroutine2"
-{% elif sanitizers == "Thread" %}
-boost/*:extra_b2_flags="context-impl=ucontext thread-sanitizer=norecover undefined-sanitizer=norecover --with-coroutine2"
-{% endif %}
-
-{% endif %}
-{% endif %}

conanfile.py

@@ -102,7 +102,6 @@ class Xrpl(ConanFile):
             self.options['boost'].visibility = 'global'
         if self.settings.compiler in ['clang', 'gcc']:
             self.options['boost'].without_cobalt = True
-        self.options['boost'].without_coroutine2 = False
 
     def requirements(self):
         # Conan 2 requires transitive headers to be specified
@@ -173,8 +172,7 @@ class Xrpl(ConanFile):
             'boost::headers',
             'boost::chrono',
             'boost::container',
-            'boost::context',
-            'boost::coroutine2',
+            'boost::coroutine',
             'boost::date_time',
             'boost::filesystem',
             'boost::json',

include/xrpl/basics/MallocTrim.h

@@ -0,0 +1,70 @@
+#ifndef XRPL_BASICS_MALLOCTRIM_H_INCLUDED
+#define XRPL_BASICS_MALLOCTRIM_H_INCLUDED
+
+#include <xrpl/beast/utility/Journal.h>
+
+#include <optional>
+#include <string>
+
+namespace ripple {
+
+// -----------------------------------------------------------------------------
+// Allocator interaction note:
+// - This facility invokes glibc's malloc_trim(0) on Linux/glibc to request that
+//   ptmalloc return free heap pages to the OS.
+// - If an alternative allocator (e.g. jemalloc or tcmalloc) is linked or
+//   preloaded (LD_PRELOAD), calling glibc's malloc_trim typically has no effect
+//   on the *active* heap. The call is harmless but may not reclaim memory
+//   because those allocators manage their own arenas.
+// - Only glibc sbrk/arena space is eligible for trimming; large mmap-backed
+//   allocations are usually returned to the OS on free regardless of trimming.
+// - Call at known reclamation points (e.g., after cache sweeps / online delete)
+//   and consider rate limiting to avoid churn.
+// -----------------------------------------------------------------------------
+
+struct MallocTrimReport
+{
+    bool supported{false};
+    int trimResult{-1};
+    long rssBeforeKB{-1};
+    long rssAfterKB{-1};
+
+    [[nodiscard]] long
+    deltaKB() const noexcept
+    {
+        if (rssBeforeKB < 0 || rssAfterKB < 0)
+            return 0;
+        return rssAfterKB - rssBeforeKB;
+    }
+};
+
+/**
+ * @brief Attempt to return freed memory to the operating system.
+ *
+ * On Linux with glibc malloc, this issues ::malloc_trim(0), which may release
+ * free space from ptmalloc arenas back to the kernel. On other platforms, or if
+ * a different allocator is in use, this function is a no-op and the report will
+ * indicate that trimming is unsupported or had no effect.
+ *
+ * @param tag     Optional identifier for logging/debugging purposes.
+ * @param journal Journal for diagnostic logging.
+ * @return Report containing before/after metrics and the trim result.
+ *
+ * @note If an alternative allocator (jemalloc/tcmalloc) is linked or preloaded,
+ *       calling glibc's malloc_trim may have no effect on the active heap. The
+ *       call is harmless but typically does not reclaim memory under those
+ *       allocators.
+ *
+ * @note Only memory served from glibc's sbrk/arena heaps is eligible for trim.
+ *       Large allocations satisfied via mmap are usually returned on free
+ *       independently of trimming.
+ *
+ * @note Intended for use after operations that free significant memory (e.g.,
+ *       cache sweeps, ledger cleanup, online delete). Consider rate limiting.
+ */
+MallocTrimReport
+mallocTrim(std::optional<std::string> const& tag, beast::Journal journal);
+
+}  // namespace ripple
+
+#endif

src/libxrpl/basics/MallocTrim.cpp

@@ -0,0 +1,121 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/MallocTrim.h>
+
+#include <boost/predef.h>
+
+#include <cstdio>
+#include <fstream>
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+#include <malloc.h>
+#include <unistd.h>
+
+namespace {
+pid_t const cachedPid = ::getpid();
+}  // namespace
+#endif
+
+namespace ripple {
+
+namespace detail {
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+
+long
+parseVmRSSkB(std::string const& status)
+{
+    std::istringstream iss(status);
+    std::string line;
+
+    while (std::getline(iss, line))
+    {
+        // Allow leading spaces/tabs before the key.
+        auto const firstNonWs = line.find_first_not_of(" \t");
+        if (firstNonWs == std::string::npos)
+            continue;
+
+        constexpr char key[] = "VmRSS:";
+        constexpr auto keyLen = sizeof(key) - 1;
+
+        // Require the line (after leading whitespace) to start with "VmRSS:".
+        // Check if we have enough characters and the substring matches.
+        if (firstNonWs + keyLen > line.size() ||
+            line.substr(firstNonWs, keyLen) != key)
+            continue;
+
+        // Move past "VmRSS:" and any following whitespace.
+        auto pos = firstNonWs + keyLen;
+        while (pos < line.size() &&
+               std::isspace(static_cast<unsigned char>(line[pos])))
+        {
+            ++pos;
+        }
+
+        long value = -1;
+        if (std::sscanf(line.c_str() + pos, "%ld", &value) == 1)
+            return value;
+
+        // Found the key but couldn't parse a number.
+        return -1;
+    }
+
+    // No VmRSS line found.
+    return -1;
+}
+
+#endif  // __GLIBC__ && BOOST_OS_LINUX
+
+}  // namespace detail
+
+MallocTrimReport
+mallocTrim(
+    [[maybe_unused]] std::optional<std::string> const& tag,
+    beast::Journal journal)
+{
+    MallocTrimReport report;
+
+#if !(defined(__GLIBC__) && BOOST_OS_LINUX)
+    JLOG(journal.debug()) << "malloc_trim not supported on this platform";
+#else
+
+    report.supported = true;
+
+    if (journal.debug())
+    {
+        auto readFile = [](std::string const& path) -> std::string {
+            std::ifstream ifs(path);
+            if (!ifs.is_open())
+                return {};
+            return std::string(
+                std::istreambuf_iterator<char>(ifs),
+                std::istreambuf_iterator<char>());
+        };
+
+        std::string const tagStr = tag.value_or("default");
+        std::string const statusPath =
+            "/proc/" + std::to_string(cachedPid) + "/status";
+
+        auto const statusBefore = readFile(statusPath);
+        report.rssBeforeKB = detail::parseVmRSSkB(statusBefore);
+
+        report.trimResult = ::malloc_trim(0);
+
+        auto const statusAfter = readFile(statusPath);
+        report.rssAfterKB = detail::parseVmRSSkB(statusAfter);
+
+        JLOG(journal.debug())
+            << "malloc_trim tag=" << tagStr << " result=" << report.trimResult
+            << " rss_before=" << report.rssBeforeKB << "kB"
+            << " rss_after=" << report.rssAfterKB << "kB"
+            << " delta=" << report.deltaKB() << "kB";
+    }
+    else
+    {
+        report.trimResult = ::malloc_trim(0);
+    }
+#endif
+
+    return report;
+}
+
+}  // namespace ripple

src/test/rpc/LedgerEntry_test.cpp

@@ -1103,7 +1103,7 @@ class LedgerEntry_test : public beast::unit_test::suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedAuthorizedCredentials",
-                "Invalid field 'authorized_credentials', array empty.");
+                "Invalid field 'authorized_credentials', not array.");
         }
 
         {
@@ -1144,7 +1144,7 @@ class LedgerEntry_test : public beast::unit_test::suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedAuthorizedCredentials",
-                "Invalid field 'authorized_credentials', array too long.");
+                "Invalid field 'authorized_credentials', not array.");
         }
     }
 

src/test/rpc/RPCCall_test.cpp

@@ -1584,6 +1584,8 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
+         "junk",  // Note: indexing bug in parseBookOffers() requires junk
+                  // param.
          "200",
      },
      RPCCallTestData::no_exception,
@@ -1595,6 +1597,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "limit" : 200,
+         "proof" : true,
          "taker_gets" : {
             "currency" : "EUR",
             "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
@@ -1614,8 +1617,8 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
+      "junk",  // Note: indexing bug in parseBookOffers() requires junk param.
       "200",
-      "0",
       "MyMarker"},
      RPCCallTestData::no_exception,
      R"({
@@ -1627,6 +1630,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "limit" : 200,
          "marker" : "MyMarker",
+         "proof" : true,
          "taker_gets" : {
             "currency" : "EUR",
             "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
@@ -1661,8 +1665,8 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
+      "junk",  // Note: indexing bug in parseBookOffers() requires junk param.
       "200",
-      "0",
       "MyMarker",
       "extra"},
      RPCCallTestData::no_exception,
@@ -1766,19 +1770,12 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
+         "junk",  // Note: indexing bug in parseBookOffers() requires junk
+                  // param.
          "not_a_number",
      },
-     RPCCallTestData::no_exception,
-     R"({
-    "method" : "book_offers",
-    "params" : [
-      {
-         "error" : "invalidParams",
-         "error_code" : 31,
-         "error_message" : "Invalid field 'limit'."
-      }
-    ]
-    })"},
+     RPCCallTestData::bad_cast,
+     R"()"},
 
     // can_delete
     // ------------------------------------------------------------------

src/tests/libxrpl/basics/MallocTrim.cpp

@@ -0,0 +1,207 @@
+#include <xrpl/basics/MallocTrim.h>
+
+#include <boost/predef.h>
+
+#include <doctest/doctest.h>
+
+using namespace ripple;
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+namespace ripple::detail {
+long
+parseVmRSSkB(std::string const& status);
+}  // namespace ripple::detail
+#endif
+
+TEST_CASE("MallocTrimReport structure")
+{
+    // Test default construction
+    MallocTrimReport report;
+    CHECK(report.supported == false);
+    CHECK(report.trimResult == -1);
+    CHECK(report.rssBeforeKB == -1);
+    CHECK(report.rssAfterKB == -1);
+    CHECK(report.deltaKB() == 0);
+
+    // Test deltaKB calculation - memory freed
+    report.rssBeforeKB = 1000;
+    report.rssAfterKB = 800;
+    CHECK(report.deltaKB() == -200);
+
+    // Test deltaKB calculation - memory increased
+    report.rssBeforeKB = 500;
+    report.rssAfterKB = 600;
+    CHECK(report.deltaKB() == 100);
+
+    // Test deltaKB calculation - no change
+    report.rssBeforeKB = 1234;
+    report.rssAfterKB = 1234;
+    CHECK(report.deltaKB() == 0);
+}
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+TEST_CASE("parseVmRSSkB")
+{
+    using ripple::detail::parseVmRSSkB;
+
+    // Test standard format
+    {
+        std::string status = "VmRSS:      123456 kB\n";
+        long result = parseVmRSSkB(status);
+        CHECK(result == 123456);
+    }
+
+    // Test with multiple lines
+    {
+        std::string status =
+            "Name:   rippled\n"
+            "VmPeak:  1234567 kB\n"
+            "VmSize:  1234567 kB\n"
+            "VmRSS:      987654 kB\n"
+            "VmData:   123456 kB\n";
+        long result = parseVmRSSkB(status);
+        CHECK(result == 987654);
+    }
+
+    // Test with minimal whitespace
+    {
+        std::string status = "VmRSS: 42 kB";
+        long result = parseVmRSSkB(status);
+        CHECK(result == 42);
+    }
+
+    // Test with extra whitespace
+    {
+        std::string status = "VmRSS:          999999 kB";
+        long result = parseVmRSSkB(status);
+        CHECK(result == 999999);
+    }
+
+    // Test with tabs
+    {
+        std::string status = "VmRSS:\t\t12345 kB";
+        long result = parseVmRSSkB(status);
+        // Note: tabs are not explicitly handled as spaces, this documents
+        // current behavior
+        CHECK(result == 12345);
+    }
+
+    // Test zero value
+    {
+        std::string status = "VmRSS:      0 kB\n";
+        long result = parseVmRSSkB(status);
+        CHECK(result == 0);
+    }
+
+    // Test missing VmRSS
+    {
+        std::string status =
+            "Name:   rippled\n"
+            "VmPeak:  1234567 kB\n"
+            "VmSize:  1234567 kB\n";
+        long result = parseVmRSSkB(status);
+        CHECK(result == -1);
+    }
+
+    // Test empty string
+    {
+        std::string status = "";
+        long result = parseVmRSSkB(status);
+        CHECK(result == -1);
+    }
+
+    // Test malformed data (VmRSS but no number)
+    {
+        std::string status = "VmRSS:      \n";
+        long result = parseVmRSSkB(status);
+        // sscanf should fail to parse and return -1 unchanged
+        CHECK(result == -1);
+    }
+
+    // Test malformed data (VmRSS but invalid number)
+    {
+        std::string status = "VmRSS:      abc kB\n";
+        long result = parseVmRSSkB(status);
+        // sscanf should fail and return -1 unchanged
+        CHECK(result == -1);
+    }
+
+    // Test partial match (should not match "NotVmRSS:")
+    {
+        std::string status = "NotVmRSS:      123456 kB\n";
+        long result = parseVmRSSkB(status);
+        CHECK(result == -1);
+    }
+}
+#endif
+
+TEST_CASE("mallocTrim basic functionality")
+{
+    beast::Journal journal{beast::Journal::getNullSink()};
+
+    // Test with no tag
+    {
+        MallocTrimReport report = mallocTrim(std::nullopt, journal);
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+        // On Linux with glibc, should be supported
+        CHECK(report.supported == true);
+        // trimResult should be 0 or 1 (success indicators)
+        CHECK(report.trimResult >= 0);
+#else
+        // On other platforms, should be unsupported
+        CHECK(report.supported == false);
+        CHECK(report.trimResult == -1);
+        CHECK(report.rssBeforeKB == -1);
+        CHECK(report.rssAfterKB == -1);
+#endif
+    }
+
+    // Test with tag
+    {
+        MallocTrimReport report =
+            mallocTrim(std::optional<std::string>("test_tag"), journal);
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+        CHECK(report.supported == true);
+        CHECK(report.trimResult >= 0);
+#else
+        CHECK(report.supported == false);
+#endif
+    }
+}
+
+TEST_CASE("mallocTrim with debug logging")
+{
+    beast::Journal journal{beast::Journal::getNullSink()};
+
+    MallocTrimReport report =
+        mallocTrim(std::optional<std::string>("debug_test"), journal);
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+    CHECK(report.supported == true);
+    // The function should complete without crashing
+#else
+    CHECK(report.supported == false);
+#endif
+}
+
+TEST_CASE("mallocTrim repeated calls")
+{
+    beast::Journal journal{beast::Journal::getNullSink()};
+
+    // Call malloc_trim multiple times to ensure it's safe
+    for (int i = 0; i < 5; ++i)
+    {
+        MallocTrimReport report = mallocTrim(
+            std::optional<std::string>("iteration_" + std::to_string(i)),
+            journal);
+
+#if defined(__GLIBC__) && BOOST_OS_LINUX
+        CHECK(report.supported == true);
+        CHECK(report.trimResult >= 0);
+#else
+        CHECK(report.supported == false);
+#endif
+    }
+}

src/xrpld/app/main/Application.cpp

@@ -37,6 +37,7 @@
 #include <xrpld/shamap/NodeFamily.h>
 
 #include <xrpl/basics/ByteUtilities.h>
+#include <xrpl/basics/MallocTrim.h>
 #include <xrpl/basics/ResolverAsio.h>
 #include <xrpl/basics/random.h>
 #include <xrpl/beast/asio/io_latency_probe.h>
@@ -1106,6 +1107,8 @@ public:
                 << "; size after: " << cachedSLEs_.size();
         }
 
+        mallocTrim(std::optional<std::string>("doSweep"), m_journal);
+
         // Set timer to do another sweep later.
         setSweepTimer();
     }

src/xrpld/app/misc/NetworkOPs.cpp

@@ -34,6 +34,7 @@
 #include <xrpld/rpc/MPTokenIssuanceID.h>
 #include <xrpld/rpc/ServerHandler.h>
 
+#include <xrpl/basics/MallocTrim.h>
 #include <xrpl/basics/UptimeClock.h>
 #include <xrpl/basics/mulDiv.h>
 #include <xrpl/basics/safe_cast.h>
@@ -2546,10 +2547,14 @@ NetworkOPsImp::setMode(OperatingMode om)
     if (mMode == om)
         return;
 
+    auto const oldMode = mMode.load(std::memory_order_relaxed);
     mMode = om;
 
     accounting_.mode(om);
 
+    if (oldMode != OperatingMode::FULL && om == OperatingMode::FULL)
+        mallocTrim(std::optional<std::string>("SyncComplete"), m_journal);
+
     JLOG(m_journal.info()) << "STATE->" << strOperatingMode();
     pubServer();
 }

src/xrpld/app/misc/SHAMapStoreImp.cpp

@@ -5,6 +5,7 @@
 #include <xrpld/app/rdb/backend/SQLiteDatabase.h>
 #include <xrpld/core/ConfigSections.h>
 
+#include <xrpl/basics/MallocTrim.h>
 #include <xrpl/beast/core/CurrentThreadName.h>
 #include <xrpl/nodestore/Scheduler.h>
 #include <xrpl/nodestore/detail/DatabaseRotatingImp.h>
@@ -545,6 +546,8 @@ SHAMapStoreImp::clearCaches(LedgerIndex validatedSeq)
 {
     ledgerMaster_->clearLedgerCachePrior(validatedSeq);
     fullBelowCache_->clear();
+
+    mallocTrim(std::optional<std::string>("clearCaches"), journal_);
 }
 
 void
@@ -610,6 +613,8 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
         });
     if (healthWait() == stopping)
         return;
+
+    mallocTrim(std::optional<std::string>("clearPrior"), journal_);
 }
 
 SHAMapStoreImp::HealthResult

src/xrpld/core/Coro.ipp

@@ -16,16 +16,18 @@ JobQueue::Coro::Coro(
     , type_(type)
     , name_(name)
     , running_(false)
-    , coro_([this, fn = std::forward<F>(f)](
-                boost::coroutines2::asymmetric_coroutine<void>::push_type&
-                    do_yield) {
-        yield_ = &do_yield;
-        yield();
-        fn(shared_from_this());
+    , coro_(
+          [this, fn = std::forward<F>(f)](
+              boost::coroutines::asymmetric_coroutine<void>::push_type&
+                  do_yield) {
+              yield_ = &do_yield;
+              yield();
+              fn(shared_from_this());
 #ifndef NDEBUG
-        finished_ = true;
+              finished_ = true;
 #endif
-    })
+          },
+          boost::coroutines::attributes(megabytes(1)))
 {
 }
 

src/xrpld/core/JobQueue.h

@@ -9,7 +9,7 @@
 #include <xrpl/basics/LocalValue.h>
 #include <xrpl/json/json_value.h>
 
-#include <boost/coroutine2/all.hpp>
+#include <boost/coroutine/all.hpp>
 
 #include <set>
 
@@ -50,8 +50,8 @@ public:
         std::mutex mutex_;
         std::mutex mutex_run_;
         std::condition_variable cv_;
-        boost::coroutines2::asymmetric_coroutine<void>::pull_type coro_;
-        boost::coroutines2::asymmetric_coroutine<void>::push_type* yield_;
+        boost::coroutines::asymmetric_coroutine<void>::pull_type coro_;
+        boost::coroutines::asymmetric_coroutine<void>::push_type* yield_;
 #ifndef NDEBUG
         bool finished_ = false;
 #endif
@@ -334,7 +334,7 @@ private:
     other requests while the RPC command completes its work asynchronously.
 
     postCoro() creates a Coro object. When the Coro ctor is called, and its
-    coro_ member is initialized (a boost::coroutines2::pull_type), execution
+    coro_ member is initialized (a boost::coroutines::pull_type), execution
     automatically passes to the coroutine, which we don't want at this point,
     since we are still in the handler thread context. It's important to note
    here that construction of a boost pull_type automatically passes execution to

src/xrpld/rpc/detail/RPCCall.cpp

@@ -332,31 +332,15 @@ private:
 
         if (jvParams.size() >= 5)
         {
-            try
-            {
-                int iLimit = jvParams[4u].asInt();
+            int iLimit = jvParams[5u].asInt();
 
-                if (iLimit > 0)
-                    jvRequest[jss::limit] = iLimit;
-            }
-            catch (std::exception const&)
-            {
-                return RPC::invalid_field_error(jss::limit);
-            }
+            if (iLimit > 0)
+                jvRequest[jss::limit] = iLimit;
         }
 
-        if (jvParams.size() >= 6)
+        if (jvParams.size() >= 6 && jvParams[5u].asInt())
         {
-            try
-            {
-                int bProof = jvParams[5u].asInt();
-                if (bProof)
-                    jvRequest[jss::proof] = true;
-            }
-            catch (std::exception const&)
-            {
-                return RPC::invalid_field_error(jss::proof);
-            }
+            jvRequest[jss::proof] = true;
         }
 
         if (jvParams.size() == 7)

src/xrpld/rpc/handlers/LedgerEntry.cpp

@@ -16,6 +16,8 @@
 #include <xrpl/protocol/STXChainBridge.h>
 #include <xrpl/protocol/jss.h>
 
+#include <functional>
+
 namespace ripple {
 
 static Expected<uint256, Json::Value>
@@ -176,41 +178,18 @@ static Expected<STArray, Json::Value>
 parseAuthorizeCredentials(Json::Value const& jv)
 {
     if (!jv.isArray())
-    {
         return LedgerEntryHelpers::invalidFieldError(
             "malformedAuthorizedCredentials",
             jss::authorized_credentials,
             "array");
-    }
-
-    std::uint32_t const n = jv.size();
-    if (n > maxCredentialsArraySize)
-    {
-        return Unexpected(LedgerEntryHelpers::malformedError(
-            "malformedAuthorizedCredentials",
-            "Invalid field '" + std::string(jss::authorized_credentials) +
-                "', array too long."));
-    }
-
-    if (n == 0)
-    {
-        return Unexpected(LedgerEntryHelpers::malformedError(
-            "malformedAuthorizedCredentials",
-            "Invalid field '" + std::string(jss::authorized_credentials) +
-                "', array empty."));
-    }
-
-    STArray arr(sfAuthorizeCredentials, n);
+    STArray arr(sfAuthorizeCredentials, jv.size());
     for (auto const& jo : jv)
     {
         if (!jo.isObject())
-        {
             return LedgerEntryHelpers::invalidFieldError(
                 "malformedAuthorizedCredentials",
                 jss::authorized_credentials,
                 "array");
-        }
-
         if (auto const value = LedgerEntryHelpers::hasRequired(
                 jo,
                 {jss::issuer, jss::credential_type},
@@ -281,6 +260,13 @@ parseDepositPreauth(Json::Value const& dp, Json::StaticString const fieldName)
     auto const arr = parseAuthorizeCredentials(ac);
     if (!arr.has_value())
         return Unexpected(arr.error());
+    if (arr->empty() || (arr->size() > maxCredentialsArraySize))
+    {
+        return LedgerEntryHelpers::invalidFieldError(
+            "malformedAuthorizedCredentials",
+            jss::authorized_credentials,
+            "array");
+    }
 
     auto const& sorted = credentials::makeSorted(arr.value());
     if (sorted.empty())