Merge branch 'develop' into pratik/Add_NO_SANITIZE_ADDRESS_macro

Signed-off-by: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com>

.github/scripts/levelization/README.md

@@ -70,7 +70,7 @@ that `test` code should _never_ be included in `xrpl` or `xrpld` code.)
 
 ## Validation
 
-The [levelization](generate.py) script takes no parameters,
+The [levelization](generate.sh) script takes no parameters,
 reads no environment variables, and can be run from any directory,
 as long as it is in the expected location in the rippled repo.
 It can be run at any time from within a checked out repo, and will
@@ -104,7 +104,7 @@ It generates many files of [results](results):
   Github Actions workflow to test that levelization loops haven't
   changed. Unfortunately, if changes are detected, it can't tell if
   they are improvements or not, so if you have resolved any issues or
-  done anything else to improve levelization, run `generate.py`,
+  done anything else to improve levelization, run `levelization.sh`,
   and commit the updated results.
 
 The `loops.txt` and `ordering.txt` files relate the modules
@@ -128,7 +128,7 @@ The committed files hide the detailed values intentionally, to
 prevent false alarms and merging issues, and because it's easy to
 get those details locally.
 
-1. Run `generate.py`
+1. Run `levelization.sh`
 2. Grep the modules in `paths.txt`.
    - For example, if a cycle is found `A ~= B`, simply `grep -w
 A .github/scripts/levelization/results/paths.txt | grep -w B`

.github/scripts/levelization/generate.py

@@ -1,335 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Usage: generate.py
-This script takes no parameters, and can be called from any directory in the file system.
-"""
-
-import os
-import re
-import subprocess
-import sys
-from collections import defaultdict
-from pathlib import Path
-from typing import Dict, List, Tuple, Set, Optional
-
-# Compile regex patterns once at module level
-INCLUDE_PATTERN = re.compile(r"^\s*#include.*/.*\.h")
-INCLUDE_PATH_PATTERN = re.compile(r'[<"]([^>"]+)[>"]')
-
-
-def dictionary_sort_key(s: str) -> str:
-    """
-    Create a sort key that mimics 'sort -d' (dictionary order).
-    Dictionary order only considers blanks and alphanumeric characters.
-    This means punctuation like '.' is ignored during sorting.
-    """
-    # Keep only alphanumeric characters and spaces
-    return "".join(c for c in s if c.isalnum() or c.isspace())
-
-
-def get_level(file_path: str) -> str:
-    """
-    Extract the level from a file path (second and third directory components).
-    Equivalent to bash: cut -d/ -f 2,3
-
-    Examples:
-        src/xrpld/app/main.cpp -> xrpld.app
-        src/libxrpl/protocol/STObject.cpp -> libxrpl.protocol
-        include/xrpl/basics/base_uint.h -> xrpl.basics
-    """
-    parts = file_path.split("/")
-
-    # Get fields 2 and 3 (indices 1 and 2 in 0-based indexing)
-    if len(parts) >= 3:
-        level = f"{parts[1]}/{parts[2]}"
-    elif len(parts) >= 2:
-        level = f"{parts[1]}/toplevel"
-    else:
-        level = file_path
-
-    # If the "level" indicates a file, cut off the filename
-    if "." in level.split("/")[-1]:  # Avoid Path object creation
-        # Use the "toplevel" label as a workaround for `sort`
-        # inconsistencies between different utility versions
-        level = level.rsplit("/", 1)[0] + "/toplevel"
-
-    return level.replace("/", ".")
-
-
-def extract_include_level(include_line: str) -> Optional[str]:
-    """
-    Extract the include path from an #include directive.
-    Gets the first two directory components from the include path.
-    Equivalent to bash: cut -d/ -f 1,2
-
-    Examples:
-        #include <xrpl/basics/base_uint.h> -> xrpl.basics
-        #include "xrpld/app/main/Application.h" -> xrpld.app
-    """
-    # Remove everything before the quote or angle bracket
-    match = INCLUDE_PATH_PATTERN.search(include_line)
-    if not match:
-        return None
-
-    include_path = match.group(1)
-    parts = include_path.split("/")
-
-    # Get first two fields (indices 0 and 1)
-    if len(parts) >= 2:
-        include_level = f"{parts[0]}/{parts[1]}"
-    else:
-        include_level = include_path
-
-    # If the "includelevel" indicates a file, cut off the filename
-    if "." in include_level.split("/")[-1]:  # Avoid Path object creation
-        include_level = include_level.rsplit("/", 1)[0] + "/toplevel"
-
-    return include_level.replace("/", ".")
-
-
-def find_repository_directories(
-    start_path: Path, depth_limit: int = 10
-) -> Tuple[Path, List[Path]]:
-    """
-    Find the repository root by looking for src or include folders.
-    Walks up the directory tree from the start path.
-    """
-    current = start_path.resolve()
-
-    # Walk up the directory tree
-    for _ in range(depth_limit):  # Limit search depth to prevent infinite loops
-        src_path = current / "src"
-        include_path = current / "include"
-        # Check if this directory has src or include folders
-        has_src = src_path.exists()
-        has_include = include_path.exists()
-
-        if has_src or has_include:
-            return current, [src_path, include_path]
-
-        # Move up one level
-        parent = current.parent
-        if parent == current:  # Reached filesystem root
-            break
-        current = parent
-
-    # If we couldn't find it, raise an error
-    raise RuntimeError(
-        "Could not find repository root. "
-        "Expected to find a directory containing 'src' and/or 'include' folders."
-    )
-
-
-def main():
-    # Change to the script's directory
-    script_dir = Path(__file__).parent.resolve()
-    os.chdir(script_dir)
-
-    # Clean up and create results directory.
-    results_dir = script_dir / "results"
-    if results_dir.exists():
-        import shutil
-
-        shutil.rmtree(results_dir)
-    results_dir.mkdir()
-
-    # Find the repository root by searching for src and include directories.
-    try:
-        repo_root, scan_dirs = find_repository_directories(script_dir)
-
-        print(f"Found repository root: {repo_root}")
-        print(f"Scanning directories:")
-        for scan_dir in scan_dirs:
-            print(f"  - {scan_dir.relative_to(repo_root)}")
-    except RuntimeError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    print("\nScanning for raw includes...")
-    # Find all #include directives
-    raw_includes: List[Tuple[str, str]] = []
-    rawincludes_file = results_dir / "rawincludes.txt"
-
-    # Write to file as we go to avoid storing everything in memory.
-    with open(rawincludes_file, "w", buffering=8192) as raw_f:
-        for dir_path in scan_dirs:
-            print(f"  Scanning {dir_path.relative_to(repo_root)}...")
-
-            for file_path in dir_path.rglob("*"):
-                if not file_path.is_file():
-                    continue
-
-                try:
-                    rel_path_str = str(file_path.relative_to(repo_root))
-
-                    # Read file with a large buffer for performance.
-                    with open(
-                        file_path,
-                        "r",
-                        encoding="utf-8",
-                        errors="ignore",
-                        buffering=8192,
-                    ) as f:
-                        for line in f:
-                            # Quick check before regex
-                            if "#include" not in line or "boost" in line:
-                                continue
-
-                            if INCLUDE_PATTERN.match(line):
-                                line_stripped = line.strip()
-                                entry = f"{rel_path_str}:{line_stripped}\n"
-                                print(entry, end="")
-                                raw_f.write(entry)
-                                raw_includes.append((rel_path_str, line_stripped))
-                except Exception as e:
-                    print(f"Error reading {file_path}: {e}", file=sys.stderr)
-
-    # Build levelization paths and count directly (no need to sort first).
-    print("Build levelization paths")
-    path_counts: Dict[Tuple[str, str], int] = defaultdict(int)
-
-    for file_path, include_line in raw_includes:
-        include_level = extract_include_level(include_line)
-        if not include_level:
-            continue
-
-        level = get_level(file_path)
-        if level != include_level:
-            path_counts[(level, include_level)] += 1
-
-    # Sort and deduplicate paths (using dictionary order like bash 'sort -d').
-    print("Sort and deduplicate paths")
-
-    paths_file = results_dir / "paths.txt"
-    with open(paths_file, "w") as f:
-        # Sort using dictionary order: only alphanumeric and spaces matter
-        sorted_items = sorted(
-            path_counts.items(),
-            key=lambda x: (dictionary_sort_key(x[0][0]), dictionary_sort_key(x[0][1])),
-        )
-        for (level, include_level), count in sorted_items:
-            line = f"{count:7} {level} {include_level}\n"
-            print(line.rstrip())
-            f.write(line)
-
-    # Split into flat-file database
-    print("Split into flat-file database")
-    includes_dir = results_dir / "includes"
-    included_by_dir = results_dir / "included_by"
-    includes_dir.mkdir()
-    included_by_dir.mkdir()
-
-    # Batch writes by grouping data first to avoid repeated file opens.
-    includes_data: Dict[str, List[Tuple[str, int]]] = defaultdict(list)
-    included_by_data: Dict[str, List[Tuple[str, int]]] = defaultdict(list)
-
-    # Process in sorted order to match bash script behaviour (dictionary order).
-    sorted_items = sorted(
-        path_counts.items(),
-        key=lambda x: (dictionary_sort_key(x[0][0]), dictionary_sort_key(x[0][1])),
-    )
-    for (level, include_level), count in sorted_items:
-        includes_data[level].append((include_level, count))
-        included_by_data[include_level].append((level, count))
-
-    # Write all includes files in sorted order (dictionary order).
-    for level in sorted(includes_data.keys(), key=dictionary_sort_key):
-        entries = includes_data[level]
-        with open(includes_dir / level, "w") as f:
-            for include_level, count in entries:
-                line = f"{include_level} {count}\n"
-                print(line.rstrip())
-                f.write(line)
-
-    # Write all included_by files in sorted order (dictionary order).
-    for include_level in sorted(included_by_data.keys(), key=dictionary_sort_key):
-        entries = included_by_data[include_level]
-        with open(included_by_dir / include_level, "w") as f:
-            for level, count in entries:
-                line = f"{level} {count}\n"
-                print(line.rstrip())
-                f.write(line)
-
-    # Search for loops
-    print("Search for loops")
-    loops_file = results_dir / "loops.txt"
-    ordering_file = results_dir / "ordering.txt"
-
-    loops_found: Set[Tuple[str, str]] = set()
-
-    # Pre-load all include files into memory to avoid repeated I/O.
-    # This is the biggest optimisation - we were reading files repeatedly in nested loops.
-    # Use list of tuples to preserve file order.
-    includes_cache: Dict[str, List[Tuple[str, int]]] = {}
-    includes_lookup: Dict[str, Dict[str, int]] = {}  # For fast lookup
-
-    # Note: bash script uses 'for source in *' which uses standard glob sorting,
-    # NOT dictionary order. So we use standard sorted() here, not dictionary_sort_key.
-    for include_file in sorted(includes_dir.iterdir(), key=lambda p: p.name):
-        if not include_file.is_file():
-            continue
-
-        includes_cache[include_file.name] = []
-        includes_lookup[include_file.name] = {}
-        with open(include_file, "r") as f:
-            for line in f:
-                parts = line.strip().split()
-                if len(parts) >= 2:
-                    include_name = parts[0]
-                    include_count = int(parts[1])
-                    includes_cache[include_file.name].append(
-                        (include_name, include_count)
-                    )
-                    includes_lookup[include_file.name][include_name] = include_count
-
-    with open(loops_file, "w", buffering=8192) as loops_f, open(
-        ordering_file, "w", buffering=8192
-    ) as ordering_f:
-
-        # Use standard sorting to match bash glob expansion 'for source in *'.
-        for source in sorted(includes_cache.keys()):
-            source_includes = includes_cache[source]
-
-            for include, include_freq in source_includes:
-                # Check if include file exists and references source
-                if include not in includes_lookup:
-                    continue
-
-                source_freq = includes_lookup[include].get(source)
-
-                if source_freq is not None:
-                    # Found a loop
-                    loop_key = tuple(sorted([source, include]))
-                    if loop_key in loops_found:
-                        continue
-                    loops_found.add(loop_key)
-
-                    loops_f.write(f"Loop: {source} {include}\n")
-
-                    # If the counts are close, indicate that the two modules are
-                    # on the same level, though they shouldn't be.
-                    diff = include_freq - source_freq
-                    if diff > 3:
-                        loops_f.write(f"  {source} > {include}\n\n")
-                    elif diff < -3:
-                        loops_f.write(f"  {include} > {source}\n\n")
-                    elif source_freq == include_freq:
-                        loops_f.write(f"  {include} == {source}\n\n")
-                    else:
-                        loops_f.write(f"  {include} ~= {source}\n\n")
-                else:
-                    ordering_f.write(f"{source} > {include}\n")
-
-    # Print results
-    print("\nOrdering:")
-    with open(ordering_file, "r") as f:
-        print(f.read(), end="")
-
-    print("\nLoops:")
-    with open(loops_file, "r") as f:
-        print(f.read(), end="")
-
-
-if __name__ == "__main__":
-    main()

.github/scripts/levelization/generate.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+# Usage: generate.sh
+# This script takes no parameters, reads no environment variables,
+# and can be run from any directory, as long as it is in the expected
+# location in the repo.
+
+pushd $( dirname $0 )
+
+if [ -v PS1 ]
+then
+  # if the shell is interactive, clean up any flotsam before analyzing
+  git clean -ix
+fi
+
+# Ensure all sorting is ASCII-order consistently across platforms.
+export LANG=C
+
+rm -rfv results
+mkdir results
+includes="$( pwd )/results/rawincludes.txt"
+pushd ../../..
+echo Raw includes:
+grep -r '^[ ]*#include.*/.*\.h' include src | \
+    grep -v boost | tee ${includes}
+popd
+pushd results
+
+oldifs=${IFS}
+IFS=:
+mkdir includes
+mkdir included_by
+echo Build levelization paths
+exec 3< ${includes} # open rawincludes.txt for input
+while read -r -u 3 file include
+do
+    level=$( echo ${file} | cut -d/ -f 2,3 )
+    # If the "level" indicates a file, cut off the filename
+    if [[ "${level##*.}" != "${level}" ]]
+    then
+        # Use the "toplevel" label as a workaround for `sort`
+        # inconsistencies between different utility versions
+        level="$( dirname ${level} )/toplevel"
+    fi
+    level=$( echo ${level} | tr '/' '.' )
+
+    includelevel=$( echo ${include} | sed 's/.*["<]//; s/[">].*//' | \
+        cut -d/ -f 1,2 )
+    if [[ "${includelevel##*.}" != "${includelevel}" ]]
+    then
+        # Use the "toplevel" label as a workaround for `sort`
+        # inconsistencies between different utility versions
+        includelevel="$( dirname ${includelevel} )/toplevel"
+    fi
+    includelevel=$( echo ${includelevel} | tr '/' '.' )
+
+    if [[ "$level" != "$includelevel" ]]
+    then
+        echo $level $includelevel | tee -a paths.txt
+    fi
+done
+echo Sort and deduplicate paths
+sort -ds paths.txt | uniq -c | tee sortedpaths.txt
+mv sortedpaths.txt paths.txt
+exec 3>&- #close fd 3
+IFS=${oldifs}
+unset oldifs
+
+echo Split into flat-file database
+exec 4<paths.txt # open paths.txt for input
+while read -r -u 4 count level include
+do
+    echo ${include} ${count} | tee -a includes/${level}
+    echo ${level} ${count} | tee -a included_by/${include}
+done
+exec 4>&- #close fd 4
+
+loops="$( pwd )/loops.txt"
+ordering="$( pwd )/ordering.txt"
+pushd includes
+echo Search for loops
+# Redirect stdout to a file
+exec 4>&1
+exec 1>"${loops}"
+for source in *
+do
+  if [[ -f "$source" ]]
+  then
+    exec 5<"${source}" # open for input
+    while read -r -u 5 include includefreq
+    do
+      if [[ -f $include ]]
+      then
+        if grep -q -w $source $include
+        then
+          if grep -q -w "Loop: $include $source" "${loops}"
+          then
+            continue
+          fi
+          sourcefreq=$( grep -w $source $include | cut -d\  -f2 )
+          echo "Loop: $source $include"
+          # If the counts are close, indicate that the two modules are
+          # on the same level, though they shouldn't be
+          if [[ $(( $includefreq - $sourcefreq )) -gt 3 ]]
+          then
+              echo -e "  $source > $include\n"
+          elif [[ $(( $sourcefreq - $includefreq )) -gt 3 ]]
+          then
+              echo -e "  $include > $source\n"
+          elif [[ $sourcefreq -eq $includefreq ]]
+          then
+              echo -e "  $include == $source\n"
+          else
+              echo -e "  $include ~= $source\n"
+          fi
+        else
+          echo "$source > $include" >> "${ordering}"
+        fi
+      fi
+    done
+    exec 5>&- #close fd 5
+  fi
+done
+exec 1>&4 #close fd 1
+exec 4>&- #close fd 4
+cat "${ordering}"
+cat "${loops}"
+popd
+popd
+popd

.github/workflows/reusable-check-levelization.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Check levelization
-        run: python .github/scripts/levelization/generate.py
+        run: .github/scripts/levelization/generate.sh
       - name: Check for differences
         env:
           MESSAGE: |
@@ -32,7 +32,7 @@ jobs:
             removed from loops.txt, it's probably an improvement, while if
             something was added, it's probably a regression.
 
-            Run '.github/scripts/levelization/generate.py' in your repo, commit
+            Run '.github/scripts/levelization/generate.sh' in your repo, commit
             and push the changes. See .github/scripts/levelization/README.md for
             more info.
         run: |

.gitignore

@@ -75,9 +75,6 @@ DerivedData
 /.claude
 /CLAUDE.md
 
-# Python
-__pycache__
-
 # Direnv's directory
 /.direnv
 

cspell.config.yaml

@@ -111,6 +111,7 @@ words:
   - gpgcheck
   - gpgkey
   - hotwallet
+  - hwaddress
   - hwrap
   - ifndef
   - inequation

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

include/xrpl/basics/contract.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/basics/sanitizers.h>
 #include <xrpl/beast/type_name.h>
 
 #include <exception>
@@ -24,7 +25,7 @@ LogThrow(std::string const& title);
     control to the next matching exception handler, if any.
     Otherwise, std::terminate will be called.
 */
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Rethrow()
 {
     LogThrow("Re-throwing exception");
@@ -32,7 +33,7 @@ Rethrow()
 }
 
 template <class E, class... Args>
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Throw(Args&&... args)
 {
     static_assert(

include/xrpl/basics/sanitizers.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Helper to disable ASan/HwASan for specific functions
+#if defined(__GNUC__) || defined(__clang__)
+#define XRPL_NO_SANITIZE_ADDRESS __attribute__((no_sanitize("address", "hwaddress")))
+#else
+#define XRPL_NO_SANITIZE_ADDRESS
+#endif

include/xrpl/core/HashRouter.h

@@ -139,13 +139,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
@@ -177,20 +170,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_;
@@ -198,7 +177,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:
@@ -221,7 +199,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>>
@@ -238,15 +216,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.
@@ -272,11 +241,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>

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 {

include/xrpl/protocol/LedgerHeader.h

@@ -35,8 +35,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;

include/xrpl/protocol/detail/transactions.macro

@@ -42,7 +42,7 @@ TRANSACTION(ttPAYMENT, 0, Payment,
 
 /** This transaction type creates an escrow object. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/escrow/EscrowCreate.h>
+#   include <xrpl/tx/transactors/escrow/Escrow.h>
 #endif
 TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
     Delegation::delegable,
@@ -58,9 +58,6 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
 }))
 
 /** This transaction type completes an existing escrow. */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/escrow/EscrowFinish.h>
-#endif
 TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
     Delegation::delegable,
     uint256{},
@@ -97,7 +94,7 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
 
 /** This transaction type cancels an existing escrow. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/escrow/EscrowCancel.h>
+#   include <xrpl/tx/transactors/escrow/Escrow.h>
 #endif
 TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
     Delegation::delegable,
@@ -183,7 +180,7 @@ TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
 
 /** This transaction type creates a new unidirectional XRP payment channel. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment_channel/PayChanCreate.h>
+#   include <xrpl/tx/transactors/payment_channel/PayChan.h>
 #endif
 TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
     Delegation::delegable,
@@ -199,9 +196,6 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
 }))
 
 /** This transaction type funds an existing unidirectional XRP payment channel. */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment_channel/PayChanFund.h>
-#endif
 TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
     Delegation::delegable,
     uint256{},
@@ -213,9 +207,6 @@ TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
 }))
 
 /** This transaction type submits a claim against an existing unidirectional payment channel. */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment_channel/PayChanClaim.h>
-#endif
 TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
     Delegation::delegable,
     uint256{},
@@ -626,7 +617,7 @@ TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
 
 /** This transaction type creates or updates a DID */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/did/DIDSet.h>
+#   include <xrpl/tx/transactors/did/DID.h>
 #endif
 TRANSACTION(ttDID_SET, 49, DIDSet,
     Delegation::delegable,
@@ -639,9 +630,6 @@ TRANSACTION(ttDID_SET, 49, DIDSet,
 }))
 
 /** This transaction type deletes a DID */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/did/DIDDelete.h>
-#endif
 TRANSACTION(ttDID_DELETE, 50, DIDDelete,
     Delegation::delegable,
     featureDID,
@@ -751,7 +739,7 @@ TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
 
 /** This transaction type create an Credential instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/credentials/CredentialCreate.h>
+#   include <xrpl/tx/transactors/credentials/Credentials.h>
 #endif
 TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
     Delegation::delegable,
@@ -765,9 +753,6 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
 }))
 
 /** This transaction type accept an Credential object */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/credentials/CredentialAccept.h>
-#endif
 TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
     Delegation::delegable,
     featureCredentials,
@@ -778,9 +763,6 @@ TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
 }))
 
 /** This transaction type delete an Credential object */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/credentials/CredentialDelete.h>
-#endif
 TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
     Delegation::delegable,
     featureCredentials,

include/xrpl/server/NetworkOPs.h

@@ -185,7 +185,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

include/xrpl/tx/transactors/credentials/CredentialAccept.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class CredentialAccept : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit CredentialAccept(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/credentials/CredentialCreate.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class CredentialCreate : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit CredentialCreate(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/credentials/CredentialDelete.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class CredentialDelete : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit CredentialDelete(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/credentials/Credentials.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class CredentialCreate : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit CredentialCreate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+//------------------------------------------------------------------------------
+
+class CredentialDelete : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit CredentialDelete(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+//------------------------------------------------------------------------------
+
+class CredentialAccept : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit CredentialAccept(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl

include/xrpl/tx/transactors/did/DID.h

@@ -4,6 +4,24 @@
 
 namespace xrpl {
 
+class DIDSet : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit DIDSet(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+//------------------------------------------------------------------------------
+
 class DIDDelete : public Transactor
 {
 public:

include/xrpl/tx/transactors/did/DIDSet.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class DIDSet : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit DIDSet(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/escrow/Escrow.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class EscrowCreate : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
+
+    explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+//------------------------------------------------------------------------------
+
+class EscrowFinish : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit EscrowFinish(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static bool
+    checkExtraFeatures(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static NotTEC
+    preflightSigValidated(PreflightContext const& ctx);
+
+    static XRPAmount
+    calculateBaseFee(ReadView const& view, STTx const& tx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+//------------------------------------------------------------------------------
+
+class EscrowCancel : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit EscrowCancel(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl

include/xrpl/tx/transactors/escrow/EscrowCancel.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class EscrowCancel : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit EscrowCancel(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/escrow/EscrowCreate.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class EscrowCreate : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
-
-    explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static TxConsequences
-    makeTxConsequences(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/escrow/EscrowFinish.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class EscrowFinish : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit EscrowFinish(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static bool
-    checkExtraFeatures(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static NotTEC
-    preflightSigValidated(PreflightContext const& ctx);
-
-    static XRPAmount
-    calculateBaseFee(ReadView const& view, STTx const& tx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/payment_channel/PayChan.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class PayChanCreate : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
+
+    explicit PayChanCreate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+using PaymentChannelCreate = PayChanCreate;
+
+//------------------------------------------------------------------------------
+
+class PayChanFund : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
+
+    explicit PayChanFund(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+using PaymentChannelFund = PayChanFund;
+
+//------------------------------------------------------------------------------
+
+class PayChanClaim : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit PayChanClaim(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static bool
+    checkExtraFeatures(PreflightContext const& ctx);
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+using PaymentChannelClaim = PayChanClaim;
+
+}  // namespace xrpl

include/xrpl/tx/transactors/payment_channel/PayChanClaim.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class PayChanClaim : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit PayChanClaim(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static bool
-    checkExtraFeatures(PreflightContext const& ctx);
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-using PaymentChannelClaim = PayChanClaim;
-
-}  // namespace xrpl

include/xrpl/tx/transactors/payment_channel/PayChanCreate.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class PayChanCreate : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
-
-    explicit PayChanCreate(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static TxConsequences
-    makeTxConsequences(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-using PaymentChannelCreate = PayChanCreate;
-
-}  // namespace xrpl

include/xrpl/tx/transactors/payment_channel/PayChanFund.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class PayChanFund : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
-
-    explicit PayChanFund(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static TxConsequences
-    makeTxConsequences(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-using PaymentChannelFund = PayChanFund;
-
-}  // namespace xrpl

src/libxrpl/basics/Number.cpp

@@ -258,7 +258,7 @@ Number::Guard::doRoundUp(
     }
     bringIntoRange(negative, mantissa, exponent, minMantissa);
     if (exponent > maxExponent)
-        throw std::overflow_error(location);
+        Throw<std::overflow_error>(std::string(location));
 }
 
 template <UnsignedMantissa T>
@@ -298,7 +298,7 @@ Number::Guard::doRound(rep& drops, std::string location)
             // or "(maxRep + 1) / 10", neither of which will round up when
             // converting to rep, though the latter might overflow _before_
             // rounding.
-            throw std::overflow_error(location);  // LCOV_EXCL_LINE
+            Throw<std::overflow_error>(std::string(location));  // LCOV_EXCL_LINE
         }
         ++drops;
     }

src/libxrpl/core/HashRouter.cpp

@@ -70,19 +70,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)
 {
@@ -120,13 +107,4 @@ HashRouter::shouldRelay(uint256 const& key) -> std::optional<std::set<PeerShortI
     return s.releasePeerSet();
 }
 
-auto
-HashRouter::getPeers(uint256 const& key) -> std::set<PeerShortID>
-{
-    std::lock_guard lock(mutex_);
-
-    auto& s = emplace(key).first;
-    return s.peekPeerSet();
-}
-
 }  // namespace xrpl

src/libxrpl/tx/transactors/account/DeleteAccount.cpp

@@ -10,7 +10,7 @@
 #include <xrpl/tx/transactors/account/DeleteAccount.h>
 #include <xrpl/tx/transactors/account/SetSignerList.h>
 #include <xrpl/tx/transactors/delegate/DelegateSet.h>
-#include <xrpl/tx/transactors/did/DIDDelete.h>
+#include <xrpl/tx/transactors/did/DID.h>
 #include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 #include <xrpl/tx/transactors/oracle/DeleteOracle.h>
 #include <xrpl/tx/transactors/payment/DepositPreauth.h>

src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp

@@ -1,113 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/credentials/CredentialAccept.h>
-
-#include <chrono>
-
-namespace xrpl {
-
-using namespace credentials;
-
-std::uint32_t
-CredentialAccept::getFlagsMask(PreflightContext const& ctx)
-{
-    // 0 means "Allow any flags"
-    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
-}
-
-NotTEC
-CredentialAccept::preflight(PreflightContext const& ctx)
-{
-    if (!ctx.tx[sfIssuer])
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: Issuer field zeroed.";
-        return temINVALID_ACCOUNT_ID;
-    }
-
-    auto const credType = ctx.tx[sfCredentialType];
-    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
-        return temMALFORMED;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialAccept::preclaim(PreclaimContext const& ctx)
-{
-    AccountID const subject = ctx.tx[sfAccount];
-    AccountID const issuer = ctx.tx[sfIssuer];
-    auto const credType(ctx.tx[sfCredentialType]);
-
-    if (!ctx.view.exists(keylet::account(issuer)))
-    {
-        JLOG(ctx.j.warn()) << "No issuer: " << to_string(issuer);
-        return tecNO_ISSUER;
-    }
-
-    auto const sleCred = ctx.view.read(keylet::credential(subject, issuer, credType));
-    if (!sleCred)
-    {
-        JLOG(ctx.j.warn()) << "No credential: " << to_string(subject) << ", " << to_string(issuer)
-                           << ", " << credType;
-        return tecNO_ENTRY;
-    }
-
-    if (sleCred->getFieldU32(sfFlags) & lsfAccepted)
-    {
-        JLOG(ctx.j.warn()) << "Credential already accepted: " << to_string(subject) << ", "
-                           << to_string(issuer) << ", " << credType;
-        return tecDUPLICATE;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialAccept::doApply()
-{
-    AccountID const issuer{ctx_.tx[sfIssuer]};
-
-    // Both exist as credential object exist itself (checked in preclaim)
-    auto const sleSubject = view().peek(keylet::account(account_));
-    auto const sleIssuer = view().peek(keylet::account(issuer));
-
-    if (!sleSubject || !sleIssuer)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    {
-        STAmount const reserve{
-            view().fees().accountReserve(sleSubject->getFieldU32(sfOwnerCount) + 1)};
-        if (mPriorBalance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-    }
-
-    auto const credType(ctx_.tx[sfCredentialType]);
-    Keylet const credentialKey = keylet::credential(account_, issuer, credType);
-    auto const sleCred = view().peek(credentialKey);  // Checked in preclaim()
-
-    if (checkExpired(sleCred, view().header().parentCloseTime))
-    {
-        JLOG(j_.trace()) << "Credential is expired: " << sleCred->getText();
-        // delete expired credentials even if the transaction failed
-        auto const err = credentials::deleteSLE(view(), sleCred, j_);
-        return isTesSuccess(err) ? tecEXPIRED : err;
-    }
-
-    sleCred->setFieldU32(sfFlags, lsfAccepted);
-    view().update(sleCred);
-
-    adjustOwnerCount(view(), sleIssuer, -1, j_);
-    adjustOwnerCount(view(), sleSubject, 1, j_);
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp

@@ -1,164 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/credentials/CredentialCreate.h>
-
-#include <chrono>
-
-namespace xrpl {
-
-/*
-    Credentials
-    ======
-
-   A verifiable credentials (VC
-   https://en.wikipedia.org/wiki/Verifiable_credentials), as defined by the W3C
-   specification (https://www.w3.org/TR/vc-data-model-2.0/), is a
-   secure and tamper-evident way to represent information about a subject, such
-   as an individual, organization, or even an IoT device. These credentials are
-   issued by a trusted entity and can be verified by third parties without
-   directly involving the issuer at all.
-*/
-
-using namespace credentials;
-
-std::uint32_t
-CredentialCreate::getFlagsMask(PreflightContext const& ctx)
-{
-    // 0 means "Allow any flags"
-    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
-}
-
-NotTEC
-CredentialCreate::preflight(PreflightContext const& ctx)
-{
-    auto const& tx = ctx.tx;
-    auto& j = ctx.j;
-
-    if (!tx[sfSubject])
-    {
-        JLOG(j.trace()) << "Malformed transaction: Invalid Subject";
-        return temMALFORMED;
-    }
-
-    auto const uri = tx[~sfURI];
-    if (uri && (uri->empty() || (uri->size() > maxCredentialURILength)))
-    {
-        JLOG(j.trace()) << "Malformed transaction: invalid size of URI.";
-        return temMALFORMED;
-    }
-
-    auto const credType = tx[sfCredentialType];
-    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
-    {
-        JLOG(j.trace()) << "Malformed transaction: invalid size of CredentialType.";
-        return temMALFORMED;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialCreate::preclaim(PreclaimContext const& ctx)
-{
-    auto const credType(ctx.tx[sfCredentialType]);
-    auto const subject = ctx.tx[sfSubject];
-
-    if (!ctx.view.exists(keylet::account(subject)))
-    {
-        JLOG(ctx.j.trace()) << "Subject doesn't exist.";
-        return tecNO_TARGET;
-    }
-
-    if (ctx.view.exists(keylet::credential(subject, ctx.tx[sfAccount], credType)))
-    {
-        JLOG(ctx.j.trace()) << "Credential already exists.";
-        return tecDUPLICATE;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialCreate::doApply()
-{
-    auto const subject = ctx_.tx[sfSubject];
-    auto const credType(ctx_.tx[sfCredentialType]);
-    Keylet const credentialKey = keylet::credential(subject, account_, credType);
-
-    auto const sleCred = std::make_shared<SLE>(credentialKey);
-    if (!sleCred)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    auto const optExp = ctx_.tx[~sfExpiration];
-    if (optExp)
-    {
-        std::uint32_t const closeTime =
-            ctx_.view().header().parentCloseTime.time_since_epoch().count();
-
-        if (closeTime > *optExp)
-        {
-            JLOG(j_.trace()) << "Malformed transaction: "
-                                "Expiration time is in the past.";
-            return tecEXPIRED;
-        }
-
-        sleCred->setFieldU32(sfExpiration, ctx_.tx.getFieldU32(sfExpiration));
-    }
-
-    auto const sleIssuer = view().peek(keylet::account(account_));
-    if (!sleIssuer)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    {
-        STAmount const reserve{
-            view().fees().accountReserve(sleIssuer->getFieldU32(sfOwnerCount) + 1)};
-        if (mPriorBalance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-    }
-
-    sleCred->setAccountID(sfSubject, subject);
-    sleCred->setAccountID(sfIssuer, account_);
-    sleCred->setFieldVL(sfCredentialType, credType);
-
-    if (ctx_.tx.isFieldPresent(sfURI))
-        sleCred->setFieldVL(sfURI, ctx_.tx.getFieldVL(sfURI));
-
-    {
-        auto const page =
-            view().dirInsert(keylet::ownerDir(account_), credentialKey, describeOwnerDir(account_));
-        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
-                         << ": " << (page ? "success" : "failure");
-        if (!page)
-            return tecDIR_FULL;
-        sleCred->setFieldU64(sfIssuerNode, *page);
-
-        adjustOwnerCount(view(), sleIssuer, 1, j_);
-    }
-
-    if (subject == account_)
-    {
-        sleCred->setFieldU32(sfFlags, lsfAccepted);
-    }
-    else
-    {
-        auto const page =
-            view().dirInsert(keylet::ownerDir(subject), credentialKey, describeOwnerDir(subject));
-        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
-                         << ": " << (page ? "success" : "failure");
-        if (!page)
-            return tecDIR_FULL;
-        sleCred->setFieldU64(sfSubjectNode, *page);
-        view().update(view().peek(keylet::account(subject)));
-    }
-
-    view().insert(sleCred);
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp

@@ -1,90 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/credentials/CredentialDelete.h>
-
-#include <chrono>
-
-namespace xrpl {
-
-using namespace credentials;
-
-std::uint32_t
-CredentialDelete::getFlagsMask(PreflightContext const& ctx)
-{
-    // 0 means "Allow any flags"
-    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
-}
-
-NotTEC
-CredentialDelete::preflight(PreflightContext const& ctx)
-{
-    auto const subject = ctx.tx[~sfSubject];
-    auto const issuer = ctx.tx[~sfIssuer];
-
-    if (!subject && !issuer)
-    {
-        // Neither field is present, the transaction is malformed.
-        JLOG(ctx.j.trace()) << "Malformed transaction: "
-                               "No Subject or Issuer fields.";
-        return temMALFORMED;
-    }
-
-    // Make sure that the passed account is valid.
-    if ((subject && subject->isZero()) || (issuer && issuer->isZero()))
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: Subject or Issuer "
-                               "field zeroed.";
-        return temINVALID_ACCOUNT_ID;
-    }
-
-    auto const credType = ctx.tx[sfCredentialType];
-    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
-        return temMALFORMED;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialDelete::preclaim(PreclaimContext const& ctx)
-{
-    AccountID const account{ctx.tx[sfAccount]};
-    auto const subject = ctx.tx[~sfSubject].value_or(account);
-    auto const issuer = ctx.tx[~sfIssuer].value_or(account);
-    auto const credType(ctx.tx[sfCredentialType]);
-
-    if (!ctx.view.exists(keylet::credential(subject, issuer, credType)))
-        return tecNO_ENTRY;
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialDelete::doApply()
-{
-    auto const subject = ctx_.tx[~sfSubject].value_or(account_);
-    auto const issuer = ctx_.tx[~sfIssuer].value_or(account_);
-
-    auto const credType(ctx_.tx[sfCredentialType]);
-    auto const sleCred = view().peek(keylet::credential(subject, issuer, credType));
-    if (!sleCred)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    if ((subject != account_) && (issuer != account_) &&
-        !checkExpired(sleCred, ctx_.view().header().parentCloseTime))
-    {
-        JLOG(j_.trace()) << "Can't delete non-expired credential.";
-        return tecNO_PERMISSION;
-    }
-
-    return deleteSLE(view(), sleCred, j_);
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/credentials/Credentials.cpp

@@ -0,0 +1,341 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/tx/transactors/credentials/Credentials.h>
+
+#include <chrono>
+
+namespace xrpl {
+
+/*
+    Credentials
+    ======
+
+   A verifiable credentials (VC
+   https://en.wikipedia.org/wiki/Verifiable_credentials), as defined by the W3C
+   specification (https://www.w3.org/TR/vc-data-model-2.0/), is a
+   secure and tamper-evident way to represent information about a subject, such
+   as an individual, organization, or even an IoT device. These credentials are
+   issued by a trusted entity and can be verified by third parties without
+   directly involving the issuer at all.
+*/
+
+using namespace credentials;
+
+// ------- CREATE --------------------------
+
+std::uint32_t
+CredentialCreate::getFlagsMask(PreflightContext const& ctx)
+{
+    // 0 means "Allow any flags"
+    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
+}
+
+NotTEC
+CredentialCreate::preflight(PreflightContext const& ctx)
+{
+    auto const& tx = ctx.tx;
+    auto& j = ctx.j;
+
+    if (!tx[sfSubject])
+    {
+        JLOG(j.trace()) << "Malformed transaction: Invalid Subject";
+        return temMALFORMED;
+    }
+
+    auto const uri = tx[~sfURI];
+    if (uri && (uri->empty() || (uri->size() > maxCredentialURILength)))
+    {
+        JLOG(j.trace()) << "Malformed transaction: invalid size of URI.";
+        return temMALFORMED;
+    }
+
+    auto const credType = tx[sfCredentialType];
+    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
+    {
+        JLOG(j.trace()) << "Malformed transaction: invalid size of CredentialType.";
+        return temMALFORMED;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialCreate::preclaim(PreclaimContext const& ctx)
+{
+    auto const credType(ctx.tx[sfCredentialType]);
+    auto const subject = ctx.tx[sfSubject];
+
+    if (!ctx.view.exists(keylet::account(subject)))
+    {
+        JLOG(ctx.j.trace()) << "Subject doesn't exist.";
+        return tecNO_TARGET;
+    }
+
+    if (ctx.view.exists(keylet::credential(subject, ctx.tx[sfAccount], credType)))
+    {
+        JLOG(ctx.j.trace()) << "Credential already exists.";
+        return tecDUPLICATE;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialCreate::doApply()
+{
+    auto const subject = ctx_.tx[sfSubject];
+    auto const credType(ctx_.tx[sfCredentialType]);
+    Keylet const credentialKey = keylet::credential(subject, account_, credType);
+
+    auto const sleCred = std::make_shared<SLE>(credentialKey);
+    if (!sleCred)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    auto const optExp = ctx_.tx[~sfExpiration];
+    if (optExp)
+    {
+        std::uint32_t const closeTime =
+            ctx_.view().header().parentCloseTime.time_since_epoch().count();
+
+        if (closeTime > *optExp)
+        {
+            JLOG(j_.trace()) << "Malformed transaction: "
+                                "Expiration time is in the past.";
+            return tecEXPIRED;
+        }
+
+        sleCred->setFieldU32(sfExpiration, ctx_.tx.getFieldU32(sfExpiration));
+    }
+
+    auto const sleIssuer = view().peek(keylet::account(account_));
+    if (!sleIssuer)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    {
+        STAmount const reserve{
+            view().fees().accountReserve(sleIssuer->getFieldU32(sfOwnerCount) + 1)};
+        if (mPriorBalance < reserve)
+            return tecINSUFFICIENT_RESERVE;
+    }
+
+    sleCred->setAccountID(sfSubject, subject);
+    sleCred->setAccountID(sfIssuer, account_);
+    sleCred->setFieldVL(sfCredentialType, credType);
+
+    if (ctx_.tx.isFieldPresent(sfURI))
+        sleCred->setFieldVL(sfURI, ctx_.tx.getFieldVL(sfURI));
+
+    {
+        auto const page =
+            view().dirInsert(keylet::ownerDir(account_), credentialKey, describeOwnerDir(account_));
+        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
+                         << ": " << (page ? "success" : "failure");
+        if (!page)
+            return tecDIR_FULL;
+        sleCred->setFieldU64(sfIssuerNode, *page);
+
+        adjustOwnerCount(view(), sleIssuer, 1, j_);
+    }
+
+    if (subject == account_)
+    {
+        sleCred->setFieldU32(sfFlags, lsfAccepted);
+    }
+    else
+    {
+        auto const page =
+            view().dirInsert(keylet::ownerDir(subject), credentialKey, describeOwnerDir(subject));
+        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
+                         << ": " << (page ? "success" : "failure");
+        if (!page)
+            return tecDIR_FULL;
+        sleCred->setFieldU64(sfSubjectNode, *page);
+        view().update(view().peek(keylet::account(subject)));
+    }
+
+    view().insert(sleCred);
+
+    return tesSUCCESS;
+}
+
+// ------- DELETE --------------------------
+
+std::uint32_t
+CredentialDelete::getFlagsMask(PreflightContext const& ctx)
+{
+    // 0 means "Allow any flags"
+    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
+}
+
+NotTEC
+CredentialDelete::preflight(PreflightContext const& ctx)
+{
+    auto const subject = ctx.tx[~sfSubject];
+    auto const issuer = ctx.tx[~sfIssuer];
+
+    if (!subject && !issuer)
+    {
+        // Neither field is present, the transaction is malformed.
+        JLOG(ctx.j.trace()) << "Malformed transaction: "
+                               "No Subject or Issuer fields.";
+        return temMALFORMED;
+    }
+
+    // Make sure that the passed account is valid.
+    if ((subject && subject->isZero()) || (issuer && issuer->isZero()))
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: Subject or Issuer "
+                               "field zeroed.";
+        return temINVALID_ACCOUNT_ID;
+    }
+
+    auto const credType = ctx.tx[sfCredentialType];
+    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
+        return temMALFORMED;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialDelete::preclaim(PreclaimContext const& ctx)
+{
+    AccountID const account{ctx.tx[sfAccount]};
+    auto const subject = ctx.tx[~sfSubject].value_or(account);
+    auto const issuer = ctx.tx[~sfIssuer].value_or(account);
+    auto const credType(ctx.tx[sfCredentialType]);
+
+    if (!ctx.view.exists(keylet::credential(subject, issuer, credType)))
+        return tecNO_ENTRY;
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialDelete::doApply()
+{
+    auto const subject = ctx_.tx[~sfSubject].value_or(account_);
+    auto const issuer = ctx_.tx[~sfIssuer].value_or(account_);
+
+    auto const credType(ctx_.tx[sfCredentialType]);
+    auto const sleCred = view().peek(keylet::credential(subject, issuer, credType));
+    if (!sleCred)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    if ((subject != account_) && (issuer != account_) &&
+        !checkExpired(sleCred, ctx_.view().header().parentCloseTime))
+    {
+        JLOG(j_.trace()) << "Can't delete non-expired credential.";
+        return tecNO_PERMISSION;
+    }
+
+    return deleteSLE(view(), sleCred, j_);
+}
+
+// ------- APPLY --------------------------
+
+std::uint32_t
+CredentialAccept::getFlagsMask(PreflightContext const& ctx)
+{
+    // 0 means "Allow any flags"
+    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
+}
+
+NotTEC
+CredentialAccept::preflight(PreflightContext const& ctx)
+{
+    if (!ctx.tx[sfIssuer])
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: Issuer field zeroed.";
+        return temINVALID_ACCOUNT_ID;
+    }
+
+    auto const credType = ctx.tx[sfCredentialType];
+    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
+        return temMALFORMED;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialAccept::preclaim(PreclaimContext const& ctx)
+{
+    AccountID const subject = ctx.tx[sfAccount];
+    AccountID const issuer = ctx.tx[sfIssuer];
+    auto const credType(ctx.tx[sfCredentialType]);
+
+    if (!ctx.view.exists(keylet::account(issuer)))
+    {
+        JLOG(ctx.j.warn()) << "No issuer: " << to_string(issuer);
+        return tecNO_ISSUER;
+    }
+
+    auto const sleCred = ctx.view.read(keylet::credential(subject, issuer, credType));
+    if (!sleCred)
+    {
+        JLOG(ctx.j.warn()) << "No credential: " << to_string(subject) << ", " << to_string(issuer)
+                           << ", " << credType;
+        return tecNO_ENTRY;
+    }
+
+    if (sleCred->getFieldU32(sfFlags) & lsfAccepted)
+    {
+        JLOG(ctx.j.warn()) << "Credential already accepted: " << to_string(subject) << ", "
+                           << to_string(issuer) << ", " << credType;
+        return tecDUPLICATE;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialAccept::doApply()
+{
+    AccountID const issuer{ctx_.tx[sfIssuer]};
+
+    // Both exist as credential object exist itself (checked in preclaim)
+    auto const sleSubject = view().peek(keylet::account(account_));
+    auto const sleIssuer = view().peek(keylet::account(issuer));
+
+    if (!sleSubject || !sleIssuer)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    {
+        STAmount const reserve{
+            view().fees().accountReserve(sleSubject->getFieldU32(sfOwnerCount) + 1)};
+        if (mPriorBalance < reserve)
+            return tecINSUFFICIENT_RESERVE;
+    }
+
+    auto const credType(ctx_.tx[sfCredentialType]);
+    Keylet const credentialKey = keylet::credential(account_, issuer, credType);
+    auto const sleCred = view().peek(credentialKey);  // Checked in preclaim()
+
+    if (checkExpired(sleCred, view().header().parentCloseTime))
+    {
+        JLOG(j_.trace()) << "Credential is expired: " << sleCred->getText();
+        // delete expired credentials even if the transaction failed
+        auto const err = credentials::deleteSLE(view(), sleCred, j_);
+        return isTesSuccess(err) ? tecEXPIRED : err;
+    }
+
+    sleCred->setFieldU32(sfFlags, lsfAccepted);
+    view().update(sleCred);
+
+    adjustOwnerCount(view(), sleIssuer, -1, j_);
+    adjustOwnerCount(view(), sleSubject, 1, j_);
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl

src/libxrpl/tx/transactors/did/DID.cpp

@@ -4,7 +4,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/did/DIDSet.h>
+#include <xrpl/tx/transactors/did/DID.h>
 
 namespace xrpl {
 
@@ -134,4 +134,54 @@ DIDSet::doApply()
     return addSLE(ctx_, sleDID, account_);
 }
 
+NotTEC
+DIDDelete::preflight(PreflightContext const& ctx)
+{
+    return tesSUCCESS;
+}
+
+TER
+DIDDelete::deleteSLE(ApplyContext& ctx, Keylet sleKeylet, AccountID const owner)
+{
+    auto const sle = ctx.view().peek(sleKeylet);
+    if (!sle)
+        return tecNO_ENTRY;
+
+    return DIDDelete::deleteSLE(ctx.view(), sle, owner, ctx.journal);
+}
+
+TER
+DIDDelete::deleteSLE(
+    ApplyView& view,
+    std::shared_ptr<SLE> sle,
+    AccountID const owner,
+    beast::Journal j)
+{
+    // Remove object from owner directory
+    if (!view.dirRemove(keylet::ownerDir(owner), (*sle)[sfOwnerNode], sle->key(), true))
+    {
+        // LCOV_EXCL_START
+        JLOG(j.fatal()) << "Unable to delete DID Token from owner.";
+        return tefBAD_LEDGER;
+        // LCOV_EXCL_STOP
+    }
+
+    auto const sleOwner = view.peek(keylet::account(owner));
+    if (!sleOwner)
+        return tecINTERNAL;  // LCOV_EXCL_LINE
+
+    adjustOwnerCount(view, sleOwner, -1, j);
+    view.update(sleOwner);
+
+    // Remove object from ledger
+    view.erase(sle);
+    return tesSUCCESS;
+}
+
+TER
+DIDDelete::doApply()
+{
+    return deleteSLE(ctx_, keylet::did(account_), account_);
+}
+
 }  // namespace xrpl

src/libxrpl/tx/transactors/did/DIDDelete.cpp

@@ -1,59 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/tx/transactors/did/DIDDelete.h>
-
-namespace xrpl {
-
-NotTEC
-DIDDelete::preflight(PreflightContext const& ctx)
-{
-    return tesSUCCESS;
-}
-
-TER
-DIDDelete::deleteSLE(ApplyContext& ctx, Keylet sleKeylet, AccountID const owner)
-{
-    auto const sle = ctx.view().peek(sleKeylet);
-    if (!sle)
-        return tecNO_ENTRY;
-
-    return DIDDelete::deleteSLE(ctx.view(), sle, owner, ctx.journal);
-}
-
-TER
-DIDDelete::deleteSLE(
-    ApplyView& view,
-    std::shared_ptr<SLE> sle,
-    AccountID const owner,
-    beast::Journal j)
-{
-    // Remove object from owner directory
-    if (!view.dirRemove(keylet::ownerDir(owner), (*sle)[sfOwnerNode], sle->key(), true))
-    {
-        // LCOV_EXCL_START
-        JLOG(j.fatal()) << "Unable to delete DID Token from owner.";
-        return tefBAD_LEDGER;
-        // LCOV_EXCL_STOP
-    }
-
-    auto const sleOwner = view.peek(keylet::account(owner));
-    if (!sleOwner)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    adjustOwnerCount(view, sleOwner, -1, j);
-    view.update(sleOwner);
-
-    // Remove object from ledger
-    view.erase(sle);
-    return tesSUCCESS;
-}
-
-TER
-DIDDelete::doApply()
-{
-    return deleteSLE(ctx_, keylet::did(account_), account_);
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp

@@ -1,201 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/tx/transactors/escrow/EscrowCancel.h>
-
-#include <libxrpl/tx/transactors/escrow/EscrowHelpers.h>
-
-namespace xrpl {
-
-NotTEC
-EscrowCancel::preflight(PreflightContext const& ctx)
-{
-    return tesSUCCESS;
-}
-
-template <ValidIssueType T>
-static TER
-escrowCancelPreclaimHelper(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    STAmount const& amount);
-
-template <>
-TER
-escrowCancelPreclaimHelper<Issue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecINTERNAL
-    if (issuer == account)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    // If the issuer has requireAuth set, check if the account is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), account); ter != tesSUCCESS)
-        return ter;
-
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowCancelPreclaimHelper<MPTIssue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecINTERNAL
-    if (issuer == account)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
-    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
-    auto const sleIssuance = ctx.view.read(issuanceKey);
-    if (!sleIssuance)
-        return tecOBJECT_NOT_FOUND;
-
-    // If the issuer has requireAuth set, check if the account is
-    // authorized
-    auto const& mptIssue = amount.get<MPTIssue>();
-    if (auto const ter = requireAuth(ctx.view, mptIssue, account, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    return tesSUCCESS;
-}
-
-TER
-EscrowCancel::preclaim(PreclaimContext const& ctx)
-{
-    if (ctx.view.rules().enabled(featureTokenEscrow))
-    {
-        auto const k = keylet::escrow(ctx.tx[sfOwner], ctx.tx[sfOfferSequence]);
-        auto const slep = ctx.view.read(k);
-        if (!slep)
-            return tecNO_TARGET;
-
-        AccountID const account = (*slep)[sfAccount];
-        STAmount const amount = (*slep)[sfAmount];
-
-        if (!isXRP(amount))
-        {
-            if (auto const ret = std::visit(
-                    [&]<typename T>(T const&) {
-                        return escrowCancelPreclaimHelper<T>(ctx, account, amount);
-                    },
-                    amount.asset().value());
-                !isTesSuccess(ret))
-                return ret;
-        }
-    }
-    return tesSUCCESS;
-}
-
-TER
-EscrowCancel::doApply()
-{
-    auto const k = keylet::escrow(ctx_.tx[sfOwner], ctx_.tx[sfOfferSequence]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-    {
-        if (ctx_.view().rules().enabled(featureTokenEscrow))
-            return tecINTERNAL;  // LCOV_EXCL_LINE
-
-        return tecNO_TARGET;
-    }
-
-    auto const now = ctx_.view().header().parentCloseTime;
-
-    // No cancel time specified: can't execute at all.
-    if (!(*slep)[~sfCancelAfter])
-        return tecNO_PERMISSION;
-
-    // Too soon: can't execute before the cancel time.
-    if (!after(now, (*slep)[sfCancelAfter]))
-        return tecNO_PERMISSION;
-
-    AccountID const account = (*slep)[sfAccount];
-
-    // Remove escrow from owner directory
-    {
-        auto const page = (*slep)[sfOwnerNode];
-        if (!ctx_.view().dirRemove(keylet::ownerDir(account), page, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from owner.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Remove escrow from recipient's owner directory, if present.
-    if (auto const optPage = (*slep)[~sfDestinationNode]; optPage)
-    {
-        if (!ctx_.view().dirRemove(keylet::ownerDir((*slep)[sfDestination]), *optPage, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    auto const sle = ctx_.view().peek(keylet::account(account));
-    STAmount const amount = slep->getFieldAmount(sfAmount);
-
-    // Transfer amount back to the owner
-    if (isXRP(amount))
-        (*sle)[sfBalance] = (*sle)[sfBalance] + amount;
-    else
-    {
-        if (!ctx_.view().rules().enabled(featureTokenEscrow))
-            return temDISABLED;  // LCOV_EXCL_LINE
-
-        auto const issuer = amount.getIssuer();
-        bool const createAsset = account == account_;
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowUnlockApplyHelper<T>(
-                        ctx_.view(),
-                        parityRate,
-                        slep,
-                        mPriorBalance,
-                        amount,
-                        issuer,
-                        account,  // sender and receiver are the same
-                        account,
-                        createAsset,
-                        j_);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;  // LCOV_EXCL_LINE
-
-        // Remove escrow from issuers owner directory, if present.
-        if (auto const optPage = (*slep)[~sfIssuerNode]; optPage)
-        {
-            if (!ctx_.view().dirRemove(keylet::ownerDir(issuer), *optPage, k.key, true))
-            {
-                // LCOV_EXCL_START
-                JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-                return tefBAD_LEDGER;
-                // LCOV_EXCL_STOP
-            }
-        }
-    }
-
-    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
-    ctx_.view().update(sle);
-
-    // Remove escrow from ledger
-    ctx_.view().erase(slep);
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp

@@ -1,498 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/conditions/Condition.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/MPTAmount.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/tx/transactors/escrow/EscrowCreate.h>
-
-namespace xrpl {
-
-/*
-    Escrow
-    ======
-
-    Escrow is a feature of the XRP Ledger that allows you to send conditional
-    XRP payments. These conditional payments, called escrows, set aside XRP and
-    deliver it later when certain conditions are met. Conditions to successfully
-    finish an escrow include time-based unlocks and crypto-conditions. Escrows
-    can also be set to expire if not finished in time.
-
-    The XRP set aside in an escrow is locked up. No one can use or destroy the
-    XRP until the escrow has been successfully finished or canceled. Before the
-    expiration time, only the intended receiver can get the XRP. After the
-    expiration time, the XRP can only be returned to the sender.
-
-    For more details on escrow, including examples, diagrams and more please
-    visit https://xrpl.org/escrow.html
-
-    For details on specific transactions, including fields and validation rules
-    please see:
-
-    `EscrowCreate`
-    --------------
-        See: https://xrpl.org/escrowcreate.html
-
-    `EscrowFinish`
-    --------------
-        See: https://xrpl.org/escrowfinish.html
-
-    `EscrowCancel`
-    --------------
-        See: https://xrpl.org/escrowcancel.html
-*/
-
-//------------------------------------------------------------------------------
-
-TxConsequences
-EscrowCreate::makeTxConsequences(PreflightContext const& ctx)
-{
-    auto const amount = ctx.tx[sfAmount];
-    return TxConsequences{ctx.tx, isXRP(amount) ? amount.xrp() : beast::zero};
-}
-
-template <ValidIssueType T>
-static NotTEC
-escrowCreatePreflightHelper(PreflightContext const& ctx);
-
-template <>
-NotTEC
-escrowCreatePreflightHelper<Issue>(PreflightContext const& ctx)
-{
-    STAmount const amount = ctx.tx[sfAmount];
-    if (amount.native() || amount <= beast::zero)
-        return temBAD_AMOUNT;
-
-    if (badCurrency() == amount.getCurrency())
-        return temBAD_CURRENCY;
-
-    return tesSUCCESS;
-}
-
-template <>
-NotTEC
-escrowCreatePreflightHelper<MPTIssue>(PreflightContext const& ctx)
-{
-    if (!ctx.rules.enabled(featureMPTokensV1))
-        return temDISABLED;
-
-    auto const amount = ctx.tx[sfAmount];
-    if (amount.native() || amount.mpt() > MPTAmount{maxMPTokenAmount} || amount <= beast::zero)
-        return temBAD_AMOUNT;
-
-    return tesSUCCESS;
-}
-
-NotTEC
-EscrowCreate::preflight(PreflightContext const& ctx)
-{
-    STAmount const amount{ctx.tx[sfAmount]};
-    if (!isXRP(amount))
-    {
-        if (!ctx.rules.enabled(featureTokenEscrow))
-            return temBAD_AMOUNT;
-
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) { return escrowCreatePreflightHelper<T>(ctx); },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;
-    }
-    else
-    {
-        if (amount <= beast::zero)
-            return temBAD_AMOUNT;
-    }
-
-    // We must specify at least one timeout value
-    if (!ctx.tx[~sfCancelAfter] && !ctx.tx[~sfFinishAfter])
-        return temBAD_EXPIRATION;
-
-    // If both finish and cancel times are specified then the cancel time must
-    // be strictly after the finish time.
-    if (ctx.tx[~sfCancelAfter] && ctx.tx[~sfFinishAfter] &&
-        ctx.tx[sfCancelAfter] <= ctx.tx[sfFinishAfter])
-        return temBAD_EXPIRATION;
-
-    // In the absence of a FinishAfter, the escrow can be finished
-    // immediately, which can be confusing. When creating an escrow,
-    // we want to ensure that either a FinishAfter time is explicitly
-    // specified or a completion condition is attached.
-    if (!ctx.tx[~sfFinishAfter] && !ctx.tx[~sfCondition])
-        return temMALFORMED;
-
-    if (auto const cb = ctx.tx[~sfCondition])
-    {
-        using namespace xrpl::cryptoconditions;
-
-        std::error_code ec;
-
-        auto condition = Condition::deserialize(*cb, ec);
-        if (!condition)
-        {
-            JLOG(ctx.j.debug()) << "Malformed condition during escrow creation: " << ec.message();
-            return temMALFORMED;
-        }
-    }
-
-    return tesSUCCESS;
-}
-
-template <ValidIssueType T>
-static TER
-escrowCreatePreclaimHelper(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    AccountID const& dest,
-    STAmount const& amount);
-
-template <>
-TER
-escrowCreatePreclaimHelper<Issue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecNO_PERMISSION
-    if (issuer == account)
-        return tecNO_PERMISSION;
-
-    // If the lsfAllowTrustLineLocking is not enabled, return tecNO_PERMISSION
-    auto const sleIssuer = ctx.view.read(keylet::account(issuer));
-    if (!sleIssuer)
-        return tecNO_ISSUER;
-    if (!sleIssuer->isFlag(lsfAllowTrustLineLocking))
-        return tecNO_PERMISSION;
-
-    // If the account does not have a trustline to the issuer, return tecNO_LINE
-    auto const sleRippleState = ctx.view.read(keylet::line(account, issuer, amount.getCurrency()));
-    if (!sleRippleState)
-        return tecNO_LINE;
-
-    STAmount const balance = (*sleRippleState)[sfBalance];
-
-    // If balance is positive, issuer must have higher address than account
-    if (balance > beast::zero && issuer < account)
-        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
-
-    // If balance is negative, issuer must have lower address than account
-    if (balance < beast::zero && issuer > account)
-        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
-
-    // If the issuer has requireAuth set, check if the account is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), account); ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has requireAuth set, check if the destination is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), dest); ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has frozen the account, return tecFROZEN
-    if (isFrozen(ctx.view, account, amount.issue()))
-        return tecFROZEN;
-
-    // If the issuer has frozen the destination, return tecFROZEN
-    if (isFrozen(ctx.view, dest, amount.issue()))
-        return tecFROZEN;
-
-    STAmount const spendableAmount =
-        accountHolds(ctx.view, account, amount.getCurrency(), issuer, fhIGNORE_FREEZE, ctx.j);
-
-    // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
-    if (spendableAmount <= beast::zero)
-        return tecINSUFFICIENT_FUNDS;
-
-    // If the spendable amount is less than the amount, return
-    // tecINSUFFICIENT_FUNDS
-    if (spendableAmount < amount)
-        return tecINSUFFICIENT_FUNDS;
-
-    // If the amount is not addable to the balance, return tecPRECISION_LOSS
-    if (!canAdd(spendableAmount, amount))
-        return tecPRECISION_LOSS;
-
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowCreatePreclaimHelper<MPTIssue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecNO_PERMISSION
-    if (issuer == account)
-        return tecNO_PERMISSION;
-
-    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
-    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
-    auto const sleIssuance = ctx.view.read(issuanceKey);
-    if (!sleIssuance)
-        return tecOBJECT_NOT_FOUND;
-
-    // If the lsfMPTCanEscrow is not enabled, return tecNO_PERMISSION
-    if (!sleIssuance->isFlag(lsfMPTCanEscrow))
-        return tecNO_PERMISSION;
-
-    // If the issuer is not the same as the issuer of the mpt, return
-    // tecNO_PERMISSION
-    if (sleIssuance->getAccountID(sfIssuer) != issuer)
-        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
-
-    // If the account does not have the mpt, return tecOBJECT_NOT_FOUND
-    if (!ctx.view.exists(keylet::mptoken(issuanceKey.key, account)))
-        return tecOBJECT_NOT_FOUND;
-
-    // If the issuer has requireAuth set, check if the account is
-    // authorized
-    auto const& mptIssue = amount.get<MPTIssue>();
-    if (auto const ter = requireAuth(ctx.view, mptIssue, account, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has requireAuth set, check if the destination is
-    // authorized
-    if (auto const ter = requireAuth(ctx.view, mptIssue, dest, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has frozen the account, return tecLOCKED
-    if (isFrozen(ctx.view, account, mptIssue))
-        return tecLOCKED;
-
-    // If the issuer has frozen the destination, return tecLOCKED
-    if (isFrozen(ctx.view, dest, mptIssue))
-        return tecLOCKED;
-
-    // If the mpt cannot be transferred, return tecNO_AUTH
-    if (auto const ter = canTransfer(ctx.view, mptIssue, account, dest); ter != tesSUCCESS)
-        return ter;
-
-    STAmount const spendableAmount = accountHolds(
-        ctx.view, account, amount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j);
-
-    // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
-    if (spendableAmount <= beast::zero)
-        return tecINSUFFICIENT_FUNDS;
-
-    // If the spendable amount is less than the amount, return
-    // tecINSUFFICIENT_FUNDS
-    if (spendableAmount < amount)
-        return tecINSUFFICIENT_FUNDS;
-
-    return tesSUCCESS;
-}
-
-TER
-EscrowCreate::preclaim(PreclaimContext const& ctx)
-{
-    STAmount const amount{ctx.tx[sfAmount]};
-    AccountID const account{ctx.tx[sfAccount]};
-    AccountID const dest{ctx.tx[sfDestination]};
-
-    auto const sled = ctx.view.read(keylet::account(dest));
-    if (!sled)
-        return tecNO_DST;
-
-    // Pseudo-accounts cannot receive escrow. Note, this is not amendment-gated
-    // because all writes to pseudo-account discriminator fields **are**
-    // amendment gated, hence the behaviour of this check will always match the
-    // currently active amendments.
-    if (isPseudoAccount(sled))
-        return tecNO_PERMISSION;
-
-    if (!isXRP(amount))
-    {
-        if (!ctx.view.rules().enabled(featureTokenEscrow))
-            return temDISABLED;  // LCOV_EXCL_LINE
-
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowCreatePreclaimHelper<T>(ctx, account, dest, amount);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;
-    }
-    return tesSUCCESS;
-}
-
-template <ValidIssueType T>
-static TER
-escrowLockApplyHelper(
-    ApplyView& view,
-    AccountID const& issuer,
-    AccountID const& sender,
-    STAmount const& amount,
-    beast::Journal journal);
-
-template <>
-TER
-escrowLockApplyHelper<Issue>(
-    ApplyView& view,
-    AccountID const& issuer,
-    AccountID const& sender,
-    STAmount const& amount,
-    beast::Journal journal)
-{
-    // Defensive: Issuer cannot create an escrow
-    if (issuer == sender)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    auto const ter = rippleCredit(
-        view, sender, issuer, amount, amount.holds<MPTIssue>() ? false : true, journal);
-    if (ter != tesSUCCESS)
-        return ter;  // LCOV_EXCL_LINE
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowLockApplyHelper<MPTIssue>(
-    ApplyView& view,
-    AccountID const& issuer,
-    AccountID const& sender,
-    STAmount const& amount,
-    beast::Journal journal)
-{
-    // Defensive: Issuer cannot create an escrow
-    if (issuer == sender)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    auto const ter = rippleLockEscrowMPT(view, sender, amount, journal);
-    if (ter != tesSUCCESS)
-        return ter;  // LCOV_EXCL_LINE
-    return tesSUCCESS;
-}
-
-TER
-EscrowCreate::doApply()
-{
-    auto const closeTime = ctx_.view().header().parentCloseTime;
-
-    if (ctx_.tx[~sfCancelAfter] && after(closeTime, ctx_.tx[sfCancelAfter]))
-        return tecNO_PERMISSION;
-
-    if (ctx_.tx[~sfFinishAfter] && after(closeTime, ctx_.tx[sfFinishAfter]))
-        return tecNO_PERMISSION;
-
-    auto const sle = ctx_.view().peek(keylet::account(account_));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    // Check reserve and funds availability
-    STAmount const amount{ctx_.tx[sfAmount]};
-
-    auto const reserve = ctx_.view().fees().accountReserve((*sle)[sfOwnerCount] + 1);
-
-    if (mSourceBalance < reserve)
-        return tecINSUFFICIENT_RESERVE;
-
-    // Check reserve and funds availability
-    if (isXRP(amount))
-    {
-        if (mSourceBalance < reserve + STAmount(amount).xrp())
-            return tecUNFUNDED;
-    }
-
-    // Check destination account
-    {
-        auto const sled = ctx_.view().read(keylet::account(ctx_.tx[sfDestination]));
-        if (!sled)
-            return tecNO_DST;  // LCOV_EXCL_LINE
-        if (((*sled)[sfFlags] & lsfRequireDestTag) && !ctx_.tx[~sfDestinationTag])
-            return tecDST_TAG_NEEDED;
-    }
-
-    // Create escrow in ledger.  Note that we we use the value from the
-    // sequence or ticket.  For more explanation see comments in SeqProxy.h.
-    Keylet const escrowKeylet = keylet::escrow(account_, ctx_.tx.getSeqValue());
-    auto const slep = std::make_shared<SLE>(escrowKeylet);
-    (*slep)[sfAmount] = amount;
-    (*slep)[sfAccount] = account_;
-    (*slep)[~sfCondition] = ctx_.tx[~sfCondition];
-    (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag];
-    (*slep)[sfDestination] = ctx_.tx[sfDestination];
-    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
-    (*slep)[~sfFinishAfter] = ctx_.tx[~sfFinishAfter];
-    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
-
-    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
-    {
-        (*slep)[sfSequence] = ctx_.tx.getSeqValue();
-    }
-
-    if (ctx_.view().rules().enabled(featureTokenEscrow) && !isXRP(amount))
-    {
-        auto const xferRate = transferRate(ctx_.view(), amount);
-        if (xferRate != parityRate)
-            (*slep)[sfTransferRate] = xferRate.value;
-    }
-
-    ctx_.view().insert(slep);
-
-    // Add escrow to sender's owner directory
-    {
-        auto page = ctx_.view().dirInsert(
-            keylet::ownerDir(account_), escrowKeylet, describeOwnerDir(account_));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfOwnerNode] = *page;
-    }
-
-    // If it's not a self-send, add escrow to recipient's owner directory.
-    AccountID const dest = ctx_.tx[sfDestination];
-    if (dest != account_)
-    {
-        auto page =
-            ctx_.view().dirInsert(keylet::ownerDir(dest), escrowKeylet, describeOwnerDir(dest));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfDestinationNode] = *page;
-    }
-
-    // IOU escrow objects are added to the issuer's owner directory to help
-    // track the total locked balance. For MPT, this isn't necessary because the
-    // locked balance is already stored directly in the MPTokenIssuance object.
-    AccountID const issuer = amount.getIssuer();
-    if (!isXRP(amount) && issuer != account_ && issuer != dest && !amount.holds<MPTIssue>())
-    {
-        auto page =
-            ctx_.view().dirInsert(keylet::ownerDir(issuer), escrowKeylet, describeOwnerDir(issuer));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfIssuerNode] = *page;
-    }
-
-    // Deduct owner's balance
-    if (isXRP(amount))
-        (*sle)[sfBalance] = (*sle)[sfBalance] - amount;
-    else
-    {
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowLockApplyHelper<T>(ctx_.view(), issuer, account_, amount, j_);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-        {
-            return ret;  // LCOV_EXCL_LINE
-        }
-    }
-
-    // increment owner count
-    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
-    ctx_.view().update(sle);
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp

@@ -1,372 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/conditions/Condition.h>
-#include <xrpl/conditions/Fulfillment.h>
-#include <xrpl/core/HashRouter.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/tx/transactors/escrow/EscrowFinish.h>
-
-#include <libxrpl/tx/transactors/escrow/EscrowHelpers.h>
-
-namespace xrpl {
-
-// During an EscrowFinish, the transaction must specify both
-// a condition and a fulfillment. We track whether that
-// fulfillment matches and validates the condition.
-constexpr HashRouterFlags SF_CF_INVALID = HashRouterFlags::PRIVATE5;
-constexpr HashRouterFlags SF_CF_VALID = HashRouterFlags::PRIVATE6;
-
-//------------------------------------------------------------------------------
-
-static bool
-checkCondition(Slice f, Slice c)
-{
-    using namespace xrpl::cryptoconditions;
-
-    std::error_code ec;
-
-    auto condition = Condition::deserialize(c, ec);
-    if (!condition)
-        return false;
-
-    auto fulfillment = Fulfillment::deserialize(f, ec);
-    if (!fulfillment)
-        return false;
-
-    return validate(*fulfillment, *condition);
-}
-
-bool
-EscrowFinish::checkExtraFeatures(PreflightContext const& ctx)
-{
-    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
-}
-
-NotTEC
-EscrowFinish::preflight(PreflightContext const& ctx)
-{
-    auto const cb = ctx.tx[~sfCondition];
-    auto const fb = ctx.tx[~sfFulfillment];
-
-    // If you specify a condition, then you must also specify
-    // a fulfillment.
-    if (static_cast<bool>(cb) != static_cast<bool>(fb))
-        return temMALFORMED;
-
-    return tesSUCCESS;
-}
-
-NotTEC
-EscrowFinish::preflightSigValidated(PreflightContext const& ctx)
-{
-    auto const cb = ctx.tx[~sfCondition];
-    auto const fb = ctx.tx[~sfFulfillment];
-
-    if (cb && fb)
-    {
-        auto& router = ctx.registry.getHashRouter();
-
-        auto const id = ctx.tx.getTransactionID();
-        auto const flags = router.getFlags(id);
-
-        // If we haven't checked the condition, check it
-        // now. Whether it passes or not isn't important
-        // in preflight.
-        if (!any(flags & (SF_CF_INVALID | SF_CF_VALID)))
-        {
-            if (checkCondition(*fb, *cb))
-                router.setFlags(id, SF_CF_VALID);
-            else
-                router.setFlags(id, SF_CF_INVALID);
-        }
-    }
-
-    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
-        return err;
-
-    return tesSUCCESS;
-}
-
-XRPAmount
-EscrowFinish::calculateBaseFee(ReadView const& view, STTx const& tx)
-{
-    XRPAmount extraFee{0};
-
-    if (auto const fb = tx[~sfFulfillment])
-    {
-        extraFee += view.fees().base * (32 + (fb->size() / 16));
-    }
-
-    return Transactor::calculateBaseFee(view, tx) + extraFee;
-}
-
-template <ValidIssueType T>
-static TER
-escrowFinishPreclaimHelper(
-    PreclaimContext const& ctx,
-    AccountID const& dest,
-    STAmount const& amount);
-
-template <>
-TER
-escrowFinishPreclaimHelper<Issue>(
-    PreclaimContext const& ctx,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tesSUCCESS
-    if (issuer == dest)
-        return tesSUCCESS;
-
-    // If the issuer has requireAuth set, check if the destination is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), dest); ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has deep frozen the destination, return tecFROZEN
-    if (isDeepFrozen(ctx.view, dest, amount.getCurrency(), amount.getIssuer()))
-        return tecFROZEN;
-
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowFinishPreclaimHelper<MPTIssue>(
-    PreclaimContext const& ctx,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the dest, return tesSUCCESS
-    if (issuer == dest)
-        return tesSUCCESS;
-
-    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
-    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
-    auto const sleIssuance = ctx.view.read(issuanceKey);
-    if (!sleIssuance)
-        return tecOBJECT_NOT_FOUND;
-
-    // If the issuer has requireAuth set, check if the destination is
-    // authorized
-    auto const& mptIssue = amount.get<MPTIssue>();
-    if (auto const ter = requireAuth(ctx.view, mptIssue, dest, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has frozen the destination, return tecLOCKED
-    if (isFrozen(ctx.view, dest, mptIssue))
-        return tecLOCKED;
-
-    return tesSUCCESS;
-}
-
-TER
-EscrowFinish::preclaim(PreclaimContext const& ctx)
-{
-    if (ctx.view.rules().enabled(featureCredentials))
-    {
-        if (auto const err = credentials::valid(ctx.tx, ctx.view, ctx.tx[sfAccount], ctx.j);
-            !isTesSuccess(err))
-            return err;
-    }
-
-    if (ctx.view.rules().enabled(featureTokenEscrow))
-    {
-        auto const k = keylet::escrow(ctx.tx[sfOwner], ctx.tx[sfOfferSequence]);
-        auto const slep = ctx.view.read(k);
-        if (!slep)
-            return tecNO_TARGET;
-
-        AccountID const dest = (*slep)[sfDestination];
-        STAmount const amount = (*slep)[sfAmount];
-
-        if (!isXRP(amount))
-        {
-            if (auto const ret = std::visit(
-                    [&]<typename T>(T const&) {
-                        return escrowFinishPreclaimHelper<T>(ctx, dest, amount);
-                    },
-                    amount.asset().value());
-                !isTesSuccess(ret))
-                return ret;
-        }
-    }
-    return tesSUCCESS;
-}
-
-TER
-EscrowFinish::doApply()
-{
-    auto const k = keylet::escrow(ctx_.tx[sfOwner], ctx_.tx[sfOfferSequence]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-    {
-        if (ctx_.view().rules().enabled(featureTokenEscrow))
-            return tecINTERNAL;  // LCOV_EXCL_LINE
-
-        return tecNO_TARGET;
-    }
-
-    // If a cancel time is present, a finish operation should only succeed prior
-    // to that time.
-    auto const now = ctx_.view().header().parentCloseTime;
-
-    // Too soon: can't execute before the finish time
-    if ((*slep)[~sfFinishAfter] && !after(now, (*slep)[sfFinishAfter]))
-        return tecNO_PERMISSION;
-
-    // Too late: can't execute after the cancel time
-    if ((*slep)[~sfCancelAfter] && after(now, (*slep)[sfCancelAfter]))
-        return tecNO_PERMISSION;
-
-    // Check cryptocondition fulfillment
-    {
-        auto const id = ctx_.tx.getTransactionID();
-        auto flags = ctx_.registry.getHashRouter().getFlags(id);
-
-        auto const cb = ctx_.tx[~sfCondition];
-
-        // It's unlikely that the results of the check will
-        // expire from the hash router, but if it happens,
-        // simply re-run the check.
-        if (cb && !any(flags & (SF_CF_INVALID | SF_CF_VALID)))
-        {
-            // LCOV_EXCL_START
-            auto const fb = ctx_.tx[~sfFulfillment];
-
-            if (!fb)
-                return tecINTERNAL;
-
-            if (checkCondition(*fb, *cb))
-                flags = SF_CF_VALID;
-            else
-                flags = SF_CF_INVALID;
-
-            ctx_.registry.getHashRouter().setFlags(id, flags);
-            // LCOV_EXCL_STOP
-        }
-
-        // If the check failed, then simply return an error
-        // and don't look at anything else.
-        if (any(flags & SF_CF_INVALID))
-            return tecCRYPTOCONDITION_ERROR;
-
-        // Check against condition in the ledger entry:
-        auto const cond = (*slep)[~sfCondition];
-
-        // If a condition wasn't specified during creation,
-        // one shouldn't be included now.
-        if (!cond && cb)
-            return tecCRYPTOCONDITION_ERROR;
-
-        // If a condition was specified during creation of
-        // the suspended payment, the identical condition
-        // must be presented again. We don't check if the
-        // fulfillment matches the condition since we did
-        // that in preflight.
-        if (cond && (cond != cb))
-            return tecCRYPTOCONDITION_ERROR;
-    }
-
-    // NOTE: Escrow payments cannot be used to fund accounts.
-    AccountID const destID = (*slep)[sfDestination];
-    auto const sled = ctx_.view().peek(keylet::account(destID));
-    if (!sled)
-        return tecNO_DST;
-
-    if (auto err = verifyDepositPreauth(ctx_.tx, ctx_.view(), account_, destID, sled, ctx_.journal);
-        !isTesSuccess(err))
-        return err;
-
-    AccountID const account = (*slep)[sfAccount];
-
-    // Remove escrow from owner directory
-    {
-        auto const page = (*slep)[sfOwnerNode];
-        if (!ctx_.view().dirRemove(keylet::ownerDir(account), page, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from owner.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Remove escrow from recipient's owner directory, if present.
-    if (auto const optPage = (*slep)[~sfDestinationNode])
-    {
-        if (!ctx_.view().dirRemove(keylet::ownerDir(destID), *optPage, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    STAmount const amount = slep->getFieldAmount(sfAmount);
-    // Transfer amount to destination
-    if (isXRP(amount))
-        (*sled)[sfBalance] = (*sled)[sfBalance] + amount;
-    else
-    {
-        if (!ctx_.view().rules().enabled(featureTokenEscrow))
-            return temDISABLED;  // LCOV_EXCL_LINE
-
-        Rate lockedRate = slep->isFieldPresent(sfTransferRate)
-            ? xrpl::Rate(slep->getFieldU32(sfTransferRate))
-            : parityRate;
-        auto const issuer = amount.getIssuer();
-        bool const createAsset = destID == account_;
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowUnlockApplyHelper<T>(
-                        ctx_.view(),
-                        lockedRate,
-                        sled,
-                        mPriorBalance,
-                        amount,
-                        issuer,
-                        account,
-                        destID,
-                        createAsset,
-                        j_);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;
-
-        // Remove escrow from issuers owner directory, if present.
-        if (auto const optPage = (*slep)[~sfIssuerNode]; optPage)
-        {
-            if (!ctx_.view().dirRemove(keylet::ownerDir(issuer), *optPage, k.key, true))
-            {
-                // LCOV_EXCL_START
-                JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-                return tefBAD_LEDGER;
-                // LCOV_EXCL_STOP
-            }
-        }
-    }
-
-    ctx_.view().update(sled);
-
-    // Adjust source owner count
-    auto const sle = ctx_.view().peek(keylet::account(account));
-    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
-    ctx_.view().update(sle);
-
-    // Remove escrow from ledger
-    ctx_.view().erase(slep);
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/escrow/EscrowHelpers.h

@@ -1,229 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/MPTAmount.h>
-#include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
-
-namespace xrpl {
-
-template <ValidIssueType T>
-TER
-escrowUnlockApplyHelper(
-    ApplyView& view,
-    Rate lockedRate,
-    std::shared_ptr<SLE> const& sleDest,
-    STAmount const& xrpBalance,
-    STAmount const& amount,
-    AccountID const& issuer,
-    AccountID const& sender,
-    AccountID const& receiver,
-    bool createAsset,
-    beast::Journal journal);
-
-template <>
-inline TER
-escrowUnlockApplyHelper<Issue>(
-    ApplyView& view,
-    Rate lockedRate,
-    std::shared_ptr<SLE> const& sleDest,
-    STAmount const& xrpBalance,
-    STAmount const& amount,
-    AccountID const& issuer,
-    AccountID const& sender,
-    AccountID const& receiver,
-    bool createAsset,
-    beast::Journal journal)
-{
-    Keylet const trustLineKey = keylet::line(receiver, amount.issue());
-    bool const recvLow = issuer > receiver;
-    bool const senderIssuer = issuer == sender;
-    bool const receiverIssuer = issuer == receiver;
-    bool const issuerHigh = issuer > receiver;
-
-    if (senderIssuer)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    if (receiverIssuer)
-        return tesSUCCESS;
-
-    if (!view.exists(trustLineKey) && createAsset && !receiverIssuer)
-    {
-        // Can the account cover the trust line's reserve?
-        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
-            xrpBalance < view.fees().accountReserve(ownerCount + 1))
-        {
-            JLOG(journal.trace()) << "Trust line does not exist. "
-                                     "Insufficient reserve to create line.";
-
-            return tecNO_LINE_INSUF_RESERVE;
-        }
-
-        Currency const currency = amount.getCurrency();
-        STAmount initialBalance(amount.issue());
-        initialBalance.setIssuer(noAccount());
-
-        // clang-format off
-        if (TER const ter = trustCreate(
-                view,                           // payment sandbox
-                recvLow,                        // is dest low?
-                issuer,                         // source
-                receiver,                       // destination
-                trustLineKey.key,               // ledger index
-                sleDest,                        // Account to add to
-                false,                          // authorize account
-                (sleDest->getFlags() & lsfDefaultRipple) == 0,
-                false,                          // freeze trust line
-                false,                          // deep freeze trust line
-                initialBalance,                 // zero initial balance
-                Issue(currency, receiver),      // limit of zero
-                0,                              // quality in
-                0,                              // quality out
-                journal);                       // journal
-            !isTesSuccess(ter))
-        {
-            return ter; // LCOV_EXCL_LINE
-        }
-        // clang-format on
-
-        view.update(sleDest);
-    }
-
-    if (!view.exists(trustLineKey) && !receiverIssuer)
-        return tecNO_LINE;
-
-    auto const xferRate = transferRate(view, amount);
-    // update if issuer rate is less than locked rate
-    if (xferRate < lockedRate)
-        lockedRate = xferRate;
-
-    // Transfer Rate only applies when:
-    // 1. Issuer is not involved in the transfer (senderIssuer or
-    // receiverIssuer)
-    // 2. The locked rate is different from the parity rate
-
-    // NOTE: Transfer fee in escrow works a bit differently from a normal
-    // payment. In escrow, the fee is deducted from the locked/sending amount,
-    // whereas in a normal payment, the transfer fee is taken on top of the
-    // sending amount.
-    auto finalAmt = amount;
-    if ((!senderIssuer && !receiverIssuer) && lockedRate != parityRate)
-    {
-        // compute transfer fee, if any
-        auto const xferFee = amount.value() - divideRound(amount, lockedRate, amount.issue(), true);
-        // compute balance to transfer
-        finalAmt = amount.value() - xferFee;
-    }
-
-    // validate the line limit if the account submitting txn is not the receiver
-    // of the funds
-    if (!createAsset)
-    {
-        auto const sleRippleState = view.peek(trustLineKey);
-        if (!sleRippleState)
-            return tecINTERNAL;  // LCOV_EXCL_LINE
-
-        // if the issuer is the high, then we use the low limit
-        // otherwise we use the high limit
-        STAmount const lineLimit =
-            sleRippleState->getFieldAmount(issuerHigh ? sfLowLimit : sfHighLimit);
-
-        STAmount lineBalance = sleRippleState->getFieldAmount(sfBalance);
-
-        // flip the sign of the line balance if the issuer is not high
-        if (!issuerHigh)
-            lineBalance.negate();
-
-        // add the final amount to the line balance
-        lineBalance += finalAmt;
-
-        // if the transfer would exceed the line limit return tecLIMIT_EXCEEDED
-        if (lineLimit < lineBalance)
-            return tecLIMIT_EXCEEDED;
-    }
-
-    // if destination is not the issuer then transfer funds
-    if (!receiverIssuer)
-    {
-        auto const ter = rippleCredit(view, issuer, receiver, finalAmt, true, journal);
-        if (ter != tesSUCCESS)
-            return ter;  // LCOV_EXCL_LINE
-    }
-    return tesSUCCESS;
-}
-
-template <>
-inline TER
-escrowUnlockApplyHelper<MPTIssue>(
-    ApplyView& view,
-    Rate lockedRate,
-    std::shared_ptr<SLE> const& sleDest,
-    STAmount const& xrpBalance,
-    STAmount const& amount,
-    AccountID const& issuer,
-    AccountID const& sender,
-    AccountID const& receiver,
-    bool createAsset,
-    beast::Journal journal)
-{
-    bool const senderIssuer = issuer == sender;
-    bool const receiverIssuer = issuer == receiver;
-
-    auto const mptID = amount.get<MPTIssue>().getMptID();
-    auto const issuanceKey = keylet::mptIssuance(mptID);
-    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && createAsset && !receiverIssuer)
-    {
-        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
-            xrpBalance < view.fees().accountReserve(ownerCount + 1))
-        {
-            return tecINSUFFICIENT_RESERVE;
-        }
-
-        if (auto const ter = MPTokenAuthorize::createMPToken(view, mptID, receiver, 0);
-            !isTesSuccess(ter))
-        {
-            return ter;  // LCOV_EXCL_LINE
-        }
-
-        // update owner count.
-        adjustOwnerCount(view, sleDest, 1, journal);
-    }
-
-    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && !receiverIssuer)
-        return tecNO_PERMISSION;
-
-    auto const xferRate = transferRate(view, amount);
-    // update if issuer rate is less than locked rate
-    if (xferRate < lockedRate)
-        lockedRate = xferRate;
-
-    // Transfer Rate only applies when:
-    // 1. Issuer is not involved in the transfer (senderIssuer or
-    // receiverIssuer)
-    // 2. The locked rate is different from the parity rate
-
-    // NOTE: Transfer fee in escrow works a bit differently from a normal
-    // payment. In escrow, the fee is deducted from the locked/sending amount,
-    // whereas in a normal payment, the transfer fee is taken on top of the
-    // sending amount.
-    auto finalAmt = amount;
-    if ((!senderIssuer && !receiverIssuer) && lockedRate != parityRate)
-    {
-        // compute transfer fee, if any
-        auto const xferFee = amount.value() - divideRound(amount, lockedRate, amount.asset(), true);
-        // compute balance to transfer
-        finalAmt = amount.value() - xferFee;
-    }
-    return rippleUnlockEscrowMPT(
-        view,
-        sender,
-        receiver,
-        finalAmt,
-        view.rules().enabled(fixTokenEscrowV1) ? amount : finalAmt,
-        journal);
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/payment_channel/PayChan.cpp

@@ -0,0 +1,542 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/chrono.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/PayChan.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/protocol/digest.h>
+#include <xrpl/tx/transactors/payment_channel/PayChan.h>
+
+namespace xrpl {
+
+/*
+    PaymentChannel
+
+        Payment channels permit off-ledger checkpoints of XRP payments flowing
+        in a single direction. A channel sequesters the owner's XRP in its own
+        ledger entry. The owner can authorize the recipient to claim up to a
+        given balance by giving the receiver a signed message (off-ledger). The
+        recipient can use this signed message to claim any unpaid balance while
+        the channel remains open. The owner can top off the line as needed. If
+        the channel has not paid out all its funds, the owner must wait out a
+        delay to close the channel to give the recipient a chance to supply any
+        claims. The recipient can close the channel at any time. Any transaction
+        that touches the channel after the expiration time will close the
+        channel. The total amount paid increases monotonically as newer claims
+        are issued. When the channel is closed any remaining balance is returned
+        to the owner. Channels are intended to permit intermittent off-ledger
+        settlement of ILP trust lines as balances get substantial. For
+        bidirectional channels, a payment channel can be used in each direction.
+
+    PaymentChannelCreate
+
+        Create a unidirectional channel. The parameters are:
+        Destination
+            The recipient at the end of the channel.
+        Amount
+            The amount of XRP to deposit in the channel immediately.
+        SettleDelay
+            The amount of time everyone but the recipient must wait for a
+            superior claim.
+        PublicKey
+            The key that will sign claims against the channel.
+        CancelAfter (optional)
+            Any channel transaction that touches this channel after the
+            `CancelAfter` time will close it.
+        DestinationTag (optional)
+            Destination tags allow the different accounts inside of a Hosted
+            Wallet to be mapped back onto the Ripple ledger. The destination tag
+            tells the server to which account in the Hosted Wallet the funds are
+            intended to go to. Required if the destination has lsfRequireDestTag
+            set.
+        SourceTag (optional)
+            Source tags allow the different accounts inside of a Hosted Wallet
+            to be mapped back onto the Ripple ledger. Source tags are similar to
+            destination tags but are for the channel owner to identify their own
+            transactions.
+
+    PaymentChannelFund
+
+        Add additional funds to the payment channel. Only the channel owner may
+        use this transaction. The parameters are:
+        Channel
+            The 256-bit ID of the channel.
+        Amount
+            The amount of XRP to add.
+        Expiration (optional)
+            Time the channel closes. The transaction will fail if the expiration
+            times does not satisfy the SettleDelay constraints.
+
+    PaymentChannelClaim
+
+        Place a claim against an existing channel. The parameters are:
+        Channel
+            The 256-bit ID of the channel.
+        Balance (optional)
+            The total amount of XRP delivered after this claim is processed
+   (optional, not needed if just closing). Amount (optional) The amount of XRP
+   the signature is for (not needed if equal to Balance or just closing the
+   line). Signature (optional) Authorization for the balance above, signed by
+   the owner (optional, not needed if closing or owner is performing the
+   transaction). The signature if for the following message: CLM\0 followed by
+   the 256-bit channel ID, and a 64-bit integer drops. PublicKey (optional) The
+   public key that made the signature (optional, required if a signature is
+   present) Flags tfClose Request that the channel be closed tfRenew Request
+   that the channel's expiration be reset. Only the owner may renew a channel.
+
+*/
+
+//------------------------------------------------------------------------------
+
+static TER
+closeChannel(
+    std::shared_ptr<SLE> const& slep,
+    ApplyView& view,
+    uint256 const& key,
+    beast::Journal j)
+{
+    AccountID const src = (*slep)[sfAccount];
+    // Remove PayChan from owner directory
+    {
+        auto const page = (*slep)[sfOwnerNode];
+        if (!view.dirRemove(keylet::ownerDir(src), page, key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j.fatal()) << "Could not remove paychan from src owner directory";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    // Remove PayChan from recipient's owner directory, if present.
+    if (auto const page = (*slep)[~sfDestinationNode])
+    {
+        auto const dst = (*slep)[sfDestination];
+        if (!view.dirRemove(keylet::ownerDir(dst), *page, key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j.fatal()) << "Could not remove paychan from dst owner directory";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    // Transfer amount back to owner, decrement owner count
+    auto const sle = view.peek(keylet::account(src));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    XRPL_ASSERT(
+        (*slep)[sfAmount] >= (*slep)[sfBalance], "xrpl::closeChannel : minimum channel amount");
+    (*sle)[sfBalance] = (*sle)[sfBalance] + (*slep)[sfAmount] - (*slep)[sfBalance];
+    adjustOwnerCount(view, sle, -1, j);
+    view.update(sle);
+
+    // Remove PayChan from ledger
+    view.erase(slep);
+    return tesSUCCESS;
+}
+
+//------------------------------------------------------------------------------
+
+TxConsequences
+PayChanCreate::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
+}
+
+NotTEC
+PayChanCreate::preflight(PreflightContext const& ctx)
+{
+    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
+        return temBAD_AMOUNT;
+
+    if (ctx.tx[sfAccount] == ctx.tx[sfDestination])
+        return temDST_IS_SRC;
+
+    if (!publicKeyType(ctx.tx[sfPublicKey]))
+        return temMALFORMED;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanCreate::preclaim(PreclaimContext const& ctx)
+{
+    auto const account = ctx.tx[sfAccount];
+    auto const sle = ctx.view.read(keylet::account(account));
+    if (!sle)
+        return terNO_ACCOUNT;
+
+    // Check reserve and funds availability
+    {
+        auto const balance = (*sle)[sfBalance];
+        auto const reserve = ctx.view.fees().accountReserve((*sle)[sfOwnerCount] + 1);
+
+        if (balance < reserve)
+            return tecINSUFFICIENT_RESERVE;
+
+        if (balance < reserve + ctx.tx[sfAmount])
+            return tecUNFUNDED;
+    }
+
+    auto const dst = ctx.tx[sfDestination];
+
+    {
+        // Check destination account
+        auto const sled = ctx.view.read(keylet::account(dst));
+        if (!sled)
+            return tecNO_DST;
+
+        auto const flags = sled->getFlags();
+
+        // Check if they have disallowed incoming payment channels
+        if (flags & lsfDisallowIncomingPayChan)
+            return tecNO_PERMISSION;
+
+        if ((flags & lsfRequireDestTag) && !ctx.tx[~sfDestinationTag])
+            return tecDST_TAG_NEEDED;
+
+        // Pseudo-accounts cannot receive payment channels, other than native
+        // to their underlying ledger object - implemented in their respective
+        // transaction types. Note, this is not amendment-gated because all
+        // writes to pseudo-account discriminator fields **are** amendment
+        // gated, hence the behaviour of this check will always match the
+        // currently active amendments.
+        if (isPseudoAccount(sled))
+            return tecNO_PERMISSION;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanCreate::doApply()
+{
+    auto const account = ctx_.tx[sfAccount];
+    auto const sle = ctx_.view().peek(keylet::account(account));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    if (ctx_.view().rules().enabled(fixPayChanCancelAfter))
+    {
+        auto const closeTime = ctx_.view().header().parentCloseTime;
+        if (ctx_.tx[~sfCancelAfter] && after(closeTime, ctx_.tx[sfCancelAfter]))
+            return tecEXPIRED;
+    }
+
+    auto const dst = ctx_.tx[sfDestination];
+
+    // Create PayChan in ledger.
+    //
+    // Note that we we use the value from the sequence or ticket as the
+    // payChan sequence.  For more explanation see comments in SeqProxy.h.
+    Keylet const payChanKeylet = keylet::payChan(account, dst, ctx_.tx.getSeqValue());
+    auto const slep = std::make_shared<SLE>(payChanKeylet);
+
+    // Funds held in this channel
+    (*slep)[sfAmount] = ctx_.tx[sfAmount];
+    // Amount channel has already paid
+    (*slep)[sfBalance] = ctx_.tx[sfAmount].zeroed();
+    (*slep)[sfAccount] = account;
+    (*slep)[sfDestination] = dst;
+    (*slep)[sfSettleDelay] = ctx_.tx[sfSettleDelay];
+    (*slep)[sfPublicKey] = ctx_.tx[sfPublicKey];
+    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
+    (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag];
+    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
+    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
+    {
+        (*slep)[sfSequence] = ctx_.tx.getSeqValue();
+    }
+
+    ctx_.view().insert(slep);
+
+    // Add PayChan to owner directory
+    {
+        auto const page = ctx_.view().dirInsert(
+            keylet::ownerDir(account), payChanKeylet, describeOwnerDir(account));
+        if (!page)
+            return tecDIR_FULL;  // LCOV_EXCL_LINE
+        (*slep)[sfOwnerNode] = *page;
+    }
+
+    // Add PayChan to the recipient's owner directory
+    {
+        auto const page =
+            ctx_.view().dirInsert(keylet::ownerDir(dst), payChanKeylet, describeOwnerDir(dst));
+        if (!page)
+            return tecDIR_FULL;  // LCOV_EXCL_LINE
+        (*slep)[sfDestinationNode] = *page;
+    }
+
+    // Deduct owner's balance, increment owner count
+    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
+    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
+    ctx_.view().update(sle);
+
+    return tesSUCCESS;
+}
+
+//------------------------------------------------------------------------------
+
+TxConsequences
+PayChanFund::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
+}
+
+NotTEC
+PayChanFund::preflight(PreflightContext const& ctx)
+{
+    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
+        return temBAD_AMOUNT;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanFund::doApply()
+{
+    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
+    auto const slep = ctx_.view().peek(k);
+    if (!slep)
+        return tecNO_ENTRY;
+
+    AccountID const src = (*slep)[sfAccount];
+    auto const txAccount = ctx_.tx[sfAccount];
+    auto const expiration = (*slep)[~sfExpiration];
+
+    {
+        auto const cancelAfter = (*slep)[~sfCancelAfter];
+        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
+        if ((cancelAfter && closeTime >= *cancelAfter) || (expiration && closeTime >= *expiration))
+            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
+    }
+
+    if (src != txAccount)
+        // only the owner can add funds or extend
+        return tecNO_PERMISSION;
+
+    if (auto extend = ctx_.tx[~sfExpiration])
+    {
+        auto minExpiration = ctx_.view().header().parentCloseTime.time_since_epoch().count() +
+            (*slep)[sfSettleDelay];
+        if (expiration && *expiration < minExpiration)
+            minExpiration = *expiration;
+
+        if (*extend < minExpiration)
+            return temBAD_EXPIRATION;
+        (*slep)[~sfExpiration] = *extend;
+        ctx_.view().update(slep);
+    }
+
+    auto const sle = ctx_.view().peek(keylet::account(txAccount));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    {
+        // Check reserve and funds availability
+        auto const balance = (*sle)[sfBalance];
+        auto const reserve = ctx_.view().fees().accountReserve((*sle)[sfOwnerCount]);
+
+        if (balance < reserve)
+            return tecINSUFFICIENT_RESERVE;
+
+        if (balance < reserve + ctx_.tx[sfAmount])
+            return tecUNFUNDED;
+    }
+
+    // do not allow adding funds if dst does not exist
+    if (AccountID const dst = (*slep)[sfDestination]; !ctx_.view().read(keylet::account(dst)))
+    {
+        return tecNO_DST;
+    }
+
+    (*slep)[sfAmount] = (*slep)[sfAmount] + ctx_.tx[sfAmount];
+    ctx_.view().update(slep);
+
+    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
+    ctx_.view().update(sle);
+
+    return tesSUCCESS;
+}
+
+//------------------------------------------------------------------------------
+
+bool
+PayChanClaim::checkExtraFeatures(PreflightContext const& ctx)
+{
+    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
+}
+
+std::uint32_t
+PayChanClaim::getFlagsMask(PreflightContext const&)
+{
+    return tfPaymentChannelClaimMask;
+}
+
+NotTEC
+PayChanClaim::preflight(PreflightContext const& ctx)
+{
+    auto const bal = ctx.tx[~sfBalance];
+    if (bal && (!isXRP(*bal) || *bal <= beast::zero))
+        return temBAD_AMOUNT;
+
+    auto const amt = ctx.tx[~sfAmount];
+    if (amt && (!isXRP(*amt) || *amt <= beast::zero))
+        return temBAD_AMOUNT;
+
+    if (bal && amt && *bal > *amt)
+        return temBAD_AMOUNT;
+
+    {
+        auto const flags = ctx.tx.getFlags();
+
+        if ((flags & tfClose) && (flags & tfRenew))
+            return temMALFORMED;
+    }
+
+    if (auto const sig = ctx.tx[~sfSignature])
+    {
+        if (!(ctx.tx[~sfPublicKey] && bal))
+            return temMALFORMED;
+
+        // Check the signature
+        // The signature isn't needed if txAccount == src, but if it's
+        // present, check it
+
+        auto const reqBalance = bal->xrp();
+        auto const authAmt = amt ? amt->xrp() : reqBalance;
+
+        if (reqBalance > authAmt)
+            return temBAD_AMOUNT;
+
+        Keylet const k(ltPAYCHAN, ctx.tx[sfChannel]);
+        if (!publicKeyType(ctx.tx[sfPublicKey]))
+            return temMALFORMED;
+
+        PublicKey const pk(ctx.tx[sfPublicKey]);
+        Serializer msg;
+        serializePayChanAuthorization(msg, k.key, authAmt);
+        if (!verify(pk, msg.slice(), *sig))
+            return temBAD_SIGNATURE;
+    }
+
+    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
+        return err;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanClaim::preclaim(PreclaimContext const& ctx)
+{
+    if (!ctx.view.rules().enabled(featureCredentials))
+        return Transactor::preclaim(ctx);
+
+    if (auto const err = credentials::valid(ctx.tx, ctx.view, ctx.tx[sfAccount], ctx.j);
+        !isTesSuccess(err))
+        return err;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanClaim::doApply()
+{
+    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
+    auto const slep = ctx_.view().peek(k);
+    if (!slep)
+        return tecNO_TARGET;
+
+    AccountID const src = (*slep)[sfAccount];
+    AccountID const dst = (*slep)[sfDestination];
+    AccountID const txAccount = ctx_.tx[sfAccount];
+
+    auto const curExpiration = (*slep)[~sfExpiration];
+    {
+        auto const cancelAfter = (*slep)[~sfCancelAfter];
+        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
+        if ((cancelAfter && closeTime >= *cancelAfter) ||
+            (curExpiration && closeTime >= *curExpiration))
+            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
+    }
+
+    if (txAccount != src && txAccount != dst)
+        return tecNO_PERMISSION;
+
+    if (ctx_.tx[~sfBalance])
+    {
+        auto const chanBalance = slep->getFieldAmount(sfBalance).xrp();
+        auto const chanFunds = slep->getFieldAmount(sfAmount).xrp();
+        auto const reqBalance = ctx_.tx[sfBalance].xrp();
+
+        if (txAccount == dst && !ctx_.tx[~sfSignature])
+            return temBAD_SIGNATURE;
+
+        if (ctx_.tx[~sfSignature])
+        {
+            PublicKey const pk((*slep)[sfPublicKey]);
+            if (ctx_.tx[sfPublicKey] != pk)
+                return temBAD_SIGNER;
+        }
+
+        if (reqBalance > chanFunds)
+            return tecUNFUNDED_PAYMENT;
+
+        if (reqBalance <= chanBalance)
+            // nothing requested
+            return tecUNFUNDED_PAYMENT;
+
+        auto const sled = ctx_.view().peek(keylet::account(dst));
+        if (!sled)
+            return tecNO_DST;
+
+        if (auto err =
+                verifyDepositPreauth(ctx_.tx, ctx_.view(), txAccount, dst, sled, ctx_.journal);
+            !isTesSuccess(err))
+            return err;
+
+        (*slep)[sfBalance] = ctx_.tx[sfBalance];
+        XRPAmount const reqDelta = reqBalance - chanBalance;
+        XRPL_ASSERT(reqDelta >= beast::zero, "xrpl::PayChanClaim::doApply : minimum balance delta");
+        (*sled)[sfBalance] = (*sled)[sfBalance] + reqDelta;
+        ctx_.view().update(sled);
+        ctx_.view().update(slep);
+    }
+
+    if (ctx_.tx.getFlags() & tfRenew)
+    {
+        if (src != txAccount)
+            return tecNO_PERMISSION;
+        (*slep)[~sfExpiration] = std::nullopt;
+        ctx_.view().update(slep);
+    }
+
+    if (ctx_.tx.getFlags() & tfClose)
+    {
+        // Channel will close immediately if dry or the receiver closes
+        if (dst == txAccount || (*slep)[sfBalance] == (*slep)[sfAmount])
+            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
+
+        auto const settleExpiration =
+            ctx_.view().header().parentCloseTime.time_since_epoch().count() +
+            (*slep)[sfSettleDelay];
+
+        if (!curExpiration || *curExpiration > settleExpiration)
+        {
+            (*slep)[~sfExpiration] = settleExpiration;
+            ctx_.view().update(slep);
+        }
+    }
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl

src/libxrpl/tx/transactors/payment_channel/PayChanClaim.cpp

@@ -1,186 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/PayChan.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/payment_channel/PayChanClaim.h>
-
-#include <libxrpl/tx/transactors/payment_channel/PayChanHelpers.h>
-
-namespace xrpl {
-
-bool
-PayChanClaim::checkExtraFeatures(PreflightContext const& ctx)
-{
-    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
-}
-
-std::uint32_t
-PayChanClaim::getFlagsMask(PreflightContext const&)
-{
-    return tfPaymentChannelClaimMask;
-}
-
-NotTEC
-PayChanClaim::preflight(PreflightContext const& ctx)
-{
-    auto const bal = ctx.tx[~sfBalance];
-    if (bal && (!isXRP(*bal) || *bal <= beast::zero))
-        return temBAD_AMOUNT;
-
-    auto const amt = ctx.tx[~sfAmount];
-    if (amt && (!isXRP(*amt) || *amt <= beast::zero))
-        return temBAD_AMOUNT;
-
-    if (bal && amt && *bal > *amt)
-        return temBAD_AMOUNT;
-
-    {
-        auto const flags = ctx.tx.getFlags();
-
-        if ((flags & tfClose) && (flags & tfRenew))
-            return temMALFORMED;
-    }
-
-    if (auto const sig = ctx.tx[~sfSignature])
-    {
-        if (!(ctx.tx[~sfPublicKey] && bal))
-            return temMALFORMED;
-
-        // Check the signature
-        // The signature isn't needed if txAccount == src, but if it's
-        // present, check it
-
-        auto const reqBalance = bal->xrp();
-        auto const authAmt = amt ? amt->xrp() : reqBalance;
-
-        if (reqBalance > authAmt)
-            return temBAD_AMOUNT;
-
-        Keylet const k(ltPAYCHAN, ctx.tx[sfChannel]);
-        if (!publicKeyType(ctx.tx[sfPublicKey]))
-            return temMALFORMED;
-
-        PublicKey const pk(ctx.tx[sfPublicKey]);
-        Serializer msg;
-        serializePayChanAuthorization(msg, k.key, authAmt);
-        if (!verify(pk, msg.slice(), *sig))
-            return temBAD_SIGNATURE;
-    }
-
-    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
-        return err;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanClaim::preclaim(PreclaimContext const& ctx)
-{
-    if (!ctx.view.rules().enabled(featureCredentials))
-        return Transactor::preclaim(ctx);
-
-    if (auto const err = credentials::valid(ctx.tx, ctx.view, ctx.tx[sfAccount], ctx.j);
-        !isTesSuccess(err))
-        return err;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanClaim::doApply()
-{
-    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-        return tecNO_TARGET;
-
-    AccountID const src = (*slep)[sfAccount];
-    AccountID const dst = (*slep)[sfDestination];
-    AccountID const txAccount = ctx_.tx[sfAccount];
-
-    auto const curExpiration = (*slep)[~sfExpiration];
-    {
-        auto const cancelAfter = (*slep)[~sfCancelAfter];
-        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
-        if ((cancelAfter && closeTime >= *cancelAfter) ||
-            (curExpiration && closeTime >= *curExpiration))
-            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
-    }
-
-    if (txAccount != src && txAccount != dst)
-        return tecNO_PERMISSION;
-
-    if (ctx_.tx[~sfBalance])
-    {
-        auto const chanBalance = slep->getFieldAmount(sfBalance).xrp();
-        auto const chanFunds = slep->getFieldAmount(sfAmount).xrp();
-        auto const reqBalance = ctx_.tx[sfBalance].xrp();
-
-        if (txAccount == dst && !ctx_.tx[~sfSignature])
-            return temBAD_SIGNATURE;
-
-        if (ctx_.tx[~sfSignature])
-        {
-            PublicKey const pk((*slep)[sfPublicKey]);
-            if (ctx_.tx[sfPublicKey] != pk)
-                return temBAD_SIGNER;
-        }
-
-        if (reqBalance > chanFunds)
-            return tecUNFUNDED_PAYMENT;
-
-        if (reqBalance <= chanBalance)
-            // nothing requested
-            return tecUNFUNDED_PAYMENT;
-
-        auto const sled = ctx_.view().peek(keylet::account(dst));
-        if (!sled)
-            return tecNO_DST;
-
-        if (auto err =
-                verifyDepositPreauth(ctx_.tx, ctx_.view(), txAccount, dst, sled, ctx_.journal);
-            !isTesSuccess(err))
-            return err;
-
-        (*slep)[sfBalance] = ctx_.tx[sfBalance];
-        XRPAmount const reqDelta = reqBalance - chanBalance;
-        XRPL_ASSERT(reqDelta >= beast::zero, "xrpl::PayChanClaim::doApply : minimum balance delta");
-        (*sled)[sfBalance] = (*sled)[sfBalance] + reqDelta;
-        ctx_.view().update(sled);
-        ctx_.view().update(slep);
-    }
-
-    if (ctx_.tx.getFlags() & tfRenew)
-    {
-        if (src != txAccount)
-            return tecNO_PERMISSION;
-        (*slep)[~sfExpiration] = std::nullopt;
-        ctx_.view().update(slep);
-    }
-
-    if (ctx_.tx.getFlags() & tfClose)
-    {
-        // Channel will close immediately if dry or the receiver closes
-        if (dst == txAccount || (*slep)[sfBalance] == (*slep)[sfAmount])
-            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
-
-        auto const settleExpiration =
-            ctx_.view().header().parentCloseTime.time_since_epoch().count() +
-            (*slep)[sfSettleDelay];
-
-        if (!curExpiration || *curExpiration > settleExpiration)
-        {
-            (*slep)[~sfExpiration] = settleExpiration;
-            ctx_.view().update(slep);
-        }
-    }
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/payment_channel/PayChanCreate.cpp

@@ -1,173 +0,0 @@
-#include <xrpl/basics/chrono.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/tx/transactors/payment_channel/PayChanCreate.h>
-
-namespace xrpl {
-
-/*
-    PaymentChannel
-
-        Payment channels permit off-ledger checkpoints of XRP payments flowing
-        in a single direction. A channel sequesters the owner's XRP in its own
-        ledger entry. The owner can authorize the recipient to claim up to a
-        given balance by giving the receiver a signed message (off-ledger). The
-        recipient can use this signed message to claim any unpaid balance while
-        the channel remains open. The owner can top off the line as needed. If
-        the channel has not paid out all its funds, the owner must wait out a
-        delay to close the channel to give the recipient a chance to supply any
-        claims. The recipient can close the channel at any time. Any transaction
-        that touches the channel after the expiration time will close the
-        channel. The total amount paid increases monotonically as newer claims
-        are issued. When the channel is closed any remaining balance is returned
-        to the owner. Channels are intended to permit intermittent off-ledger
-        settlement of ILP trust lines as balances get substantial. For
-        bidirectional channels, a payment channel can be used in each direction.
-*/
-
-//------------------------------------------------------------------------------
-
-TxConsequences
-PayChanCreate::makeTxConsequences(PreflightContext const& ctx)
-{
-    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
-}
-
-NotTEC
-PayChanCreate::preflight(PreflightContext const& ctx)
-{
-    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
-        return temBAD_AMOUNT;
-
-    if (ctx.tx[sfAccount] == ctx.tx[sfDestination])
-        return temDST_IS_SRC;
-
-    if (!publicKeyType(ctx.tx[sfPublicKey]))
-        return temMALFORMED;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanCreate::preclaim(PreclaimContext const& ctx)
-{
-    auto const account = ctx.tx[sfAccount];
-    auto const sle = ctx.view.read(keylet::account(account));
-    if (!sle)
-        return terNO_ACCOUNT;
-
-    // Check reserve and funds availability
-    {
-        auto const balance = (*sle)[sfBalance];
-        auto const reserve = ctx.view.fees().accountReserve((*sle)[sfOwnerCount] + 1);
-
-        if (balance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-
-        if (balance < reserve + ctx.tx[sfAmount])
-            return tecUNFUNDED;
-    }
-
-    auto const dst = ctx.tx[sfDestination];
-
-    {
-        // Check destination account
-        auto const sled = ctx.view.read(keylet::account(dst));
-        if (!sled)
-            return tecNO_DST;
-
-        auto const flags = sled->getFlags();
-
-        // Check if they have disallowed incoming payment channels
-        if (flags & lsfDisallowIncomingPayChan)
-            return tecNO_PERMISSION;
-
-        if ((flags & lsfRequireDestTag) && !ctx.tx[~sfDestinationTag])
-            return tecDST_TAG_NEEDED;
-
-        // Pseudo-accounts cannot receive payment channels, other than native
-        // to their underlying ledger object - implemented in their respective
-        // transaction types. Note, this is not amendment-gated because all
-        // writes to pseudo-account discriminator fields **are** amendment
-        // gated, hence the behaviour of this check will always match the
-        // currently active amendments.
-        if (isPseudoAccount(sled))
-            return tecNO_PERMISSION;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanCreate::doApply()
-{
-    auto const account = ctx_.tx[sfAccount];
-    auto const sle = ctx_.view().peek(keylet::account(account));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    if (ctx_.view().rules().enabled(fixPayChanCancelAfter))
-    {
-        auto const closeTime = ctx_.view().header().parentCloseTime;
-        if (ctx_.tx[~sfCancelAfter] && after(closeTime, ctx_.tx[sfCancelAfter]))
-            return tecEXPIRED;
-    }
-
-    auto const dst = ctx_.tx[sfDestination];
-
-    // Create PayChan in ledger.
-    //
-    // Note that we we use the value from the sequence or ticket as the
-    // payChan sequence.  For more explanation see comments in SeqProxy.h.
-    Keylet const payChanKeylet = keylet::payChan(account, dst, ctx_.tx.getSeqValue());
-    auto const slep = std::make_shared<SLE>(payChanKeylet);
-
-    // Funds held in this channel
-    (*slep)[sfAmount] = ctx_.tx[sfAmount];
-    // Amount channel has already paid
-    (*slep)[sfBalance] = ctx_.tx[sfAmount].zeroed();
-    (*slep)[sfAccount] = account;
-    (*slep)[sfDestination] = dst;
-    (*slep)[sfSettleDelay] = ctx_.tx[sfSettleDelay];
-    (*slep)[sfPublicKey] = ctx_.tx[sfPublicKey];
-    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
-    (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag];
-    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
-    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
-    {
-        (*slep)[sfSequence] = ctx_.tx.getSeqValue();
-    }
-
-    ctx_.view().insert(slep);
-
-    // Add PayChan to owner directory
-    {
-        auto const page = ctx_.view().dirInsert(
-            keylet::ownerDir(account), payChanKeylet, describeOwnerDir(account));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfOwnerNode] = *page;
-    }
-
-    // Add PayChan to the recipient's owner directory
-    {
-        auto const page =
-            ctx_.view().dirInsert(keylet::ownerDir(dst), payChanKeylet, describeOwnerDir(dst));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfDestinationNode] = *page;
-    }
-
-    // Deduct owner's balance, increment owner count
-    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
-    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
-    ctx_.view().update(sle);
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/payment_channel/PayChanFund.cpp

@@ -1,92 +0,0 @@
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/tx/transactors/payment_channel/PayChanFund.h>
-
-#include <libxrpl/tx/transactors/payment_channel/PayChanHelpers.h>
-
-namespace xrpl {
-
-TxConsequences
-PayChanFund::makeTxConsequences(PreflightContext const& ctx)
-{
-    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
-}
-
-NotTEC
-PayChanFund::preflight(PreflightContext const& ctx)
-{
-    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
-        return temBAD_AMOUNT;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanFund::doApply()
-{
-    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-        return tecNO_ENTRY;
-
-    AccountID const src = (*slep)[sfAccount];
-    auto const txAccount = ctx_.tx[sfAccount];
-    auto const expiration = (*slep)[~sfExpiration];
-
-    {
-        auto const cancelAfter = (*slep)[~sfCancelAfter];
-        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
-        if ((cancelAfter && closeTime >= *cancelAfter) || (expiration && closeTime >= *expiration))
-            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
-    }
-
-    if (src != txAccount)
-        // only the owner can add funds or extend
-        return tecNO_PERMISSION;
-
-    if (auto extend = ctx_.tx[~sfExpiration])
-    {
-        auto minExpiration = ctx_.view().header().parentCloseTime.time_since_epoch().count() +
-            (*slep)[sfSettleDelay];
-        if (expiration && *expiration < minExpiration)
-            minExpiration = *expiration;
-
-        if (*extend < minExpiration)
-            return temBAD_EXPIRATION;
-        (*slep)[~sfExpiration] = *extend;
-        ctx_.view().update(slep);
-    }
-
-    auto const sle = ctx_.view().peek(keylet::account(txAccount));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    {
-        // Check reserve and funds availability
-        auto const balance = (*sle)[sfBalance];
-        auto const reserve = ctx_.view().fees().accountReserve((*sle)[sfOwnerCount]);
-
-        if (balance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-
-        if (balance < reserve + ctx_.tx[sfAmount])
-            return tecUNFUNDED;
-    }
-
-    // do not allow adding funds if dst does not exist
-    if (AccountID const dst = (*slep)[sfDestination]; !ctx_.view().read(keylet::account(dst)))
-    {
-        return tecNO_DST;
-    }
-
-    (*slep)[sfAmount] = (*slep)[sfAmount] + ctx_.tx[sfAmount];
-    ctx_.view().update(slep);
-
-    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
-    ctx_.view().update(sle);
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.cpp

@@ -1,58 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Indexes.h>
-
-#include <libxrpl/tx/transactors/payment_channel/PayChanHelpers.h>
-
-namespace xrpl {
-
-TER
-closeChannel(
-    std::shared_ptr<SLE> const& slep,
-    ApplyView& view,
-    uint256 const& key,
-    beast::Journal j)
-{
-    AccountID const src = (*slep)[sfAccount];
-    // Remove PayChan from owner directory
-    {
-        auto const page = (*slep)[sfOwnerNode];
-        if (!view.dirRemove(keylet::ownerDir(src), page, key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j.fatal()) << "Could not remove paychan from src owner directory";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Remove PayChan from recipient's owner directory, if present.
-    if (auto const page = (*slep)[~sfDestinationNode])
-    {
-        auto const dst = (*slep)[sfDestination];
-        if (!view.dirRemove(keylet::ownerDir(dst), *page, key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j.fatal()) << "Could not remove paychan from dst owner directory";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Transfer amount back to owner, decrement owner count
-    auto const sle = view.peek(keylet::account(src));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    XRPL_ASSERT(
-        (*slep)[sfAmount] >= (*slep)[sfBalance], "xrpl::closeChannel : minimum channel amount");
-    (*sle)[sfBalance] = (*sle)[sfBalance] + (*slep)[sfAmount] - (*slep)[sfBalance];
-    adjustOwnerCount(view, sle, -1, j);
-    view.update(sle);
-
-    // Remove PayChan from ledger
-    view.erase(slep);
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl

src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/protocol/UintTypes.h>
-
-namespace xrpl {
-
-TER
-closeChannel(
-    std::shared_ptr<SLE> const& slep,
-    ApplyView& view,
-    uint256 const& key,
-    beast::Journal j);
-
-}  // namespace xrpl

src/test/app/HashRouter_test.cpp

@@ -388,33 +388,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
@@ -427,7 +400,6 @@ public:
         testProcess();
         testSetup();
         testFlagsOps();
-        testProcessPeer();
     }
 };
 

src/test/app/LedgerReplay_test.cpp

@@ -296,11 +296,6 @@ public:
     {
         return false;
     }
-    std::set<std::optional<uint64_t>>
-    releaseRequestCookies(uint256 const& requestHash) override
-    {
-        return {};
-    }
 
     std::string const&
     fingerprint() const override

src/test/jtx/TrustedPublisherServer.h

@@ -129,7 +129,7 @@ public:
 
     // TrustedPublisherServer must be accessed through a shared_ptr.
     // This constructor is only public so std::make_shared has access.
-    // The function `make_TrustedPublisherServer` should be used to create
+    // The function`make_TrustedPublisherServer` should be used to create
     // instances.
     // The `futures` member is expected to be structured as
     // effective / expiration time point pairs for use in version 2 UNLs
@@ -249,7 +249,7 @@ public:
     {
         error_code ec;
         acceptor_.close(ec);
-        // TODO: consider making this join
+        // TODO consider making this join
         // any running do_peer threads
     }
 

src/test/overlay/ProtocolVersion_test.cpp

@@ -66,8 +66,8 @@ public:
                 negotiateProtocolVersion("RTXP/1.2, XRPL/2.0, XRPL/2.1") == make_protocol(2, 1));
             BEAST_EXPECT(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));
+                negotiateProtocolVersion("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);
             BEAST_EXPECT(negotiateProtocolVersion("") == std::nullopt);
         }

src/test/overlay/reduce_relay_test.cpp

@@ -167,11 +167,6 @@ public:
     removeTxQueue(uint256 const&) override
     {
     }
-    std::set<std::optional<uint64_t>>
-    releaseRequestCookies(uint256 const& requestHash) override
-    {
-        return {};
-    }
 };
 
 /** Manually advanced clock. */

src/test/protocol/STTx_test.cpp

@@ -1474,7 +1474,7 @@ public:
         // Signer {
         //     Account: "...",
         //     TxnSignature: "...",
-        //     PublicKey: "..."
+        //     PublicKey: "...""
         // }
         // Make one well formed Signer and several mal-formed ones.  See
         // whether the serializer lets the good one through and catches

src/xrpld/app/consensus/RCLConsensus.cpp

@@ -983,7 +983,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

src/xrpld/app/ledger/InboundLedger.h

@@ -172,22 +172,4 @@ 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

src/xrpld/app/ledger/detail/InboundLedger.cpp

@@ -353,14 +353,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;
 

src/xrpld/app/ledger/detail/InboundLedgers.cpp

@@ -2,9 +2,9 @@
 #include <xrpld/app/ledger/LedgerMaster.h>
 #include <xrpld/app/main/Application.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>
@@ -54,78 +54,10 @@ public:
             XRPL_ASSERT(
                 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;
@@ -133,7 +65,6 @@ public:
                 ScopedLockType sl(mLock);
                 if (stopping_)
                 {
-                    JLOG(j_.debug()) << "Abort(stopping): " << ss.str();
                     return {};
                 }
 
@@ -152,51 +83,47 @@ 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(doAcquire, "InboundLedgersImp::acquire", 500ms, j_);
+        std::shared_ptr<Ledger const> ledger =
+            perf::measureDurationAndLog(doAcquire, "InboundLedgersImp::acquire", 500ms, j_);
+
+        return ledger;
     }
 
     void
     acquireAsync(uint256 const& hash, 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>

src/xrpld/app/ledger/detail/LedgerMaster.cpp

@@ -907,9 +907,8 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
         return;
     }
 
-    JLOG(m_journal.info()) << "Advancing accepted ledger to " << ledger->header().seq << " ("
-                           << to_short_string(ledger->header().hash) << ") with >= " << minVal
-                           << " validations";
+    JLOG(m_journal.info()) << "Advancing accepted ledger to " << ledger->header().seq
+                           << " with >= " << minVal << " validations";
 
     ledger->setValidated();
     ledger->setFull();

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,7 +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) {
         if (ec == boost::asio::error::operation_aborted)
@@ -42,10 +40,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);
         }

src/xrpld/app/ledger/detail/TimeoutCounter.h

@@ -3,7 +3,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>
@@ -104,7 +103,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_;
 

src/xrpld/app/misc/NetworkOPs.cpp

@@ -30,10 +30,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/HashRouter.h>
 #include <xrpl/core/NetworkIDService.h>
@@ -397,7 +397,7 @@ public:
     isFull() override;
 
     void
-    setMode(OperatingMode om, char const* reason) override;
+    setMode(OperatingMode om) override;
 
     bool
     isBlocked() override;
@@ -842,7 +842,7 @@ NetworkOPsImp::strOperatingMode(bool const admin /* = false */) const
 inline void
 NetworkOPsImp::setStandAlone()
 {
-    setMode(OperatingMode::FULL, "setStandAlone");
+    setMode(OperatingMode::FULL);
 }
 
 inline void
@@ -985,7 +985,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_ << ").";
@@ -1009,7 +1009,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 << " peers. ";
         }
@@ -1019,9 +1019,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)
         {
@@ -1711,7 +1711,7 @@ void
 NetworkOPsImp::setAmendmentBlocked()
 {
     amendmentBlocked_ = true;
-    setMode(OperatingMode::CONNECTED, "setAmendmentBlocked");
+    setMode(OperatingMode::CONNECTED);
 }
 
 inline bool
@@ -1742,7 +1742,7 @@ void
 NetworkOPsImp::setUNLBlocked()
 {
     unlBlocked_ = true;
-    setMode(OperatingMode::CONNECTED, "setUNLBlocked");
+    setMode(OperatingMode::CONNECTED);
 }
 
 inline void
@@ -1838,7 +1838,7 @@ NetworkOPsImp::checkLastClosedLedger(Overlay::PeerSequence const& peerList, uint
 
     if ((mMode == OperatingMode::TRACKING) || (mMode == OperatingMode::FULL))
     {
-        setMode(OperatingMode::CONNECTED, "check LCL: not on consensus ledger");
+        setMode(OperatingMode::CONNECTED);
     }
 
     if (consensus)
@@ -1923,8 +1923,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. ";
         }
 
@@ -2053,7 +2053,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) || (mMode == OperatingMode::TRACKING)) &&
@@ -2066,7 +2066,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
         if (registry_.timeKeeper().now() <
             (current->header().parentCloseTime + 2 * current->header().closeTimeResolution))
         {
-            setMode(OperatingMode::FULL, "endConsensus: check full");
+            setMode(OperatingMode::FULL);
         }
     }
 
@@ -2078,7 +2078,7 @@ NetworkOPsImp::consensusViewChange()
 {
     if ((mMode == OperatingMode::FULL) || (mMode == OperatingMode::TRACKING))
     {
-        setMode(OperatingMode::CONNECTED, "consensusViewChange");
+        setMode(OperatingMode::CONNECTED);
     }
 }
 
@@ -2380,7 +2380,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)
@@ -2400,12 +2400,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();
 }
 
@@ -2414,24 +2413,32 @@ NetworkOPsImp::recvValidation(std::shared_ptr<STValidation> const& val, std::str
 {
     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(registry_.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(registry_.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);
 

src/xrpld/overlay/Peer.h

@@ -17,7 +17,6 @@ enum class ProtocolFeature {
     ValidatorListPropagation,
     ValidatorList2Propagation,
     LedgerReplay,
-    LedgerDataCookies
 };
 
 /** Represents a peer connection in the overlay. */
@@ -117,13 +116,6 @@ public:
 
     virtual bool
     txReduceRelayEnabled() const = 0;
-
-    //
-    // Messages
-    //
-
-    virtual std::set<std::optional<uint64_t>>
-    releaseRequestCookies(uint256 const& requestHash) = 0;
 };
 
 }  // namespace xrpl

src/xrpld/overlay/detail/PeerImp.cpp

@@ -7,7 +7,6 @@
 #include <xrpld/app/misc/ValidatorList.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
@@ -476,8 +473,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;
 }
@@ -1399,9 +1394,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()};
@@ -1475,68 +1469,11 @@ 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, "RcvGetLedger", [weak, m, messageHash]() {
+    app_.getJobQueue().addJob(jtLEDGER_REQ, "RcvGetLedger", [weak, m]() {
         if (auto peer = weak.lock())
-            peer->processLedgerRequest(m, messageHash);
+            peer->processLedgerRequest(m);
     });
 }
 
@@ -1635,9 +1572,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;
     };
 
@@ -1684,96 +1620,23 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMLedgerData> const& m)
         return badData("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)
     {
@@ -3083,21 +2946,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;
@@ -3116,18 +2974,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;
@@ -3141,8 +2997,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";
 
@@ -3172,92 +3027,14 @@ 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;
 
@@ -3273,30 +3050,16 @@ PeerImp::getLedger(std::shared_ptr<protocol::TMGetLedger> const& m, uint256 cons
             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);
-                        }))
+                        overlay_, ledgerHash, m->has_ledgerseq() ? m->ledgerseq() : 0, 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;
+                    JLOG(p_journal_.debug()) << "getLedger: Request relayed to peer";
                     return ledger;
                 }
 
-                JLOG(p_journal_.trace())
-                    << "getLedger: Don't have ledger with hash " << ledgerHash << ": " << mHash;
+                JLOG(p_journal_.trace()) << "getLedger: Failed to find peer to relay request";
             }
         }
     }
@@ -3305,15 +3068,15 @@ PeerImp::getLedger(std::shared_ptr<protocol::TMGetLedger> const& m, uint256 cons
         // Attempt to find ledger by sequence
         if (m->ledgerseq() < app_.getLedgerMaster().getEarliestFetch())
         {
-            JLOG(p_journal_.debug()) << "getLedger: Early ledger sequence request " << mHash;
+            JLOG(p_journal_.debug()) << "getLedger: Early ledger sequence request";
         }
         else
         {
             ledger = app_.getLedgerMaster().getLedgerBySeq(m->ledgerseq());
             if (!ledger)
             {
-                JLOG(p_journal_.debug()) << "getLedger: Don't have ledger with sequence "
-                                         << m->ledgerseq() << ": " << mHash;
+                JLOG(p_journal_.debug())
+                    << "getLedger: Don't have ledger with sequence " << m->ledgerseq();
             }
         }
     }
@@ -3335,29 +3098,27 @@ PeerImp::getLedger(std::shared_ptr<protocol::TMGetLedger> const& m, uint256 cons
                     charge(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;
+            JLOG(p_journal_.debug()) << "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{app_.getInboundTransactions().getSet(txSetHash, false)};
@@ -3366,28 +3127,20 @@ PeerImp::getTxSet(std::shared_ptr<protocol::TMGetLedger> const& m, uint256 const
         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;
+                JLOG(p_journal_.debug()) << "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";
         }
     }
 
@@ -3395,7 +3148,7 @@ PeerImp::getTxSet(std::shared_ptr<protocol::TMGetLedger> const& m, uint256 const
 }
 
 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())
@@ -3408,72 +3161,9 @@ PeerImp::processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m, u
     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();
 
@@ -3481,6 +3171,8 @@ PeerImp::processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m, u
         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;
@@ -3498,12 +3190,7 @@ PeerImp::processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m, u
             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
@@ -3511,11 +3198,13 @@ PeerImp::processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m, u
         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:
@@ -3624,7 +3313,7 @@ PeerImp::processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m, u
     if (ledgerData.nodes_size() == 0)
         return;
 
-    sendToMultiple(ledgerData, destinations);
+    send(std::make_shared<Message>(ledgerData, protocol::mtLEDGER_DATA));
 }
 
 int
@@ -3672,19 +3361,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)
 {

src/xrpld/overlay/detail/PeerImp.h

@@ -247,13 +247,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
@@ -496,13 +489,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.
@@ -798,22 +784,16 @@ private:
         std::shared_ptr<protocol::TMValidation> const& packet);
 
     void
-    sendLedgerBase(
-        std::shared_ptr<Ledger const> const& ledger,
-        protocol::TMLedgerData& ledgerData,
-        PeerCookieMap const& destinations);
-
-    void
-    sendToMultiple(protocol::TMLedgerData& ledgerData, PeerCookieMap const& destinations);
+    sendLedgerBase(std::shared_ptr<Ledger const> const& ledger, 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);
 };
 
 //------------------------------------------------------------------------------

src/xrpld/overlay/detail/PeerSet.cpp

@@ -2,9 +2,7 @@
 #include <xrpld/overlay/Overlay.h>
 #include <xrpld/overlay/PeerSet.h>
 
-#include <xrpl/core/HashRouter.h>
 #include <xrpl/core/JobQueue.h>
-#include <xrpl/protocol/digest.h>
 
 namespace xrpl {
 
@@ -84,45 +82,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);
     }
 }
 

src/xrpld/overlay/detail/ProtocolMessage.h

@@ -23,12 +23,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&)
 {
@@ -438,63 +432,3 @@ invokeProtocolMessage(Buffers const& buffers, Handler& handler, std::size_t& hin
 }
 
 }  // namespace xrpl
-
-namespace protocol {
-
-template <class Hasher>
-void
-hash_append(Hasher& h, TMGetLedger const& msg)
-{
-    using beast::hash_append;
-    using namespace xrpl;
-    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 xrpl;
-    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

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